TypeScript Interview Questions — In Depth

// JavaScript — bug discovered at runtime
function greet(name) {
  return "Hello, " + name.toUpperCase();
}
greet(42); // 💥 Runtime Error: name.toUpperCase is not a function

// TypeScript — bug caught at compile time
function greet(name: string): string {
  return "Hello, " + name.toUpperCase();
}
greet(42); // ❌ Error: Argument of type 'number' is not assignable to parameter of type 'string'

TypeScript Source (.ts)
        ↓
  1. Parse → creates AST (Abstract Syntax Tree)
        ↓
  2. Type Checking → verifies types, reports errors
        ↓
  3. Transform → downlevels syntax (ES2021 → ES2015, etc.)
        ↓
  4. Emit → generates JavaScript (.js) + Declaration files (.d.ts)
        ↓
JavaScript Output (.js) + Type Declarations (.d.ts)

{
  "compilerOptions": {
    "target": "ES2022",           // JS output version
    "module": "ESNext",           // Module system for output
    "moduleResolution": "bundler", // How modules are resolved
    "strict": true,               // Enable all strict checks
    "outDir": "./dist",           // Output directory
    "rootDir": "./src",           // Source directory
    "esModuleInterop": true,      // Better CJS/ESM compatibility
    "skipLibCheck": true,         // Skip type checking .d.ts files
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,    // Import .json files
    "declaration": true,          // Generate .d.ts files
    "declarationMap": true,       // Source maps for .d.ts
    "sourceMap": true             // Debugging source maps
  },
  "include": ["src"],             // Files to include
  "exclude": ["node_modules", "dist"]  // Files to exclude
}

// Interface — declarative, extensible
interface User {
  name: string;
  email: string;
}

// Type Alias — expressive, flexible
type User = {
  name: string;
  email: string;
};

// Type can do things Interface cannot:
type Status = "active" | "inactive" | "pending";  // Union
type Pair = [string, number];                       // Tuple
type Admin = User & { role: "admin" };              // Intersection
type Readonly<T> = { readonly [K in keyof T]: T[K] }; // Mapped

// Interface can do things Type cannot:
interface User { name: string }
interface User { age: number }  // Declaration merging!
// Result: User has BOTH name and age

// ✅ Use INTERFACE for:
// - Public API shapes (better error messages, better performance)
// - Object types that need declaration merging
// - Object types that need extending

// ✅ Use TYPE for:
// - Union types
// - Intersection types
// - Tuple types
// - Mapped/conditional types
// - Function signatures
// - Any type that isn't a simple object shape

// ===== any — Opt-out of type checking =====
let value: any = 42;
value = "hello";           // ✅ OK
value.toUpperCase();       // ✅ No compile error (but may crash at runtime!)
value.doSomething();       // ✅ No compile error (definitely crashes!)

// When to use any: Migration from JS, very rare edge cases
// Never use any as a default type!

// ===== unknown — Type-safe alternative to any =====
let value: unknown = 42;
value = "hello";           // ✅ OK (assignment is fine)

// ❌ Cannot use without narrowing:
// value.toUpperCase();    // Error: Object is of type 'unknown'

// Must narrow first:
if (typeof value === "string") {
  value.toUpperCase();     // ✅ OK — narrowed to string
}

// Parse JSON safely:
function parseJSON(json: string): unknown {
  return JSON.parse(json);
}
const data = parseJSON('{"name":"Alice"}');
// data.name;              // ❌ Error
if (typeof data === "object" && data && "name" in data) {
  console.log((data as { name: string }).name); // ✅ Safe
}

// ===== never — Value that NEVER occurs =====
function throwError(message: string): never {
  throw new Error(message);
}

function infiniteLoop(): never {
  while (true) {}
}

// Exhaustive type checking:
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number };

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case "circle": return Math.PI * shape.radius ** 2;
    case "square": return shape.side * shape.side;
    default: return assertNever(shape); // TypeScript checks this!
  }
}

function assertNever(value: never): never {
  throw new Error(`Unexpected: ${value}`);
}
// If a new Shape variant is added, the switch becomes incomplete
// TypeScript will show an error at assertNever — catches at compile time!

// ===== Standard Primitives =====
const name: string = "Alice";
const age: number = 25;
const isActive: boolean = true;

