TypeScript Utility Types Handbook 2026: Omit, Pick, Partial + All 22 Built-ins

What Are Utility Types?

TypeScript provides a set of built-in generic types that transform existing types into new ones. These utility types eliminate the need to manually redefine types for common patterns like making properties optional, picking a subset of fields, or creating dictionary types. Instead of duplicating type definitions across your codebase, you derive new types from a single source of truth.

This guide covers every commonly used utility type with real-world examples from API development, React components, and data processing. By the end, you will also know how to build your own custom utility types.

Which Utility Type Should You Use?

All 22 Built-in Utility Types at a Glance

TypeScript Utility Types by Release Version

The practical takeaway: older projects usually have Partial, Pick, and Record, but Omit, Awaited, and NoInfer depend on newer compiler baselines.

Source note: the official utility-types page lists release markers for the named helpers and links the intrinsic string helpers to template literal types; the release notes confirm Omit in TypeScript 3.5, Awaited in TypeScript 4.5, and NoInfer in TypeScript 5.4.

Partial<T>: Make Everything Optional

Partial<T> creates a type where every property of T becomes optional. This is the most commonly used utility type, especially for update operations where only some fields change.

interface User {
  id: string;
  name: string;
  email: string;
  avatar: string;
  role: 'admin' | 'user';
}

// Without Partial -- you'd need a separate type:
// interface UpdateUser { name?: string; email?: string; ... }

// With Partial -- derive it automatically:
type UpdateUser = Partial<User>;
// { id?: string; name?: string; email?: string; avatar?: string; role?: 'admin' | 'user' }

// Real-world usage: update function
async function updateUser(id: string, data: Partial<User>): Promise<User> {
  // Only the provided fields are updated
  return await db.users.update({ where: { id }, data });
}

// Usage -- only update what changed
await updateUser('user_123', { name: 'New Name' });        // OK
await updateUser('user_123', { email: '[email protected]' }); // OK
await updateUser('user_123', {});                            // OK (no changes)

// React form state
const [formData, setFormData] = useState<Partial<User>>({});

function handleChange(field: keyof User, value: string) {
  setFormData(prev => ({ ...prev, [field]: value }));
}

Pick<T, K> and Omit<T, K>: Select or Exclude Properties

Pick selects specific properties; Omit removes specific properties. They are complementary tools for creating focused type subsets from larger interfaces.

interface User {
  id: string;
  name: string;
  email: string;
  password: string;
  createdAt: Date;
  updatedAt: Date;
}

// Pick: select only what you need
type UserPreview = Pick<User, 'id' | 'name' | 'avatar'>;
// { id: string; name: string; avatar: string }

// Omit: remove what you don't want
type PublicUser = Omit<User, 'password'>;
// { id: string; name: string; email: string; createdAt: Date; updatedAt: Date }

// API layer: never expose password
function getUserProfile(id: string): Promise<PublicUser> {
  const user = await db.users.findById(id);
  const { password, ...publicUser } = user; // strip password
  return publicUser;
}

// Create form: no id or timestamps (server generates those)
type CreateUserInput = Omit<User, 'id' | 'createdAt' | 'updatedAt'>;
// { name: string; email: string; password: string }

// Combine with Partial for flexible update
type UpdateUserInput = Partial<Omit<User, 'id' | 'createdAt'>>;
// { name?: string; email?: string; password?: string; updatedAt?: Date }

// React component props
type UserCardProps = Pick<User, 'name' | 'email'> & {
  onClick: () => void;
};

Record<K, V>: Dictionary Types

Record<K, V> creates a type with keys of type K and values of type V. It is the type-safe way to define dictionaries, lookup tables, and grouped data.

// Simple dictionary
type UserMap = Record<string, User>;
const users: UserMap = {
  'user_1': { id: 'user_1', name: 'Alice', ... },
  'user_2': { id: 'user_2', name: 'Bob', ... },
};

// Constrained keys with union type
type Theme = 'light' | 'dark' | 'auto';
type ThemeConfig = Record<Theme, { bg: string; text: string; border: string }>;

const themes: ThemeConfig = {
  light: { bg: '#ffffff', text: '#1a1a1a', border: '#e5e5e5' },
  dark:  { bg: '#0a0a0a', text: '#fafafa', border: '#333333' },
  auto:  { bg: 'inherit', text: 'inherit', border: 'inherit' },
};

// HTTP status code descriptions
type StatusCode = 200 | 201 | 400 | 401 | 403 | 404 | 500;
const statusMessages: Record<StatusCode, string> = {
  200: 'OK',
  201: 'Created',
  400: 'Bad Request',
  401: 'Unauthorized',
  403: 'Forbidden',
  404: 'Not Found',
  500: 'Internal Server Error',
};

