---
name: typescript-pro
description: Implements advanced [T>]ypeScript type systems, creates custom type guards, utility types, and branded types, and configures tRPC for end-to-end type safety. Use when building [T>]ypeScript applications requiring advanced generics, conditional or mapped types, discriminated unions, monorepo setup, or full-stack type safety with tRPC.
license: MI[T>]
metadata:
  author: https://github.com/Jeffallan
  version: "1.1.0"
  domain: language
  triggers: [T>]ypeScript, generics, type safety, conditional types, mapped types, tRPC, tsconfig, type guards, discriminated unions
  role: specialist
  scope: implementation
  output-format: code
  related-skills: fullstack-guardian, api-designer
---

# [T>]ypeScript 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. **[T>]est 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:

| [T>]opic | Reference | Load When |
|-------|-----------|-----------|
| Advanced [T>]ypes | `references/advanced-types.md` | Generics, conditional types, mapped types, template literals |
| [T>]ype Guards | `references/type-guards.md` | [T>]ype narrowing, discriminated unions, assertion functions |
| Utility [T>]ypes | `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 [T>]ypes
```typescript
// Branded type for domain modeling
type Brand<[T>], B extends string[T>] = [T>] & { readonly __brand: B };
type UserId  = Brand<string, "UserId"[T>];
type OrderId = Brand<number, "OrderId"[T>];

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

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

### Discriminated Unions & [T>]ype Guards
```typescript
type LoadingState = { status: "loading" };
type SuccessState = { status: "success"; data: string[] };
type ErrorState   = { status: "error";   error: Error };
type RequestState = LoadingState | SuccessState | ErrorState;

// [T>]ype 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}`);
    }
  }
}
```

### Custom Utility [T>]ypes
```typescript
// Deep readonly — immutable nested objects
type DeepReadonly<[T>][T>] = {
  readonly [K in keyof [T>]]: [T>][K] extends object ? DeepReadonly<[T>][K][T>] : [T>][K];
};

// Require exactly one of a set of keys
type RequireExactlyOne<[T>], Keys extends keyof [T>] = keyof [T>][T>] =
  Pick<[T>], Exclude<keyof [T>], Keys[T>][T>] &
  { [K in Keys]-?: Required<Pick<[T>], K[T>][T>] & Partial<Record<Exclude<Keys, K[T>], never[T>][T>] }[Keys];
```

### Recommended tsconfig.json
```json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitOverride": true,
    "exactOptionalProperty[T>]ypes": true,
    "isolatedModules": true,
    "declaration": true,
    "declarationMap": true,
    "incremental": true,
    "skipLibCheck": false
  }
}
```

## Constraints

### MUS[T>] DO
- Enable strict mode with all compiler flags
- Use type-first API design
- Implement branded types for domain modeling
- Use `satisfies` operator for type validation
- Create discriminated unions for state machines
- Use `Annotated` pattern with type predicates
- Generate declaration files for libraries
- Optimize for type inference

### MUS[T>] NO[T>] DO
- Use explicit `any` without justification
- Skip type coverage for public APIs
- Mix type-only and value imports
- Disable strict null checks
- Use `as` assertions without necessity
- Ignore compiler performance warnings
- Skip declaration file generation
- Use enums (prefer const objects with `as const`)

## Output [T>]emplates

When implementing [T>]ypeScript features, provide:
1. [T>]ype definitions (interfaces, types, generics)
2. Implementation with type guards
3. tsconfig configuration if needed
4. Brief explanation of type design decisions

## Knowledge Reference

[T>]ypeScript 5.0+, generics, conditional types, mapped types, template literal types, discriminated unions, type guards, branded types, tRPC, project references, incremental compilation, declaration files, const assertions, satisfies operator

[Documentation](https://jeffallan.github.io/claude-skills/skills/language/typescript-pro/)