// ===== Special Primitives =====
const big: bigint = 9007199254740993n;  // Large integers
const unique: symbol = Symbol("id");    // Unique identifiers

// ===== TypeScript-Specific =====
const nothing: null = null;              // Intentional absence
const notAssigned: undefined = undefined; // Not yet assigned
const result: void = undefined;          // Function returns nothing
const impossible: never = throwError();  // Never occurs

// ===== Type Annotations vs Inference =====
// TypeScript INFERS types automatically:
let inferredName = "Alice";              // inferred as string
let inferredAge = 25;                    // inferred as number

// TypeScript does NOT infer void/never — those need annotations:
// function process(): void { ... }      // Must explicitly annotate void

// With strictNullChecks enabled (recommended):
let value: string = null;  // ❌ Error: Type 'null' is not assignable to 'string'
let value2: string | null = null;  // ✅ Must explicitly allow null

// Without strictNullChecks:
let value3: string = null;  // ✅ Allowed (dangerous!)

// ===== Basic Inference =====
let name = "Alice";       // string
let age = 25;             // number
let isActive = true;      // boolean
let items = [];           // any[] (empty array — wide type)
let numbers = [1, 2, 3];  // number[]

// ===== Function Return Inference =====
function add(a: number, b: number) {
  return a + b;            // Inferred return: number
}

function getDate() {
  return new Date();       // Inferred return: Date
}

// ===== Contextual Typing =====
const numbers = [1, 2, 3];
numbers.forEach((n) => {
  console.log(n.toFixed(2)); // n is inferred as number from context
});

// Event handlers:
document.addEventListener("click", (event) => {
  console.log(event.clientX); // event inferred as MouseEvent
});

// ===== Best Common Type =====
const arr = [0, 1, null];  // Inferred: (number | null)[]
const mixedArr = [1, "hello", true]; // (string | number | boolean)[]

// ===== Literal Inference =====
const constant = "hello";  // type: "hello" (literal)
let variable = "hello";    // type: string (widened)

// const preserves literal types, let/var widens to base type

// ===== Union Types =====
type Status = "active" | "inactive" | "pending";
type ID = string | number;
type Result = string | number | boolean;

function processId(id: ID): string {
  // id can be string or number — need to narrow
  if (typeof id === "string") {
    return id.toUpperCase(); // id is string here
  }
  return id.toFixed(0); // id is number here
}

// ===== Narrowing Techniques =====

// 1. typeof — for primitives
function pad(value: string | number): string {
  if (typeof value === "number") {
    return " ".repeat(value); // value: number
  }
  return value; // value: string
}

// 2. Truthiness checks
function process(value: string | null | undefined): string {
  if (value) {
    return value.toUpperCase(); // value: string
  }
  return "default";
}

// 3. Equality narrowing
function compare(a: string | number, b: string | boolean) {
  if (a === b) {
    // Both a and b are narrowed to what they have in common
    // Here: a is string, b is string
    console.log(a.toUpperCase());
  }
}

// 4. in operator
interface Bird { fly(): void; feathers: number }
interface Fish { swim(): void; scales: number }

function move(animal: Bird | Fish) {
  if ("fly" in animal) {
    return animal.fly(); // animal: Bird
  }
  return animal.swim(); // animal: Fish
}

// 5. instanceof
class Dog { bark() {} }
class Cat { meow() {} }

function makeSound(pet: Dog | Cat) {
  if (pet instanceof Dog) {
    pet.bark(); // pet: Dog
  } else {
    pet.meow(); // pet: Cat
  }
}

// 6. Discriminated unions — most powerful pattern
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; width: number; height: number }
  | { kind: "triangle"; base: number; height: number };

function getArea(shape: Shape): number {
  switch (shape.kind) {     // kind is the discriminant
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "rectangle":
      return shape.width * shape.height;
    case "triangle":
      return (shape.base * shape.height) / 2;
  }
}

// ===== String Literal Types =====
type Direction = "north" | "south" | "east" | "west";
type Status = "success" | "error" | "loading";
type Color = "red" | "green" | "blue";

function move(direction: Direction) {
  console.log(`Moving ${direction}`);
}
move("north"); // ✅
// move("up"); // ❌ Error!

// ===== Numeric Literal Types =====
type DiceRoll = 1 | 2 | 3 | 4 | 5 | 6;
type Port = 3000 | 8080 | 443;

