// Old way: type annotation loses specific info
const config: Record<string, string | number> = {
  host: 'localhost',
  port: 3000,
  debug: 'true',
};

config.host.toUpperCase(); // ❌ Error! TypeScript thinks it could be number
config.port.toFixed(2);    // ❌ Error! TypeScript thinks it could be string

// New way: satisfies validates but preserves the specific type
const config = {
  host: 'localhost',
  port: 3000,
  debug: 'true',
} satisfies Record<string, string | number>;

config.host.toUpperCase(); // ✅ TypeScript knows it's a string
config.port.toFixed(2);    // ✅ TypeScript knows it's a number

// Validate route definitions
type RouteConfig = {
  path: string;
  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
  requiresAuth: boolean;
};

const routes = {
  getUsers: { path: '/users', method: 'GET', requiresAuth: true },
  createUser: { path: '/users', method: 'POST', requiresAuth: true },
  health: { path: '/health', method: 'GET', requiresAuth: false },
  // TypeScript validates each route has the correct shape
} satisfies Record<string, RouteConfig>;

// But you also get auto-complete on specific routes!
routes.health.requiresAuth; // ✅ TypeScript knows this is boolean

// Validate theme objects
type Color = `#${string}` | `rgb(${number}, ${number}, ${number})`;

const theme = {
  primary: '#3B82F6',
  secondary: '#6B7280',
  danger: '#EF4444',
  background: 'rgb(255, 255, 255)',
} satisfies Record<string, Color>;

// theme.primary is typed as '#3B82F6', not just string!
type PrimaryColor = typeof theme.primary; // '#3B82F6'

// Build complex string types from combinations
type EventName = 'click' | 'focus' | 'blur' | 'submit';
type EventHandler = `on${Capitalize<EventName>}`;
// = 'onClick' | 'onFocus' | 'onBlur' | 'onSubmit'

type CSSUnit = 'px' | 'rem' | 'em' | 'vw' | 'vh' | '%';
type CSSValue = `${number}${CSSUnit}`;
// Valid: '16px', '1.5rem', '100%', etc.

// HTTP API pattern
type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
type APIEndpoint = `/api/v${number}/${string}`;
type FullRoute = `${HTTPMethod} ${APIEndpoint}`;
// Valid: 'GET /api/v1/users', 'POST /api/v2/orders', etc.

type EventMap = {
  'user:created': { id: string; email: string };
  'user:deleted': { id: string };
  'order:placed': { orderId: string; amount: number };
  'order:shipped': { orderId: string; trackingNumber: string };
};

class TypedEventEmitter<T extends Record<string, any>> {
  private handlers: Partial<{ [K in keyof T]: Array<(data: T[K]) => void> }> = {};

  on<K extends keyof T>(event: K, handler: (data: T[K]) => void): void {
    if (!this.handlers[event]) {
      this.handlers[event] = [];
    }
    this.handlers[event]!.push(handler);
  }

  emit<K extends keyof T>(event: K, data: T[K]): void {
    this.handlers[event]?.forEach(handler => handler(data));
  }
}

const emitter = new TypedEventEmitter<EventMap>();

// ✅ Fully type-safe!
emitter.on('user:created', ({ id, email }) => {
  console.log(`New user ${id}: ${email}`);
});

emitter.emit('user:created', { id: '123', email: 'test@example.com' });

// ❌ TypeScript error — wrong event shape
emitter.emit('user:created', { id: '123' }); // Missing email

// ❌ TypeScript error — wrong event name
emitter.on('user:updated', (data) => {}); // 'user:updated' doesn't exist

// Extract promise return type
type Awaited<T> = T extends Promise<infer U> ? Awaited<U> : T;
// Built-in since TS 4.5, but understanding it is key

// Extract function parameters
type Parameters<T extends (...args: any) => any> = 
  T extends (...args: infer P) => any ? P : never;

// Real pattern: Make all nested properties optional
type DeepPartial<T> = T extends object
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : T;

// Make specific keys required while keeping rest optional
type RequiredKeys<T, K extends keyof T> = T & Required<Pick<T, K>>;

interface UserCreate {
  name?: string;
  email?: string;
  role?: 'admin' | 'user';
}

type ValidUserCreate = RequiredKeys<UserCreate, 'name' | 'email'>;
// name and email are required, role is still optional

// Model API responses with discriminated unions
type ApiResult<T> = 
  | { status: 'success'; data: T; timestamp: number }
  | { status: 'error'; error: string; code: number }
  | { status: 'loading' };

function handleResult<T>(result: ApiResult<T>): T | null {
  switch (result.status) {
    case 'success':
      return result.data;        // ✅ TypeScript knows data exists
    case 'error':
      console.error(result.error); // ✅ TypeScript knows error and code exist
      return null;
    case 'loading':
      return null;
  }
  // TypeScript ensures exhaustive - no need for default case!
}

