Home/TypeScript Utility Types

TypeScript Utility Types: Partial, Pick, Omit & More

TypeScript ships with over a dozen built-in utility types that transform existing types without writing boilerplate. This guide covers every utility type with real code examples so you can reach for the right one immediately.

All examples use this base interface:

interface User {
  id: number;
  name: string;
  email: string;
  password: string;
  role: "admin" | "user";
  createdAt: Date;
}

Object-Transforming Utilities

Partial<T>

Makes all properties optional. Perfect for PATCH endpoints where the client sends only changed fields.

type PartialUser = Partial<User>;
// { id?: number; name?: string; email?: string; password?: string; role?: "admin" | "user"; createdAt?: Date }

async function updateUser(id: number, patch: Partial<User>): Promise<User> {
  // Only the fields provided in 'patch' will be updated
  return { ...currentUser, ...patch };
}

Required<T>

The inverse of Partial — removes all optional markers, making every property required.

interface Config {
  host?: string;
  port?: number;
  ssl?: boolean;
}

type StrictConfig = Required<Config>;
// { host: string; port: number; ssl: boolean }
// TypeScript now errors if any field is missing

Readonly<T>

Makes all properties read-only. Assignment to any property is a compile-time error.

const user: Readonly<User> = { id: 1, name: "Alice", email: "alice@example.com", password: "secret", role: "user", createdAt: new Date() };

user.name = "Bob"; // Error: Cannot assign to 'name' because it is a read-only property

Field Selection Utilities

Pick<T, K>

Creates a type by selecting a subset of keys from T. Great for DTOs and API response shapes.

type PublicUser = Pick<User, "id" | "name" | "email">;
// { id: number; name: string; email: string }
// password and role are excluded — safe to return from an API

type UserPreview = Pick<User, "id" | "name">;
// Minimal shape for list views

Omit<T, K>

Creates a type by removing specified keys from T. The complement of Pick.

type SafeUser = Omit<User, "password">;
// All User fields except password

type NewUser = Omit<User, "id" | "createdAt">;
// Shape for creating a new user — id and createdAt are generated server-side

Record<K, V>

Creates an object type with keys of type K and values of type V. Excellent for lookup tables and maps.

// All keys must be present when K is a union
type RoleConfig = Record<"admin" | "user" | "guest", { canRead: boolean; canWrite: boolean }>;
const roles: RoleConfig = {
  admin: { canRead: true,  canWrite: true  },
  user:  { canRead: true,  canWrite: false },
  guest: { canRead: true,  canWrite: false },
};

// Dynamic key lookups
const cache: Record<string, User> = {};
cache["user:1"] = { id: 1, name: "Alice", email: "a@a.com", password: "", role: "user", createdAt: new Date() };

Union Type Utilities

type ABC = "a" | "b" | "c" | "d";

// Exclude removes members from a union
type BC  = Exclude<ABC, "a" | "d">;   // "b" | "c"

// Extract keeps only matching members
type AD  = Extract<ABC, "a" | "d" | "z">; // "a" | "d"

// NonNullable removes null and undefined
type MaybeString = string | null | undefined;
type JustString = NonNullable<MaybeString>; // string

Function Utilities

async function fetchUser(id: number): Promise<User> {
  const res = await fetch(`/api/users/${id}`);
  return res.json();
}

// ReturnType extracts the return type of a function
type FetchUserReturn = ReturnType<typeof fetchUser>;   // Promise<User>
type ResolvedUser   = Awaited<ReturnType<typeof fetchUser>>; // User

// Parameters extracts the parameter types as a tuple
type FetchUserParams = Parameters<typeof fetchUser>; // [id: number]

// ConstructorParameters works the same for class constructors
class EventEmitter {
  constructor(private maxListeners: number, private name: string) {}
}
type EmitterArgs = ConstructorParameters<typeof EventEmitter>; // [maxListeners: number, name: string]

Frequently Asked Questions