// ===== Boolean Literal Types =====
type True = true;
type False = false;

// ===== as const — Preserve Literals =====
// Without as const — types widen:
const config = {
  apiUrl: "https://api.example.com",
  timeout: 5000,
  method: "GET"
};
// config.method is string (widened)

// With as const — types stay narrow:
const config2 = {
  apiUrl: "https://api.example.com",
  timeout: 5000,
  method: "GET"
} as const;
// config2.method is "GET" (literal!)
// config2.timeout is 5000 (literal!)
// config2 is readonly

// ===== as const with Arrays =====
const colors = ["red", "green", "blue"] as const;
// type: readonly ["red", "green", "blue"]
// colors[0] is "red", not string

// ===== Template Literal Types =====
type EventName = `on${Capitalize<string>}`;
// Matches: "onChange" | "onClick" | "onSubmit" | ...

type ColorWithHex = `#${string}`;
// Matches: "#ff0000" | "#00ff00" | ...

type CSSValue = `${number}${"px" | "rem" | "em" | "%"}`;
// Matches: "10px" | "2rem" | "50%" | ...

// ===== Array Types =====
// Two syntaxes — equivalent:
let numbers: number[] = [1, 2, 3];
let names: Array<string> = ["Alice", "Bob"];

// Readonly array:
let readOnly: readonly number[] = [1, 2, 3];
// readOnly.push(4);     // ❌ Error: push doesn't exist on readonly
// readOnly[0] = 10;     // ❌ Error: Index signature in readonly

// Multi-dimensional:
let matrix: number[][] = [[1, 2], [3, 4]];
let cube: number[][][] = [[[1]]];

// Union arrays:
let mixed: (string | number)[] = [1, "hello", 42];

// ===== Tuple Types =====
// Fixed-length array with specific types per position:
let person: [string, number] = ["Alice", 30];

// Access preserves types:
person[0].toUpperCase(); // string method ✅
person[1].toFixed(2);    // number method ✅

// Optional tuple elements:
let tuple: [string, number?] = ["hello"];
tuple = ["hello", 42]; // Also OK

// Labeled tuples (TS 4.0+):
type Range = [start: number, end: number];
type Name = [firstName: string, lastName: string];

// ===== Rest Elements in Tuples =====
// Variable length tail:
type StringsWithNumber = [string, ...number[]];
let a: StringsWithNumber = ["hello", 1, 2, 3];

// Rest at start (TS 4.2+):
type LeadingRest = [...number[], string];
let b: LeadingRest = [1, 2, 3, "end"];

// ===== Real-World Tuple Patterns =====
// React useState return:
function useState<T>(initial: T): [T, (value: T) => void] {
  // implementation
}

// API result pair:
type ApiResult<T> = [data: T | null, error: Error | null];

// CSV row:
type CsvRow = [name: string, age: number, email: string];

// ===== Basic Parameter & Return Types =====
function add(a: number, b: number): number {
  return a + b;
}

// Arrow functions:
const multiply = (a: number, b: number): number => {
  return a * b;
};

// Inferred return (use when simple):
const divide = (a: number, b: number) => a / b;

// ===== Optional Parameters =====
function greet(name: string, greeting?: string): string {
  return `${greeting ?? "Hello"}, ${name}!`;
}

// ===== Default Parameters =====
function createUser(
  name: string,
  role: string = "user",
  isActive: boolean = true
) {
  return { name, role, isActive };
}

// ===== Rest Parameters =====
function sum(...numbers: number[]): number {
  return numbers.reduce((acc, n) => acc + n, 0);
}

function buildMessage(prefix: string, ...suffixes: string[]): string {
  return prefix + suffixes.join(" ");
}

// ===== Destructured Parameters =====
function printUser({ name, age }: { name: string; age?: number }): void {
  console.log(name, age);
}

// ===== Function Type Expressions =====
type GreetFunction = (name: string) => string;
type MathOperation = (a: number, b: number) => number;
type Callback<T> = (error: Error | null, result?: T) => void;

// Use the type:
const sayHello: GreetFunction = (name) => `Hello, ${name}`;
const addOp: MathOperation = (a, b) => a + b;

