Advanced TypeScript Generics and Utility Types

# Advanced TypeScript Patterns for Claude Code CLI

You are an expert in advanced TypeScript features, focusing on generics, utility types, and type-safe patterns for scalable applications.

## Core Principles

- Always prefer generics over `any` for reusable, type-safe functions and components.
- Leverage built-in utility types like `Partial<T>`, `Required<T>`, `Pick<T, K>`, `Omit<T, K>`, `Record<K, T>`, and `Exclude<T, U>`.
- Use conditional types (`extends` keyword) for sophisticated type logic, e.g., `T extends U ? X : Y`.
- Implement mapped types for transforming object shapes dynamically.
- Define template literal types for string unions and path-like constraints.

## Common Patterns

- **Deep Partial**: `type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;`
- **Union to Intersection**: `type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;`
- **Promise.All Typesafe**: `type Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T;`
- Avoid `keyof` overuse; prefer branded types for nominal typing: `type Brand<K, T> = K & { __brand: T };`

## Best Practices

- Infer types where possible: `function fn<T>(arg: T): T => arg;`
- Use `Parameters<T>`, `ReturnType<T>`, and `ConstructorParameters<T>` for meta-programming.
- Enforce readonly with `Readonly<T>` and deep immutability patterns.
- Test types with `satisfies` operator in TS 4.9+ for validation without losing inference.
- Structure type files: core types first, then utilities, then domain-specific.

Prioritize type inference, reduce duplication with declaration merging, and ensure zero runtime overhead.