TypeScript Utility Types Reference

You need to make all fields of your User interface optional for a PATCH endpoint, but you can never remember: is it Partial<User> or Optional<User>? And for the response that excludes the password field — is it Omit<User, "password"> or Pick<User, Exclude<keyof User, "password">>? TypeScript has 21 built-in utility types and the docs don’t show them all on one page.

Why This Reference (Not the TypeScript Playground)

PureDevTools has a TypeScript Playground for experimenting with type definitions. This reference covers all 21 TypeScript built-in utility types — Partial, Required, Readonly, Record, Pick, Omit, Exclude, Extract, NonNullable, Parameters, ReturnType, Awaited, and more — with live examples, syntax, use cases, and a try-it playground for each type.

What Are TypeScript Utility Types?

TypeScript utility types are built-in generic types that transform or derive new types from existing ones. They are part of the TypeScript standard library — no imports required. Every utility type takes one or more type parameters and returns a transformed type at compile time.

Utility types let you express common type transformations concisely:

• Partial<User> instead of manually adding ? to every property
• Readonly<Config> instead of adding readonly to every field
• ReturnType<typeof fetchUser> instead of duplicating the return type

TypeScript ships 21 built-in utility types, grouped into five categories: Object Types, Union & Conditional Types, Function Types, String Types, and Promise Types.

Object Utility Types

Object utility types transform object/interface types by modifying their properties.

Partial<T>

Makes every property of T optional. The resulting type requires no properties, but still validates that any provided values match their declared types.

interface User {
  id: number;
  name: string;
  email: string;
}

function updateUser(id: number, changes: Partial<User>): User {
  // changes may have any combination of {id, name, email}
}

updateUser(1, { name: "Alice" });          // ✓
updateUser(1, { email: "a@example.com" }); // ✓
updateUser(1, { name: "Alice", email: "a@example.com" }); // ✓

When to use: HTTP PATCH requests, React setState, form partial updates, merging default values.

Required<T>

The opposite of Partial<T>. Removes all ? optional markers, making every property required.

interface Config {
  host?: string;
  port?: number;
  timeout?: number;
}

function connect(config: Required<Config>) {
  // All three fields guaranteed present
}

When to use: After applying defaults, after validation, when passing a fully-resolved config.

Readonly<T>

Adds readonly to every property. TypeScript will error if any code attempts to reassign a property after initialization.

Note: Readonly<T> is shallow — nested objects remain mutable. Use DeepReadonly patterns or as const for deep immutability.

function processPoint(point: Readonly<Point>) {
  point.x = 10; // Error: Cannot assign to 'x' because it is a read-only property.
}

When to use: Immutable state in Redux, frozen config objects, pure function parameters.

Record<Keys, Type>

Creates an object type mapping every member of the Keys union to Type. Equivalent to { [K in Keys]: Type }.

type Color = "red" | "green" | "blue";

const hex: Record<Color, string> = {
  red: "#ff0000",
  green: "#00ff00",
  blue: "#0000ff",
};

When to use: Lookup tables, dictionaries, exhaustive mappings of enum-like unions.

Pick<Type, Keys>

Selects a subset of properties from Type. Only the listed keys are included in the result.

type UserSummary = Pick<User, "id" | "name">;
// { id: number; name: string }

When to use: API response shapes, component props from a larger model, safe public-facing types.

Omit<Type, Keys>

The inverse of Pick — includes all properties except the listed keys.

type CreateUserInput = Omit<User, "id" | "createdAt">;
// All User fields except id and createdAt

When to use: Removing auto-generated fields for creation payloads, removing sensitive fields before sending to client.

Union & Conditional Utility Types

These operate on union types rather than object types.

Exclude<UnionType, ExcludedMembers>

Removes union members that are assignable to ExcludedMembers.

type NonNullString = Exclude<string | null | undefined, null | undefined>;
// string

Extract<Type, Union>

Keeps only union members that are assignable to Union. The intersection of two union types.

