Const Types Pattern (REQUIRED)
typescript
// ✅ 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)
typescript
// ✅ 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
typescript
// ✅ 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
typescript
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
typescript
function isUser(value: unknown): value is User {
return (
typeof value === 'object' &&
value !== null &&
'id' in value &&
'name' in value
)
}
Import Types
typescript
import type { User } from '@/types'
import { createUser, type Config } from './utils'