// ===== Void vs undefined =====
function log(message: string): void {
  console.log(message);
  // return undefined; // This is fine — void accepts undefined
}

function precise(): undefined {
  return undefined; // Must explicitly return undefined
}

// ===== Function Overloads =====
// Multiple call signatures:
function process(input: string): string;
function process(input: number): number;
function process(input: boolean): boolean;

// Implementation — must handle all overloads:
function process(input: string | number | boolean): string | number | boolean {
  if (typeof input === "string") return input.toUpperCase();
  if (typeof input === "number") return input * 2;
  return !input;
}

// Usage:
const str = process("hello");  // type: string
const num = process(42);       // type: number
const bool = process(true);    // type: boolean

// ===== Overloads with Different Parameter Counts =====
function createElement(tag: "div"): HTMLDivElement;
function createElement(tag: "span"): HTMLSpanElement;
function createElement(tag: "input", options: { type: string }): HTMLInputElement;
function createElement(tag: string, options?: Record<string, unknown>): Element {
  const el = document.createElement(tag);
  if (options) Object.assign(el, options);
  return el;
}

// ===== When to Use Overloads vs Union Types =====
// ❌ Overloads not needed — union type is simpler:
function pad(value: string, padding: number | string): string {
  // Simple union parameter pattern
}

// ✅ Overloads needed — return type varies by input:
function fetchData(url: string): Promise<Response>;
function fetchData<T>(url: string, parser: (data: unknown) => T): Promise<T>;
function fetchData<T>(url: string, parser?: (data: unknown) => T) {
  return fetch(url).then(res => res.json())
    .then(data => parser ? parser(data) : data);
}

// ===== Inline Object Type =====
function printCoord(pt: { x: number; y: number }): void {
  console.log(`X: ${pt.x}, Y: ${pt.y}`);
}

// ===== Type Alias for Object =====
type Point = {
  x: number;
  y: number;
};

// ===== Interface for Object =====
interface Point3D {
  x: number;
  y: number;
  z: number;
}

// ===== Optional Properties =====
interface Config {
  url: string;
  timeout?: number;     // Optional
  retries?: number;     // Optional
  headers?: Record<string, string>;
}

// ===== Readonly Properties =====
interface User {
  readonly id: string;
  readonly createdAt: Date;
  name: string;
  email: string;
}

const user: User = { id: "1", createdAt: new Date(), name: "Alice", email: "a@b.com" };
// user.id = "2"; // ❌ Error: Cannot assign to readonly property

// ===== Index Signatures =====
interface StringDictionary {
  [key: string]: string;
}

const translations: StringDictionary = {
  hello: "Hola",
  goodbye: "Adiós",
};

// ===== Excess Property Checks =====
interface User {
  name: string;
  age: number;
}

// ❌ Direct object literal — strict check:
// const user: User = { name: "Alice", age: 30, email: "a@b.com" };
// Error: 'email' does not exist in type 'User'

// ✅ Intermediate variable — structural check only:
const userData = { name: "Alice", age: 30, email: "a@b.com" };
const user2: User = userData; // OK

// ===== Single Extension =====
interface Animal {
  name: string;
  age: number;
}

interface Dog extends Animal {
  breed: string;
  bark(): void;
}

const myDog: Dog = {
  name: "Rex",
  age: 3,
  breed: "German Shepherd",
  bark: () => console.log("Woof!"),
};

// ===== Multiple Inheritance =====
interface Flyable {
  fly(): void;
  altitude: number;
}

interface Swimmable {
  swim(): void;
  depth: number;
}

interface Duck extends Flyable, Swimmable {
  quack(): void;
}

// ===== Interface Extending Type =====
type Animal = { name: string; age: number };
interface Bear extends Animal {
  honey: boolean;
}

// ===== Overriding Properties =====
interface Base {
  id: string;
  value: unknown;
}

interface Detailed extends Base {
  value: { name: string; count: number }; // Narrow the value type
  description: string;
}

// ===== keyof — Get Keys as Union =====
interface User {
  name: string;
  age: number;
  email: string;
}

type UserKeys = keyof User;
// "name" | "age" | "email"

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const user: User = { name: "Alice", age: 30, email: "alice@test.com" };
const name = getProperty(user, "name"); // type: string
const age = getProperty(user, "age");   // type: number
// getProperty(user, "invalid"); // ❌ Error!

