Utility Types and Advanced TypeScript

interface User {
    id:      number;
    name:    string;
    email:   string;
    role:    "admin" | "user";
    address?: string;
}

// Partial<T> — all properties become optional
type UserUpdate = Partial<User>;
const update: UserUpdate = { name: "Priya" };   // all other fields omitted

// Required<T> — all optional properties become required
type FullUser = Required<User>;   // address is now required

// Readonly<T> — all properties become readonly
type FrozenUser = Readonly<User>;
// frozenUser.name = "x";   // Error

// Pick<T, K> — keep only specified keys
type UserPreview = Pick<User, "id" | "name">;
// { id: number; name: string }

// Omit<T, K> — remove specified keys
type UserWithoutRole = Omit<User, "role" | "id">;
// { name: string; email: string; address?: string }

// Record<K, V> — object type with keys K and values V
type RolePermissions = Record<"admin" | "user" | "guest", string[]>;
const perms: RolePermissions = {
    admin: ["read","write","delete"],
    user:  ["read","write"],
    guest: ["read"],
};

// Record for a lookup table
type ErrorMessages = Record<number, string>;
const httpErrors: ErrorMessages = { 404: "Not Found", 500: "Server Error" };

// Union manipulation
type AllRoles    = "admin" | "user" | "guest" | "moderator";
type PublicRoles = "user" | "guest";

// Exclude<T, U> — remove U from union T
type PrivateRoles = Exclude<AllRoles, PublicRoles>;  // "admin" | "moderator"

// Extract<T, U> — keep only the members of T that are in U
type CommonRoles = Extract<AllRoles, "user" | "guest" | "unknown">;  // "user" | "guest"

// NonNullable<T> — remove null and undefined
type MaybeString = string | null | undefined;
type DefinitelyString = NonNullable<MaybeString>;  // string

// Function utility types
function fetchUser(id: number, token: string): Promise<User> { ... }

type Params   = Parameters<typeof fetchUser>;       // [number, string]
type Result   = ReturnType<typeof fetchUser>;       // Promise<User>
type Resolved = Awaited<ReturnType<typeof fetchUser>>; // User

// ConstructorParameters<T> — constructor argument types
class Logger {
    constructor(private name: string, private level: number) {}
}
type LoggerArgs = ConstructorParameters<typeof Logger>;  // [string, number]

// InstanceType<T> — the type an constructor produces
type LoggerInstance = InstanceType<typeof Logger>;  // Logger

// satisfies (TypeScript 4.9) — validate type without widening
const palette = {
    red:   [255, 0, 0],
    green: "#00ff00",
    blue:  [0, 0, 255],
} satisfies Record<string, string | number[]>;

// satisfies checks the object against Record<string, string | number[]> but keeps
// each property's own precise inferred type, so palette.red stays number[] here —
// same as if the "satisfies ..." clause were deleted and palette were left with no
// annotation at all. The widening only happens if you swap satisfies for a plain
// type annotation instead: `const palette: Record<string, string | number[]> = {...}`
// makes palette.red string | number[], because every property now takes the
// declared type. satisfies gets you the validation without paying that price.
palette.red.map(v => v * 2);   // OK — TypeScript knows it's number[]

// as const — make all values literal types, readonly recursively
const config = {
    host:  "localhost",
    port:  3000,
    debug: true,
} as const;
// config: { readonly host: "localhost"; readonly port: 3000; readonly debug: true }

// Combined with typeof for enums-without-enums
const Direction = {
    NORTH: "north",
    SOUTH: "south",
    EAST:  "east",
    WEST:  "west",
} as const;
type Direction = (typeof Direction)[keyof typeof Direction];
// "north" | "south" | "east" | "west"

// Template literal types for API path validation
type ApiPath = `/api/${string}`;
function callApi(path: ApiPath) { ... }
callApi("/api/users");     // OK
// callApi("/users");     // Error — must start with /api/