TypeScript Utility Types: Complete Reference Guide

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

type PartialUser = Partial<User>;
// {
//   id?: number;
//   name?: string;
//   email?: string;
//   age?: number;
// }

function updateUser(id: number, updates: Partial<User>) {
  // Merge updates with existing user
  return { ...existingUser, ...updates };
}

updateUser(1, { age: 25 });  // Only update age

interface PartialUser {
  id?: number;
  name?: string;
  email?: string;
}

type CompleteUser = Required<PartialUser>;
// {
//   id: number;
//   name: string;
//   email: string;
// }

interface Config {
  apiUrl: string;
  timeout: number;
}

type ReadonlyConfig = Readonly<Config>;

const config: ReadonlyConfig = {
  apiUrl: 'https://api.example.com',
  timeout: 5000,
};

// config.apiUrl = 'new url';  // Error: Cannot assign

type UserMap = Record<string, User>;

const users: UserMap = {
  user1: { id: 1, name: 'John' },
  user2: { id: 2, name: 'Jane' },
};

// More specific keys
type Roles = Record<'admin' | 'user' | 'guest', number>;

const permissions: Roles = {
  admin: 7,
  user: 4,
  guest: 1,
};

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

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

function getUserInfo(user: User): UserBasicInfo {
  const { id, name } = user;
  return { id, name };
}

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

type PublicUser = Omit<User, 'password'>;
// {
//   id: number;
//   name: string;
//   email: string;
// }

function toPublicUser(user: User): PublicUser {
  const { password, ...publicUser } = user;
  return publicUser;
}

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

type NonNullable = Exclude<Primitives, null | undefined>;
// string | number | boolean

type OnlyStrings = Exclude<string | number | boolean, number | boolean>;
// string

type All = string | number | boolean | Function;

type FunctionsOnly = Extract<All, Function>;
// Function

type StringsAndNumbers = Extract<All, string | number>;
// string | number

type Value = string | null | undefined;

type NonNullValue = NonNullable<Value>;
// string

function process(value: NonNullValue) {
  // value is guaranteed not to be null or undefined
  return value.toUpperCase();
}

function getUser(): {
  id: number;
  name: string;
} {
  return { id: 1, name: 'John' };
}

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

async function fetchData(): Promise<number> {
  return 42;
}

type DataReturn = ReturnType<typeof fetchData>;
// Promise<number>

class User {
  constructor(public name: string, public age: number) {}
}

type UserInstance = InstanceType<typeof User>;
// User

function createUser(Class: new (...args: any) => any) {
  return new Class();
}

const user = createUser(User);  // User

type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object
    ? DeepPartial<T[P]>
    : T[P];
};

interface Config {
  database: {
    host: string;
    port: number;
    credentials: {
      username: string;
      password: string;
    };
  };
}

type PartialConfig = DeepPartial<Config>;
// Can partially specify nested properties

type DeepRequired<T> = {
  [P in keyof T]-?: T[P] extends object
    ? DeepRequired<T[P]>
    : T[P];
};

type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object
    ? DeepReadonly<T[P]>
    : T[P];
};

interface State {
  user: {
    name: string;
    preferences: {
      theme: string;
    };
  };
}

type ReadonlyState = DeepReadonly<State>;
// All nested properties are readonly

type Mutable<T> = {
  -readonly [P in keyof T]: T[P];
};

interface ReadonlyInterface {
  readonly id: number;
  readonly name: string;
}

type MutableInterface = Mutable<ReadonlyInterface>;
// {
//   id: number;
//   name: string;
// }

type Push<T extends any[], V> = [...T, V];
type Unshift<T extends any[], V> = [V, ...T];

type Tuple = [1, 2];
type WithPush = Push<Tuple, 3>;  // [1, 2, 3]
type WithUnshift = Unshift<Tuple, 0>;  // [0, 1, 2]

type First<T extends any[]> = T extends [infer F, ...any[]] ? F : never;
type Last<T extends any[]> = T extends [...any[], infer L] ? L : never;

type Head = First<[1, 2, 3]>;  // 1
type Tail = Last<[1, 2, 3]>;  // 3

type Arguments<T> = T extends (...args: infer A) => any ? A : never;

function example(name: string, age: number): boolean {
  return true;
}

type ExampleArgs = Arguments<typeof example>;
// [string, number]

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

// Create user - only provide required fields
type CreateUserInput = Omit<User, 'id'>;

// Update user - all fields optional
type UpdateUserInput = Partial<CreateUserInput>;

// Public user - hide sensitive fields
type PublicUser = Omit<User, 'email' | 'password'>;

async function createUser(input: CreateUserInput): Promise<PublicUser> {
  const user = await db.create(input);
  const { email, ...publicUser } = user;
  return publicUser;
}

interface FormData {
  username: string;
  email: string;
  password: string;
  confirmPassword: string;
}

// Form state - all fields optional
type FormState = Partial<FormData>;

// Form errors - all fields optional string
type FormErrors = {
  [K in keyof FormData]?: string;
};

const errors: FormErrors = {
  username: 'Username is required',
  email: 'Invalid email',
};

interface DatabaseConfig {
  host: string;
  port: number;
  username: string;
  password: string;
}

interface ServerConfig {
  port: number;
  database: DatabaseConfig;
}

// Partial config for development
type DevConfig = Partial<ServerConfig>;

// Required config for production
type ProdConfig = Required<ServerConfig>;