typescript-pro Checked

Implements advanced TypeScript type systems, creates custom type guards, utility types, and branded types, and configures tRPC for end-to-end type safety. Use when building TypeScript applications requiring advanced generics, conditional or mapped types, discriminated unions, monorepo setup, or full-stack type safety with tRPC.

TypeScript Pro

Implements advanced TypeScript type systems, creates custom type guards, utility types, and branded types, and configures tRPC for end-to-end type safety. Use when building TypeScript applications requiring advanced generics, conditional or mapped types, discriminated unions, monorepo setup, or full-stack type safety with tRPC.

TypeScript Pro

Core Workflow

1. **Analyze type architecture** - Review tsconfig, type coverage, build performance

2. **Design type-first APIs** - Create branded types, generics, utility types

3. **Implement with type safety** - Write type guards, discriminated unions, conditional types; run tsc --noEmit to catch type errors before proceeding

4. **Optimize build** - Configure project references, incremental compilation, tree shaking; re-run tsc --noEmit to confirm zero errors after changes

5. **Test types** - Confirm type coverage with a tool like type-coverage; validate that all public APIs have explicit return types; iterate on steps 3–4 until all checks pass

Reference Guide

Load detailed guidance based on context:

| Topic | Reference | Load When |

|-------|-----------|-----------|

| Advanced Types | references/advanced-types.md | Generics, conditional types, mapped types, template literals |

| Type Guards | references/type-guards.md | Type narrowing, discriminated unions, assertion functions |

| Utility Types | references/utility-types.md | Partial, Pick, Omit, Record, custom utilities |

| Configuration | references/configuration.md | tsconfig options, strict mode, project references |

| Patterns | references/patterns.md | Builder pattern, factory pattern, type-safe APIs |

Code Examples

### Branded Types

// Branded type for domain modeling
type Brand<T, B extends string> = T & { readonly __brand: B };
type UserId  = Brand<string, "UserId">;
type OrderId = Brand<number, "OrderId">;

const toUserId  = (id: string): UserId  => id as UserId;
const toOrderId = (id: number): OrderId => id as OrderId;

// Usage — prevents accidental id mix-ups at compile time
function getOrder(userId: UserId, orderId: OrderId) { /* ... */ }

### Discriminated Unions & Type Guards

type LoadingState = { status: "loading" };
type SuccessState = { status: "success"; data: string[] };
type ErrorState   = { status: "error";   error: Error };
type RequestState = LoadingState | SuccessState | ErrorState;

// Type predicate guard
function isSuccess(state: RequestState): state is SuccessState {
  return state.status === "success";
}

// Exhaustive switch with discriminated union
function renderState(state: RequestState): string {
  switch (state.status) {
    case "loading": return "Loading…";
    case "success": return state.data.join(", ");
    case "error":   return state.error.message;
    default: {
      const _exhaustive: never = state;
      throw new Error(`Unhandled state: ${_exhaustive}`);
    }
  }
}