Utility Types

TypeScript provides built-in utility types that transform existing types. These let you create new types from old ones without repetition.

Partial and Required

Partial<T> makes all properties optional. Required<T> makes all properties required.

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

// Partial — all fields optional (great for updates)
function updateUser(id: number, updates: Partial<User>): User {
  const existing: User = { id, name: "Alice", email: "alice@example.com", age: 30 };
  return { ...existing, ...updates };
}

const updated = updateUser(1, { name: "Alice Smith", age: 31 });
console.log(`Updated: ${updated.name}, age ${updated.age}`);

// Required — all fields required
interface Config {
  host?: string;
  port?: number;
  debug?: boolean;
}

function startServer(config: Required<Config>): void {
  console.log(`Server: ${config.host}:${config.port} (debug: ${config.debug})`);
}

startServer({ host: "localhost", port: 3000, debug: false });

Pick and Omit

Pick<T, K> creates a type with only selected properties. Omit<T, K> creates a type without specified properties.

interface Article {
  id: number;
  title: string;
  body: string;
  author: string;
  publishedAt: string;
  tags: string[];
}

// Pick — only the fields you need
type ArticlePreview = Pick<Article, "id" | "title" | "author">;

const preview: ArticlePreview = {
  id: 1,
  title: "TypeScript Utility Types",
  author: "Alice"
};
console.log(`Preview: "${preview.title}" by ${preview.author}`);

// Omit — everything except specified fields
type CreateArticleInput = Omit<Article, "id" | "publishedAt">;

const input: CreateArticleInput = {
  title: "New Article",
  body: "Article content here...",
  author: "Bob",
  tags: ["typescript", "tutorial"]
};
console.log(`New article: "${input.title}" [${input.tags.join(", ")}]`);

// Combine them
type ArticleUpdate = Partial<Omit<Article, "id">>;

const update: ArticleUpdate = { title: "Updated Title" };
console.log(`Update: ${JSON.stringify(update)}`);

Record

Record<K, V> creates an object type with keys of type K and values of type V.

type Status = "pending" | "active" | "archived";

// Record creates a type with all Status keys
const statusLabels: Record<Status, string> = {
  pending: "Awaiting Review",
  active: "Currently Active",
  archived: "No Longer Active"
};

const statusColors: Record<Status, string> = {
  pending: "#FFA500",
  active: "#00FF00",
  archived: "#808080"
};

const statuses: Status[] = ["pending", "active", "archived"];
statuses.forEach(s => {
  console.log(`${statusLabels[s]} (${statusColors[s]})`);
});

// Record with dynamic keys
type UserScores = Record<string, number>;

const scores: UserScores = {
  alice: 95,
  bob: 87,
  charlie: 92
};

Object.entries(scores).forEach(([name, score]) => {
  console.log(`${name}: ${score}`);
});

Exclude, Extract, and NonNullable

Work with union types by filtering members.

type AllTypes = string | number | boolean | null | undefined;

// Exclude — remove types from a union
type Primitives = Exclude<AllTypes, null | undefined>;
// Result: string | number | boolean

// Extract — keep only matching types
type NumOrStr = Extract<AllTypes, string | number>;
// Result: string | number

// NonNullable — remove null and undefined
type Defined = NonNullable<AllTypes>;
// Result: string | number | boolean

// Practical example
type ApiResult = "success" | "error" | "loading" | "idle";
type ActiveState = Exclude<ApiResult, "idle">;

function handleState(state: ActiveState): string {
  switch (state) {
    case "success": return "Data loaded!";
    case "error": return "Something went wrong";
    case "loading": return "Please wait...";
  }
}

const states: ActiveState[] = ["loading", "success", "error"];
states.forEach(s => console.log(`${s}: ${handleState(s)}`));

ReturnType and Parameters

Extract types from function signatures.

function createUser(name: string, age: number, admin: boolean) {
  return { id: Math.random(), name, age, admin, createdAt: new Date() };
}

// Extract the return type
type User = ReturnType<typeof createUser>;

// Extract parameter types
type CreateUserParams = Parameters<typeof createUser>;

const user: User = createUser("Alice", 30, true);
console.log(`User: ${user.name}, admin: ${user.admin}`);

// Use with existing functions
function formatDate(date: Date, locale: string): string {
  return date.toLocaleDateString(locale);
}

type FormatDateReturn = ReturnType<typeof formatDate>; // string
type FormatDateParams = Parameters<typeof formatDate>; // [Date, string]

const args: FormatDateParams = [new Date(), "en-US"];
const result: FormatDateReturn = formatDate(...args);
console.log(`Formatted: ${result}`);

Try It Yourself

// Build a type-safe form builder
interface FormField {
  label: string;
  type: "text" | "email" | "number" | "select";
  required: boolean;
  options?: string[];
}

type FormSchema = Record<string, FormField>;

type FormValues<T extends FormSchema> = {
  [K in keyof T]: T[K]["type"] extends "number" ? number : string;
};

type FormErrors<T extends FormSchema> = Partial<Record<keyof T, string>>;

const schema = {
  name: { label: "Name", type: "text" as const, required: true },
  email: { label: "Email", type: "email" as const, required: true },
  age: { label: "Age", type: "number" as const, required: false },
  role: { label: "Role", type: "select" as const, required: true, options: ["admin", "user"] },
} satisfies FormSchema;

type MyFormValues = FormValues<typeof schema>;
type MyFormErrors = FormErrors<typeof schema>;

const values: MyFormValues = { name: "Alice", email: "alice@co.com", age: 30, role: "admin" };
const errors: MyFormErrors = { email: "Invalid email format" };

console.log("Form values:", JSON.stringify(values));
console.log("Form errors:", JSON.stringify(errors));

// Validate
Object.entries(schema).forEach(([key, field]) => {
  const value = values[key as keyof MyFormValues];
  if (field.required && !value) {
    console.log(`${field.label} is required`);
  } else {
    console.log(`${field.label}: ${value}`);
  }
});

Key Takeaways

Partial<T> makes all properties optional — perfect for update functions
Pick<T, K> and Omit<T, K> select or exclude specific properties
Record<K, V> creates object types with specific key and value types
Exclude and Extract filter union type members
ReturnType and Parameters extract types from functions
Combine utility types for powerful transformations: Partial<Omit<T, "id">>

Pro Tip: When you find yourself defining a type that's almost identical to an existing one, reach for utility types first. Pick, Omit, and Partial eliminate redundancy and keep types in sync — when the source type changes, all derived types update automatically.