Utility Types

TypeScript's built-in utility types are generic types that transform other types. They're implemented using mapped types and conditional types, so understanding how they work helps you write custom utilities.

Property Modifier Utilities

Partial<T> — Makes all properties optional:

type Partial<T> = { [K in keyof T]?: T[K] };
interface User { name: string; age: number; }
type PartialUser = Partial<User>; // { name?: string; age?: number; }

Common use: update functions that accept a subset of properties: function updateUser(id: string, updates: Partial<User>).

Required<T> — Makes all properties required (removes ?):

type Required<T> = { [K in keyof T]-?: T[K] };

The -? removes the optional modifier. Useful when you need to ensure all fields are present (e.g., after validation).

Readonly<T> — Makes all properties readonly:

type Readonly<T> = { readonly [K in keyof T]: T[K] };

Prevents accidental mutation. Note: this is shallow — nested objects are still mutable. For deep immutability, you need a custom DeepReadonly or as const.

Property Selection Utilities

Pick<T, K> — Select specific properties:

type Pick<T, K extends keyof T> = { [P in K]: T[P] };
type UserName = Pick<User, 'name'>; // { name: string }
type UserNameAge = Pick<User, 'name' | 'age'>;

Omit<T, K> — Remove specific properties:

type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
type UserWithoutAge = Omit<User, 'age'>; // { name: string }

Pick and Omit are complementary — use whichever results in a shorter union of keys.

Type Construction Utilities

Record<K, V> — Create an object type with keys K and values V:

type Record<K extends keyof any, V> = { [P in K]: V };
type Scores = Record<string, number>; // { [key: string]: number }
type StatusMap = Record<'active' | 'inactive', User[]>;

Record is the type-safe way to describe dictionaries and lookup objects.

Function Utilities

ReturnType<T> — Extract a function's return type:

type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
function getUser() { return { name: 'Alice', age: 30 }; }
type User = ReturnType<typeof getUser>; // { name: string; age: number }

Parameters<T> — Extract function parameters as a tuple:

type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;
type Params = Parameters<typeof getUser>; // []

ConstructorParameters<T> and InstanceType<T> do the same for class constructors.

Union Utilities

Exclude<T, U> — Remove types from T that are assignable to U:

type Exclude<T, U> = T extends U ? never : T;
type Result = Exclude<'a' | 'b' | 'c', 'a'>; // 'b' | 'c'

Extract<T, U> — Keep only types from T assignable to U:

type Extract<T, U> = T extends U ? T : never;
type Result = Extract<string | number | boolean, number | boolean>; // number | boolean

NonNullable<T> — Remove null and undefined:

type NonNullable<T> = T & {}; // equivalent to Exclude<T, null | undefined>
type Result = NonNullable<string | null | undefined>; // string

Awaited<T> — Unwrap Promise types (recursively):

type Result = Awaited<Promise<Promise<string>>>; // string

Combining Utilities

Utility types compose together:

// Optional update payload without the id field
type UserUpdate = Partial<Omit<User, 'id'>>;
 
// Readonly version of only name and email
type ReadonlyNameEmail = Readonly<Pick<User, 'name' | 'email'>>;

Key Interview Distinction

Partial makes properties optional for update patterns. Pick/Omit select or exclude properties. Record constructs typed dictionaries. ReturnType and Parameters extract function signatures using conditional types with infer. Exclude/Extract filter union types. These are all implemented using mapped types and conditional types — understanding the implementation helps you write custom utilities.