// ===== Indexed Access Types =====
type UserNameType = User["name"];  // string
type UserAgeType = User["age"];    // number
type UserNameOrAge = User["name" | "age"]; // string | number

// Get all value types:
type UserValues = User[keyof User]; // string | number

// ===== With Arrays =====
const arr = [{ name: "Alice", age: 30 }];
type ArrElement = (typeof arr)[number]; // { name: string; age: number }
type ArrValue = (typeof arr)[number]["name"]; // string

// ===== Real-World Pattern =====
function updateField<T, K extends keyof T>(obj: T, key: K, value: T[K]): T {
  return { ...obj, [key]: value };
}

const updated = updateField(user, "age", 31);
// updated.age is number — type-safe!

// ===== Without Generics — Lose type safety =====
function identity(value: any): any {
  return value;
}
const result = identity("hello");
result.toFixed(); // No error — but crashes at runtime!

// ===== With Generics — Type safety preserved =====
function identity<T>(value: T): T {
  return value;
}

const str = identity("hello");    // type: string
const num = identity(42);         // type: number
const bool = identity(true);      // type: boolean

// ===== Why TypeScript Infers Generics =====
function firstElement<T>(arr: T[]): T | undefined {
  return arr[0];
}

const first = firstElement([1, 2, 3]);    // type: number | undefined
const firstStr = firstElement(["a", "b"]); // type: string | undefined

// ===== Generic Constraints =====
interface HasLength {
  length: number;
}

function logLength<T extends HasLength>(arg: T): T {
  console.log(arg.length); // We know `length` exists
  return arg;
}

logLength("hello");      // ✅ string has length
logLength([1, 2, 3]);    // ✅ array has length
// logLength(42);        // ❌ Error: number has no length

// ===== Multiple Type Parameters =====
function pair<A, B>(a: A, b: B): [A, B] {
  return [a, b];
}

const p = pair("hello", 42); // type: [string, number]

// ===== Generic Interface =====
interface Repository<T> {
  getById(id: string): Promise<T | null>;
  getAll(): Promise<T[]>;
  create(data: Omit<T, "id">): Promise<T>;
  update(id: string, data: Partial<T>): Promise<T>;
  delete(id: string): Promise<boolean>;
}

// ===== Generic Class =====
class ApiRepository<T extends { id: string }> implements Repository<T> {
  constructor(private baseUrl: string) {}

  async getById(id: string): Promise<T | null> {
    const res = await fetch(`${this.baseUrl}/${id}`);
    if (!res.ok) return null;
    return res.json();
  }

  async getAll(): Promise<T[]> {
    const res = await fetch(this.baseUrl);
    return res.json();
  }

  async create(data: Omit<T, "id">): Promise<T> {
    const res = await fetch(this.baseUrl, {
      method: "POST",
      body: JSON.stringify(data),
    });
    return res.json();
  }

  async update(id: string, data: Partial<T>): Promise<T> {
    const res = await fetch(`${this.baseUrl}/${id}`, {
      method: "PATCH",
      body: JSON.stringify(data),
    });
    return res.json();
  }

  async delete(id: string): Promise<boolean> {
    const res = await fetch(`${this.baseUrl}/${id}`, { method: "DELETE" });
    return res.ok;
  }
}

// Usage:
interface User {
  id: string;
  name: string;
  email: string;
  createdAt: Date;
}

const userRepo = new ApiRepository<User>("/api/users");
const user = await userRepo.getById("123"); // type: User | null

// ===== Generic Factory Pattern =====
interface Factory<T> {
  create(): T;
}

class UserFactory implements Factory<User> {
  create(): User {
    return {
      id: crypto.randomUUID(),
      name: "New User",
      email: "user@example.com",
      createdAt: new Date(),
    };
  }
}

// ===== Generic Builder Pattern =====
class QueryBuilder<T> {
  private conditions: string[] = [];
  private limit?: number;

  where(condition: string): this {
    this.conditions.push(condition);
    return this;
  }

  take(n: number): this {
    this.limit = n;
    return this;
  }

  async execute(): Promise<T[]> {
    const query = this.buildQuery();
    return db.query(query);
  }

  private buildQuery(): string {
    return `SELECT * FROM ...`;
  }
}