type CommonStatus = Extract<"draft" | "published", "published" | "archived">;
// "published"

NonNullable<Type>

Shorthand for Exclude<T, null | undefined>. Ensures a type is not nullish.

type SafeId = NonNullable<number | null | undefined>;
// number

When to use: After null checks, in filter callbacks (array.filter(Boolean)), asserting values are present.

Function Utility Types

Extract type information from function signatures.

Parameters<Type>

Produces a tuple of the parameter types of a function.

type CreateArgs = Parameters<typeof createUser>;
// [name: string, age: number, admin: boolean]

ConstructorParameters<Type>

Like Parameters but for class constructors, accessed via typeof ClassName.

type DbArgs = ConstructorParameters<typeof Database>;
// [url: string, options?: DbOptions]

ReturnType<Type>

Extracts the return type from a function type.

type UserResult = ReturnType<typeof getUser>;
// { id: number; name: string; email: string }

Tip: Combine with Awaited for async functions: Awaited<ReturnType<typeof fetchUser>>.

InstanceType<Type>

Gets the instance type of a class constructor. Equivalent to writing the class name as a type, but works with generic constructor references.

ThisParameterType<Type>

Extracts the type of the this parameter from a function that declares one explicitly.

OmitThisParameter<Type>

Removes the this parameter from a function type. Reflects what .bind() does at runtime.

ThisType<Type>

A marker type — does not transform anything. It annotates the contextual this type for methods in object literals. Requires noImplicitThis: true in tsconfig.

String Utility Types

These operate on string literal types and template literal types.

Uppercase<StringType>

Converts string literals to uppercase at the type level.

type Shout = Uppercase<"hello" | "world">;
// "HELLO" | "WORLD"

Lowercase<StringType>

Converts string literals to lowercase at the type level.

Capitalize<StringType>

Capitalizes the first character of each string literal.

type HandlerName = `on${Capitalize<"click" | "focus">}`;
// "onClick" | "onFocus"

Uncapitalize<StringType>

Lowercases the first character. Inverse of Capitalize.

Promise Utility Types

Awaited<Type>

Recursively unwraps Promise<T> — works for nested promise chains too. Added in TypeScript 4.5.

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

// Combining with ReturnType:
type FetchedUser = Awaited<ReturnType<typeof fetchUser>>;

When to use: Typing Promise.all() results, extracting resolved value types from async functions.

Frequently Asked Questions

Do utility types affect runtime performance?

No. Utility types are erased at compile time and produce no JavaScript output. They are purely a compile-time type-checking mechanism.

Can I chain multiple utility types?

Yes. For example: Readonly<Partial<User>> makes all User properties optional and readonly. Awaited<ReturnType<typeof fetchUser>> extracts the resolved type of an async function. You can compose them freely.

What is the difference between Omit and Exclude?

Omit<T, Keys> works on object types and removes named properties. Exclude<T, U> works on union types and removes union members. They are not interchangeable. Omit<User, "password"> removes the password property from an interface; Exclude<"a" | "b" | "c", "b"> removes "b" from a union.

When should I use Pick vs. explicit interface?

Use Pick<T, K> when you want to select a subset of an existing interface and stay in sync with it automatically. If User adds a new property, Pick<User, "id" | "name"> is unaffected. An explicit { id: number; name: string } interface would diverge silently.

What TypeScript version introduced Awaited?

Awaited<T> was added in TypeScript 4.5 (released November 2021). The string utility types (Uppercase, Lowercase, Capitalize, Uncapitalize) were added in TypeScript 4.1. All other utility types have been available since TypeScript 2.1 or earlier.

Can I create my own utility types?

Yes. Any generic type using mapped types, conditional types, infer, or template literal types is a custom utility type. Examples: DeepPartial<T>, Mutable<T> (remove readonly), Flatten<T[]>. Utility types from the ts-toolbelt and type-fest libraries extend the built-in set significantly.