TypeScript Utility Types

Apply built-in TypeScript utility types to transform and compose types without redundancy

When to Use

• You need a variant of an existing type with some properties optional, required, or removed
• You want to derive a type from a function's return value or parameter list without duplicating it
• You need to build a lookup map type from a union of keys
• You want to filter a union type to include or exclude specific members
• You are building form types, API response shapes, or partial update payloads

Instructions

1. Use

   Partial<T>

   for optional-update payloads where every field is optional.
2. Use

   Required<T>

   to make every optional field mandatory (opposite of Partial).
3. Use

   Pick<T, K>

   to create a type with only the listed keys from T.
4. Use

   Omit<T, K>

   to create a type with all keys except the listed ones.
5. Use

   Record<K, V>

   to define a mapping type — prefer over index signatures when keys are known.
6. Use

   Exclude<T, U>

   to remove union members assignable to U from T.
7. Use

   Extract<T, U>

   to keep only union members assignable to U.
8. Use

   ReturnType<typeof fn>

   to derive the return type of a function without manually declaring it.
9. Use

   Parameters<typeof fn>

   to derive the parameter tuple of a function.
10. Chain utility types when needed:

    Partial<Pick<User, 'name' | 'email'>>

    .

interface User {
  id: string;
  name: string;
  email: string;
  role: 'admin' | 'viewer' | 'editor';
  createdAt: Date;
}

// Partial update payload — all fields optional
type UserUpdate = Partial<Omit<User, 'id' | 'createdAt'>>;

// Public profile — only safe fields
type PublicUser = Pick<User, 'id' | 'name' | 'role'>;

// Role lookup map
type RoleConfig = Record<User['role'], { canWrite: boolean; canDelete: boolean }>;

// Exclude admin from public-facing role type
type PublicRole = Exclude<User['role'], 'admin'>; // 'viewer' | 'editor'

// Infer return type without coupling to implementation
async function fetchUser(id: string): Promise<User> {
  /* ... */ return {} as User;
}
type FetchUserResult = Awaited<ReturnType<typeof fetchUser>>; // User

// Infer parameters for wrapping/mocking
type FetchUserParams = Parameters<typeof fetchUser>; // [id: string]

Details

All utility types are implemented as generic conditional or mapped types in TypeScript's standard library (

lib.es5.d.ts

Implementation anatomy

// Partial<T> implementation
type Partial<T> = { [P in keyof T]?: T[P] };

// Pick<T, K> implementation
type Pick<T, K extends keyof T> = { [P in K]: T[P] };

// Exclude<T, U> implementation
type Exclude<T, U> = T extends U ? never : T;

// ReturnType<T> implementation
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

Omit

Exclude

Omit<T, K>

Exclude<T, U>

Record

Record<string, V>

{ [key: string]: V }

Record<K, V>

Composing utility types

Utility types compose via nesting. Deep transformations may require recursive types (TypeScript 4.1+) or a custom mapped type. For deeply partial types, the standard library's

Partial

NonNullable<T>

Removes

null

undefined

Exclude<T, null | undefined>

ConstructorParameters<T>

InstanceType<T>

Less common but useful for class-based code:

ConstructorParameters

InstanceType

new T()

When to write custom utilities instead

When none of the built-ins express your transformation, write a mapped or conditional type. The built-ins are a starting point, not a ceiling.

Source

https://typescriptlang.org/docs/handbook/utility-types.html

Process

1. Read the instructions and examples in this document.
2. Apply the patterns to your implementation, adapting to your specific context.
3. Verify your implementation against the details and edge cases listed above.

Harness Integration

• Type: knowledge — this skill is a reference document, not a procedural workflow.
• No tools or state — consumed as context by other skills and agents.

Success Criteria

• The patterns described in this document are applied correctly in the implementation.
• Edge cases and anti-patterns listed in this document are avoided.