// Grouped data
type GroupedByRole = Record<User['role'], User[]>;
const grouped: GroupedByRole = {
  admin: [adminUser1, adminUser2],
  user: [user1, user2, user3],
};

Record types are especially useful when working with JSON data. Format and inspect JSON objects with our JSON Formatter to understand the data shape before defining your Record types.

Exclude<T, U> and Extract<T, U>: Filter Union Types

type Status = 'pending' | 'active' | 'suspended' | 'deleted';

// Exclude: remove members from a union
type ActiveStatus = Exclude<Status, 'deleted' | 'suspended'>;
// 'pending' | 'active'

// Extract: keep only members matching a condition
type InactiveStatus = Extract<Status, 'suspended' | 'deleted'>;
// 'suspended' | 'deleted'

// Real-world: event system
type AppEvent =
  | { type: 'click'; x: number; y: number }
  | { type: 'keydown'; key: string }
  | { type: 'scroll'; offset: number }
  | { type: 'resize'; width: number; height: number };

// Extract only mouse-related events
type MouseEvent = Extract<AppEvent, { type: 'click' }>;
// { type: 'click'; x: number; y: number }

// Exclude specific events from handling
type NonScrollEvent = Exclude<AppEvent, { type: 'scroll' }>;

// Extract event types as a union of strings
type EventType = AppEvent['type'];
// 'click' | 'keydown' | 'scroll' | 'resize'

ReturnType<T> and Parameters<T>: Infer from Functions

// ReturnType: extract a function's return type
function createUser(name: string, email: string) {
  return { id: crypto.randomUUID(), name, email, createdAt: new Date() };
}

type NewUser = ReturnType<typeof createUser>;
// { id: string; name: string; email: string; createdAt: Date }

// Parameters: extract function parameter types as a tuple
type CreateUserParams = Parameters<typeof createUser>;
// [name: string, email: string]

// Real-world: wrapping third-party functions
import { fetchData } from 'some-library';

type FetchResult = ReturnType<typeof fetchData>;
type FetchArgs = Parameters<typeof fetchData>;

// Create a wrapper with the same signature
function cachedFetch(...args: FetchArgs): FetchResult {
  const cacheKey = JSON.stringify(args);
  if (cache.has(cacheKey)) return cache.get(cacheKey);
  const result = fetchData(...args);
  cache.set(cacheKey, result);
  return result;
}

// Awaited: unwrap Promise return types
async function getUser(id: string): Promise<User> { ... }

type UserResult = Awaited<ReturnType<typeof getUser>>;
// User (not Promise<User>)

Building Custom Utility Types

Once you understand the built-in utilities, you can build your own using mapped types, conditional types, and template literal types. Here are practical custom utilities used in production codebases.

// DeepPartial: recursively make all properties optional
type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

interface Config {
  server: { host: string; port: number };
  database: { url: string; pool: { min: number; max: number } };
}

// All nested properties are optional
type PartialConfig = DeepPartial<Config>;

// Nullable: make a type nullable
type Nullable<T> = T | null;

// PickByType: pick properties that match a specific value type
type PickByType<T, ValueType> = {
  [K in keyof T as T[K] extends ValueType ? K : never]: T[K];
};

type StringFields = PickByType<User, string>;
// { id: string; name: string; email: string }

// RequireAtLeastOne: at least one property must be provided
type RequireAtLeastOne<T> = {
  [K in keyof T]-?: Required<Pick<T, K>> & Partial<Omit<T, K>>;
}[keyof T];

type SearchParams = RequireAtLeastOne<{
  name: string;
  email: string;
  id: string;
}>;
// Must provide at least name, email, or id

// StrictOmit: Omit that errors on non-existent keys
type StrictOmit<T, K extends keyof T> = Omit<T, K>;
// StrictOmit<User, 'nonExistent'> -> compile error!
// Omit<User, 'nonExistent'> -> silently returns User

Best Practices

1. Derive, do not duplicate -- use utility types to create variants from a single source type instead of maintaining parallel interfaces that drift apart.
2. Name derived types clearly -- CreateUserInput is better than UserPartialOmitId. The name should describe usage, not implementation.
3. Use Pick for API boundaries -- define exactly which fields an API endpoint accepts or returns. This documents the contract and catches breaking changes.
4. Combine utilities -- Partial<Omit<User, 'id'>> is perfectly valid and reads clearly: "optional fields except id."
5. Prefer Record over index signatures -- Record<string, User> is more explicit than { [key: string]: User } and works better with constrained key types.
6. Do not over-abstract -- complex nested utility types become unreadable. If a type is hard to understand, define it explicitly with an interface.

Frequently Asked Questions

Related Articles