Built-in Utility Types: Partial, Pick, Omit, Record & friends

Why reshape a type you already have?

Imagine you have a User interface. You constantly need slightly different versions of it: a version where every field is optional (for an update form), a version with only a couple of fields (for a list), or a version with one field removed (to hide a password). Rewriting the whole shape each time is tedious and drifts out of sync.

Utility types are built-in generic helpers that take a type in and hand a reshaped type back. You already know generics — these are just generics the TypeScript team wrote for you. They are the single most-used everyday tool in real codebases, so let us meet the important ones.

Partial<T> — make every property optional

A classic case: an "update" function that changes only *some* fields of a user. Partial<User> takes User and returns a copy where every property is optional.

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

function updateUser(id: number, changes: Partial<User>): void {
  console.log('Updating user ' + id + ' with', changes);
}

updateUser(1, { name: 'Asha' });            // ok — only one field
updateUser(1, { email: 'a@x.com', name: 'A' }); // ok — two fields

Required<T> and Readonly<T> — the other two flippers

Required<T> does the opposite of Partial: it makes every property mandatory. Readonly<T> makes every property read-only (set once, never reassigned).

interface Settings {
  theme?: string;       // optional in the original
  fontSize?: number;
}

// Required: now BOTH are mandatory
const full: Required<Settings> = { theme: 'dark', fontSize: 14 };

// Readonly: the object is frozen at the type level
const locked: Readonly<Settings> = { theme: 'light' };
locked.theme = 'dark';    // error — read-only

Pick<T, Keys> and Omit<T, Keys> — choose or drop fields

Often you want a smaller slice of a big type. Pick keeps only the named fields; Omit keeps everything *except* the named fields. The field names are written as a literal union in quotes.

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

// Pick: a tiny "preview" with just two fields
type UserPreview = Pick<User, 'id' | 'name'>;
const p: UserPreview = { id: 1, name: 'Asha' };

// Omit: a "safe" user with password removed
type SafeUser = Omit<User, 'password'>;
const s: SafeUser = { id: 1, name: 'Asha', email: 'a@x.com' };

console.log(p.name, s.email);

Record<Keys, Value> — build a lookup object type

Record<Keys, Value> describes an object whose keys come from a set and whose values all share one type. Great for dictionaries and lookup tables.

type Role = 'admin' | 'editor' | 'viewer';

// An object that maps every Role to a number (its permission level)
const levels: Record<Role, number> = {
  admin: 3,
  editor: 2,
  viewer: 1
};

console.log(levels.editor);

Pulling types out of functions: ReturnType, Parameters, Awaited

Some utilities read a type *out of* a function or promise, so you never hand-copy it:

• ReturnType<typeof fn> — the type a function returns.
• Parameters<typeof fn> — a tuple of a function’s parameter types.
• NonNullable<T> — T with null and undefined removed.
• Awaited<T> — the value inside a Promise (what await would give you).

function makeUser(name: string, age: number) {
  return { name, age, active: true };
}

// Grab the return shape automatically — no hand-typing
type NewUser = ReturnType<typeof makeUser>;
// NewUser is { name: string; age: number; active: boolean }

const u: NewUser = { name: 'Asha', age: 28, active: true };
console.log(u.active);

// Awaited unwraps a Promise's value type
type Data = Awaited<Promise<number>>;   // Data is number

The utility-type cheat sheet