Const Types Pattern (REQUIRED)

// ✅ ALWAYS: Create const object first, then extract type const STATUS = { ACTIVE: "active", INACTIVE: "inactive", PENDING: "pending", } as const;

type Status = (typeof STATUS)[keyof typeof STATUS];

// ❌ NEVER: Direct union types type Status = "active" | "inactive" | "pending";

Why? Single source of truth, runtime values, autocomplete, easier refactoring.

Flat Interfaces (REQUIRED)

// ✅ ALWAYS: One level depth, nested objects → dedicated interface interface UserAddress { street: string; city: string; }

interface User { id: string; name: string; address: UserAddress; // Reference, not inline }

interface Admin extends User { permissions: string[]; }

// ❌ NEVER: Inline nested objects interface User { address: { street: string; city: string }; // NO! }

Never Use any

// ✅ Use unknown for truly unknown types function parse(input: unknown): User { if (isUser(input)) return input; throw new Error("Invalid input"); }

// ✅ Use generics for flexible types function first<T>(arr: T[]): T | undefined { return arr[0]; }

// ❌ NEVER function parse(input: any): any {}

Utility Types

Pick<User, "id" | "name">; // Select fields Omit<User, "id">; // Exclude fields Partial<User>; // All optional Required<User>; // All required Readonly<User>; // All readonly Record<string, User>; // Object type Extract<Union, "a" | "b">; // Extract from union Exclude<Union, "a">; // Exclude from union NonNullable<T | null>; // Remove null/undefined ReturnType<typeof fn>; // Function return type Parameters<typeof fn>; // Function params tuple

Type Guards

function isUser(value: unknown): value is User { return ( typeof value === "object" && value !== null && "id" in value && "name" in value ); }

Import Types

import type { User } from "./types"; import { createUser, type Config } from "./utils";