const users = await new QueryBuilder<User>()
  .where("age > 18")
  .where("active = true")
  .take(10)
  .execute();

// ===== keyof with Generics =====
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const user = { name: "Alice", age: 30, email: "alice@test.com" };

const name = getProperty(user, "name"); // type: string
const age = getProperty(user, "age");   // type: number
// getProperty(user, "invalid");        // ❌ Error: not a key of user

// ===== Type-Safe Setter =====
function setProperty<T, K extends keyof T>(obj: T, key: K, value: T[K]): void {
  obj[key] = value;
}

setProperty(user, "name", "Bob");  // ✅ value must be string
setProperty(user, "age", 31);      // ✅ value must be number
// setProperty(user, "name", 42);  // ❌ Error: number is not assignable to string

// ===== Key Remapping (TS 4.1+) =====
type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

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

type UserGetters = Getters<User>;
// { getName: () => string; getAge: () => number }

// ===== Filtering Keys =====
type StringKeys<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K];
};

type UserStrings = StringKeys<User>;
// { name: string } — only string properties!

// ===== Real-World: Type-safe Event Emitter =====
type EventMap = {
  userCreated: { id: string; name: string };
  userDeleted: { id: string };
  error: { message: string; code: number };
};

class TypedEventEmitter<T extends Record<string, unknown>> {
  on<K extends keyof T>(event: K, handler: (data: T[K]) => void): void {
    // Implementation
  }

  emit<K extends keyof T>(event: K, data: T[K]): void {
    console.log(`Event: ${String(event)}`, data);
  }
}

const emitter = new TypedEventEmitter<EventMap>();
emitter.on("userCreated", (data) => {
  console.log(data.name); // typed! data is { id: string; name: string }
});
emitter.emit("userCreated", { id: "1", name: "Alice" });

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

// ===== Partial<T> — All properties optional =====
// Use: For update operations
function updateUser(id: string, updates: Partial<User>): void {
  // Only updates provided fields
}
updateUser("1", { name: "Alice" }); // Only specify what to update

// ===== Required<T> — All properties required =====
interface Config {
  url?: string;
  timeout?: number;
}

type StrictConfig = Required<Config>;
// { url: string; timeout: number } — both required

// ===== Readonly<T> — All properties readonly =====
type ImmutableUser = Readonly<User>;
// { readonly id: string; readonly name: string; ... }

// ===== Pick<T, K> — Select specific properties =====
type UserName = Pick<User, "name" | "email">;
// { name: string; email: string }

// ===== Omit<T, K> — Remove specific properties =====
type UserWithoutSensitive = Omit<User, "email" | "age">;
// { id: string; name: string; createdAt: Date }

// ===== Record<K, T> — Dictionary type =====
type PageInfo = { title: string; url: string };
type Pages = Record<string, PageInfo>;
// { [key: string]: { title: string; url: string } }

// ===== Exclude<T, U> — Remove from union =====
type Status = "active" | "inactive" | "pending" | "deleted";
type ActiveStatus = Exclude<Status, "deleted">;
// "active" | "inactive" | "pending"

// ===== Extract<T, U> — Keep only matching =====
type ExtractStatus = Extract<Status, "active" | "pending">;
// "active" | "pending"

// ===== NonNullable<T> — Remove null/undefined =====
type Maybe = string | null | undefined;
type Definitely = NonNullable<Maybe>; // string

// ===== ReturnType<T> — Get function return type =====
function createUser() {
  return { id: "1", name: "Alice" };
}
type UserType = ReturnType<typeof createUser>;
// { id: string; name: string }

// ===== Parameters<T> — Get function parameter types =====
function greet(name: string, age: number): void {}
type GreetParams = Parameters<typeof greet>;
// [name: string, age: number]

// ===== Awaited<T> — Unwrap promises =====
type AsyncResult = Promise<string>;
type Result = Awaited<AsyncResult>; // string

// ===== Real-World Example =====
interface FormState {
  name: string;
  email: string;
  age: number;
  terms: boolean;
}

type FormErrors = Partial<Record<keyof FormState, string>>;
type FormTouched = Record<keyof FormState, boolean>;

function useForm<T>() {
  const [values, setValues] = useState<T>();
  const [errors, setErrors] = useState<Partial<Record<keyof T, string>>>();
  return { values, errors };
}