TypeScript Utility Types Reference

Makes every property of T optional.

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

Constructs a type by picking the set of keys K from T.

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

Marks every property of T as readonly.

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

Removes the optional modifier from every property of T.

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

Builds an object type with keys K and values V.

type Record<K extends keyof any, V> = { [P in K]: V };

Removes from T the members that are assignable to U.

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

Keeps only the members of T that are assignable to U.

type Extract<T, U> = T extends U ? T : never;

Removes null and undefined from T.

type NonNullable<T> = T & {};

Unwraps the resolved value of a Promise (recursively).

type Awaited<T> = T extends null | undefined

Extracts the constructor parameter tuple of a class.

type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never;

Extracts the instance type of a class constructor.

type InstanceType<T extends abstract new (...args: any) => any> = T extends abstract new (...args: any) => infer R ? R : any;

Removes the this parameter from a function type.

type OmitThisParameter<T> = unknown extends ThisParameterType<T> ? T : T extends (...args: infer A) => infer R ? (...args: A) => R : T;

Extracts the parameter list of a function type as a tuple.

type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

Extracts the return type of a function type.

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

Extracts the type of the this parameter of a function type.

type ThisParameterType<T> = T extends (this: infer U, ...args: never) => any ? U : unknown;

Uppercases the first character of a string literal type.

type Capitalize<S extends string> = intrinsic;

Lowercases every character in a string literal type.

type Lowercase<S extends string> = intrinsic;

Lowercases the first character of a string literal type.

type Uncapitalize<S extends string> = intrinsic;

Uppercases every character in a string literal type.

type Uppercase<S extends string> = intrinsic;

Iterates a union of keys to build an object type.

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

Composes string literal types by interpolation.

type Combined<A extends string, B extends string> = `${A}${B}`;

Captures a type during conditional type matching.

type Result<T> = T extends Foo<infer R> ? R : never;

The union of all property keys of T.

type Keys<T> = keyof T;

Picks between two types based on whether T is assignable to U.

type Result<T> = T extends Condition ? IfTrue : IfFalse;

Indexed access. Reads the type of property K from T.

type Value = T[K];

Derives a type from a runtime value.

type Value = typeof someValue;

Narrows literal values to their most specific type.

const x = expression as const;

Disables inference for a position in a generic call.

type NoInfer<T> = intrinsic;

Marker type used inside object literals to set the this context.

interface ThisType<T> {}