// Even better: use the never type to enforce exhaustiveness
function assertNever(x: never): never {
  throw new Error(`Unhandled case: ${JSON.stringify(x)}`);
}

function handleResultStrict<T>(result: ApiResult<T>): T | null {
  switch (result.status) {
    case 'success': return result.data;
    case 'error': return null;
    case 'loading': return null;
    default: return assertNever(result); // Compile error if new case added!
  }
}

function process(value: string | null) {
  if (!value) return;
  
  // Before 5.4: TypeScript forgot the narrowing in setTimeout
  setTimeout(() => {
    console.log(value.toUpperCase()); // ✅ In 5.4+, TypeScript knows it's string
  }, 1000);
}

// Problem: TypeScript infers T from multiple places, causing unexpected widening
function createState<T>(initial: T, fallback: T): [T, T] {
  return [initial, fallback];
}

// TypeScript infers T as string | number (unwanted)
const [s, f] = createState('hello', 0);

// Solution: NoInfer prevents inference from fallback
function createStateBetter<T>(initial: T, fallback: NoInfer<T>): [T, T] {
  return [initial, fallback];
}

// ❌ Now TypeScript errors — fallback must match initial's type
const [s2, f2] = createStateBetter('hello', 0);

// ✅ This works
const [s3, f3] = createStateBetter<string | number>('hello', 0);

// Build pipe/compose with full type safety
type Fn<A, B> = (a: A) => B;

// Pipe for 2 functions
function pipe<A, B, C>(f: Fn<A, B>, g: Fn<B, C>): Fn<A, C>;
// Pipe for 3 functions
function pipe<A, B, C, D>(f: Fn<A, B>, g: Fn<B, C>, h: Fn<C, D>): Fn<A, D>;

// Variadic version using tuple types
type PipeArgs<T extends readonly Fn<any, any>[]> = {
  [K in keyof T]: T[K] extends Fn<infer A, infer B> ? Fn<A, B> : never;
};

// Practical middleware pattern
type Middleware<T, U = T> = (ctx: T, next: () => Promise<U>) => Promise<U>;

function compose<T>(...middlewares: Middleware<T>[]): Middleware<T> {
  return async (ctx, next) => {
    let index = -1;
    
    const dispatch = async (i: number): Promise<T> => {
      if (i <= index) throw new Error('next() called multiple times');
      index = i;
      
      const fn = i === middlewares.length ? next : middlewares[i];
      return fn(ctx, () => dispatch(i + 1));
    };
    
    return dispatch(0);
  };
}

// Type-safe query builder pattern
type TableSchema = {
  users: { id: number; name: string; email: string; createdAt: Date };
  orders: { id: number; userId: number; amount: number; status: 'pending' | 'shipped' | 'delivered' };
  products: { id: number; name: string; price: number; inventory: number };
};

type TableName = keyof TableSchema;
type ColumnOf<T extends TableName> = keyof TableSchema[T] & string;

class TypedQueryBuilder<T extends TableName, TSelect extends ColumnOf<T>> {
  select<K extends ColumnOf<T>>(
    ...columns: K[]
  ): TypedQueryBuilder<T, K> {
    return this as any;
  }
  
  where<K extends ColumnOf<T>>(
    column: K,
    value: TableSchema[T][K]
  ): this {
    return this;
  }
  
  async execute(): Promise<Pick<TableSchema[T], TSelect>[]> {
    // Implementation
    return [] as any;
  }
}

function from<T extends TableName>(table: T): TypedQueryBuilder<T, never> {
  return new TypedQueryBuilder();
}

// Usage — fully type-safe!
const results = await from('users')
  .select('id', 'name', 'email')
  .where('id', 42)    // ✅ 42 is valid for id (number)
  .execute();
// results is: { id: number; name: string; email: string }[]

// ❌ TypeScript errors:
from('users').where('id', 'not-a-number'); // id expects number
from('users').select('notAColumn');         // not a valid column
from('orders').where('status', 'cancelled'); // 'cancelled' not in union

// Create nominal types to prevent mixing up IDs
declare const __brand: unique symbol;
type Brand<T, B> = T & { [__brand]: B };

type UserId = Brand<string, 'UserId'>;
type OrderId = Brand<string, 'OrderId'>;
type ProductId = Brand<string, 'ProductId'>;

// Factory functions
const UserId = (id: string): UserId => id as UserId;
const OrderId = (id: string): OrderId => id as OrderId;

// Functions that require specific types
function getUser(id: UserId): Promise<User> { /* ... */ }
function getOrder(id: OrderId): Promise<Order> { /* ... */ }

const userId = UserId('user_123');
const orderId = OrderId('order_456');

getUser(userId);    // ✅
getOrder(orderId);  // ✅
getUser(orderId);   // ❌ TypeScript error! OrderId ≠ UserId
getOrder(userId);   // ❌ TypeScript error! UserId ≠ OrderId

// Even though they're both strings at runtime:
const plain = 'user_123';
getUser(plain);     // ❌ TypeScript error! plain string ≠ UserId