TypeScript is an open-source programming language developed by Microsoft. It is a superset of JavaScript that adds static typing and compile-time error checking.

• Type Safety
• Better IntelliSense
• Improved Refactoring
• Easier Maintenance
• Better Developer Experience

let value: any = 10;

let userInput: unknown = 'John';

function throwError(): never {
  throw new Error('Something went wrong');
}

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

type Employee = {
  id: number;
  name: string;
};

• Interfaces support declaration merging
• Types can represent unions
• Types can represent primitives
• Interfaces are preferred for object contracts

Generics allow writing reusable and type-safe code.

function identity<T>(value: T): T {
  return value;
}

identity<string>('Hello');

identity<number>(100);

• Reusable Code
• Compile-time Type Safety
• Better IDE Support

type User = {
  name: string;
};

const user = {} as User;

console.log(user.name);

Answer

The code compiles successfully but prints undefined.

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

type PartialUser = Partial<User>;

type ReadonlyUser = Readonly<User>;

type UserName = Pick<User, 'name'>;

• Partial
• Readonly
• Pick
• Omit
• Record
• Required

function print(value: string | number) {

  if (typeof value === 'string') {
    console.log(value.toUpperCase());
  }

}

Type Guards help TypeScript narrow types safely during runtime checks.

• typeof
• instanceof
• in operator
• Custom Guards

type IsString<T> =
  T extends string
    ? true
    : false;

type A = IsString<string>;

type B = IsString<number>;

Conditional Types allow creating dynamic types based on conditions.

type ReadonlyType<T> = {

  readonly [K in keyof T]: T[K];

};

Mapped Types transform existing types into new types.

• DTO Generation
• Readonly Objects
• API Response Models
• Form Models

interface ApiResponse<T> {

  success: boolean;

  data: T;

  message?: string;

}

const response: ApiResponse<string> = {

  success: true,

  data: 'User Created'

};

Interview Follow-up

• How would you handle API errors?
• How would you support pagination?
• How would you model nested responses?

• Compile-time validation
• Improved maintainability
• Safe refactoring
• Reduced production bugs
• Better team collaboration

interface Events {

  login: {
    userId: number;
  };

  logout: {
    userId: number;
  };

}

function emit<K extends keyof Events>(
  event: K,
  payload: Events[K]
) {

  console.log(event, payload);

}

What Interviewers Evaluate

• Generics Knowledge
• Type Inference Understanding
• Scalable Design Thinking
• Architecture Skills

These types allow composing complex structures from basic types:

• Union Types (|): Represents a value that can be one of several types (either A OR B). Used when variables can receive different input formats.
• Intersection Types (&): Combines multiple types into one, requiring the value to satisfy all combined interfaces (A AND B). Used to extend objects or mix in behaviors.

// Union Type
type Status = 'success' | 'error' | 'loading';
let current: Status = 'success';

// Intersection Type
interface Loggable { log: () => void; }
interface Identifiable { id: string; }

type Entity = Loggable & Identifiable;
const obj: Entity = {
  id: 'E101',
  log: () => console.log('Log entry')
};

Type Narrowing is the process of resolving a broad type (like a union type) into a more specific type within conditional execution blocks.

• typeof: Used to check primitive values (e.g. typeof value === 'string').
• instanceof: Used to check class constructor allocations (e.g. value instanceof Date).
• in operator: Checks if a specific property exists inside an object (e.g. 'role' in user).

function processValue(val: string | Date | { role: string }) {
  if (typeof val === 'string') {
    console.log(val.toUpperCase()); // Narrowed to string
  } else if (val instanceof Date) {
    console.log(val.getFullYear()); // Narrowed to Date
  } else if ('role' in val) {
    console.log(val.role); // Narrowed to object
  }
}

While similar, they differ in how they handle property conflict checks:

• Interface Extension (extends): Enforces strict verification. If you extend an interface and redefine a property with an incompatible type, the compiler throws a compile error immediately.
• Type Intersection (&): Merges properties. If property types conflict, it creates an never type for that property rather than throwing a compile error immediately.

// Interface conflict throws compile error
interface A { id: string; }
// interface B extends A { id: number; } // Compile Error!

// Type intersection merges types (results in never)
type C = { id: string };
type D = { id: number };
type E = C & D; // E.id is 'string & number' which resolves to never!

Literal types restrict variables to specific exact values rather than general types:

• Literal Types: Limit values to specific strings, numbers, or booleans (e.g. let role: 'admin').
• Template Literal Types: Built on string literal types, allowing you to combine literal segments using template string syntax (e.g. `on-${Event}`).

type Direction = 'left' | 'right';
type Margin = `margin-${Direction}`; // 'margin-left' | 'margin-right'

Type Assertions tell the compiler to treat a value as a specific type, bypassing default type inference checks:

• Assertion vs Casting: In C# or Java, type casting performs runtime conversions. In TypeScript, assertions are compile-time directives and do not modify the compiled JavaScript outputs.
• Double Assertion: Required when types do not overlap (e.g., converting a string to a number). Since you cannot assert incompatible types directly, you must assert to unknown or any first.

const val = '123';
// const num = val as number; // Compile Error: no overlap!
const num = val as unknown as number; // Double assertion passes compiler

Both enforce read-only properties, but differ in scope:

• readonly property: Applied to individual properties inside interface definitions or classes.
• Readonly<T>: A utility type that wraps an entire interface type, making all of its properties read-only automatically.

interface User {
  readonly id: string;
  name: string;
}

type FullyReadonlyUser = Readonly<User>; // Both id and name are now read-only!

Enums define collections of named constants:

• Numeric Enums: Store values as numbers (starting at 0). Support reverse mappings (looking up key names by value).
• String Enums: Store values as strings, providing clearer error output. Do not support reverse mappings.
• const enum: Inline constant values during compilation, generating no runtime objects. This reduces bundle size.

Generic Constraints restrict the types that can be passed to a generic parameter using the extends keyword. This allows you to access specific properties (e.g. length) safely inside generic functions.

interface Lengthwise {
  length: number;
}

function logLength<T extends Lengthwise>(arg: T): T {
  console.log(arg.length); // Safe to access length property
  return arg;
}

logLength('hello'); // Works
// logLength(123); // Compile Error: number lacks a length property!

These models determine type compatibility differently:

• Nominal Typing: Compatibility is based on explicit type declarations and names (like in C++ or Java).
• Structural Typing: Compatibility is based on the structure (shape) of the object. If two objects share the same properties and types, they are compatible, regardless of their declared names.
• TypeScript's Choice: TypeScript uses structural typing because it matches JavaScript's dynamic patterns, where objects are defined ad-hoc.

class User { name!: string; }
class Product { name!: string; }

const user: User = new Product(); // Valid because shapes are identical!

These operators are used to extract types from values or keys:

• keyof: Takes an object type and returns a union type of its keys.
• typeof: Used in type queries to extract the TypeScript type of an active variable or object instance.

const config = { api: '/api', timeout: 5000 };

type ConfigType = typeof config; // { api: string, timeout: number }
type ConfigKeys = keyof ConfigType; // 'api' | 'timeout'

These features allow extending existing type definitions:

• Declaration Merging: The compiler automatically merges multiple declarations sharing the same name (e.g., merging two interfaces with the same name).
• Module Augmentation: Allows adding properties to external modules by declaring them within a matching module definition wrapper.

// Module Augmentation
import { AxiosRequestConfig } from 'axios';

declare module 'axios' {
  interface AxiosRequestConfig {
    retryCount?: number; // Augment retry properties safely
  }
}

These files and declarations provide type descriptions for code that does not have native TypeScript types:

• Declaration Files (.d.ts): Files containing only type declarations. They generate no compiled JavaScript output. Used to provide types for compiled JavaScript libraries.
• Ambient Declarations: Tell the compiler that a variable or module exists externally (e.g. globally in the browser), preventing compile errors.

// global.d.ts
declare global {
  const APP_VERSION: string; // Declare global variable
}

Namespaces are an internal module system used to group related code under a single global object name.

• Replacement: ES Modules are now the standard module format, resolving dependencies at compile time and enabling tree-shaking.
• When Useful: Namespaces are still useful for grouping global type definitions inside declaration files (.d.ts) without importing them explicitly.

These options configure the type checking and compilation behavior:

• strict: Enables all strict type-checking options.
• noImplicitAny: Throws errors on expressions where the type defaults to any implicitly.
• strictNullChecks: Treats null and undefined as distinct types, preventing runtime property reads on null references.
• target: Specifies the ECMAScript target version for output files (e.g. ES2022).
• moduleResolution: Determines how TypeScript resolves module imports (e.g. node16, bundler).

While both return booleans at runtime, they handle types differently during compilation:

• Boolean Function: Returns a boolean without notifying the compiler about type changes. The compiler does not narrow types inside conditional blocks.
• Type Guard (is): Tells the compiler that if the function returns true, the variable is guaranteed to match the asserted type, enabling type narrowing.

interface User { role: string; }

// Custom Type Guard
function isUser(obj: any): obj is User {
  return obj && typeof obj.role === 'string';
}

The satisfies operator validates that an object matches a specific type structure without changing its inferred type:

• satisfies: Validates the type structure but retains the most specific inferred type (e.g. preserving string literal types).
• as assertion: Forces the compiler to treat an object as the specified type, which can widen types and hide missing property errors.

type Colors = 'red' | 'blue';
const config = {
  red: '#ff0000',
  blue: [0, 0, 255]
} satisfies Record<Colors, string | number[]>;

// Retains specific inferred types (preserves string methods for red)
config.red.toUpperCase(); 

Const Type Parameters allow generic parameters to automatically infer read-only, literal types when passed arguments, removing the need for as const assertions.

// Const generic parameter T
function getRoles<const T extends readonly string[]>(roles: T) {
  return roles;
}

const list = getRoles(['admin', 'user']); // Inferred type is readonly ['admin', 'user']

The infer keyword is used inside conditional type checks to declare a type variable that can be inferred dynamically by the compiler.

// Extract return type of a function
type MyReturnType<T> = T extends (...args: any[]) => infer R ? R : any;

// Extract resolution type of a Promise
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

type A = UnwrapPromise<Promise<string>>; // string

Mapped types can add or remove property modifiers (like readonly or ?) using prefix modifiers (+ or -):

• -readonly: Removes the read-only modifier, making properties writable.
• -?: Removes the optional modifier, making all properties required.

type MutableRequired<T> = {
  -readonly [K in keyof T]-?: T[K];
};

interface User {
  readonly id: string;
  name?: string;
}
type CustomUser = MutableRequired<User>; // id is mutable, name is required!

TypeScript 5.0 introduced native support for ECMAScript decorators, replacing the legacy Microsoft decorators:

• Legacy Decorators: Require setting experimentalDecorators: true. Use old parameter signatures and evaluate class members during design-time.
• Native Decorators: Match native TC39 standards. Use type-safe signatures and receive context objects detailing properties, accessors, and metadata.

// Native Method Decorator
function log(target: any, context: ClassMethodDecoratorContext) {
  console.log(`Decorated method: ${String(context.name)}`);
}

reflect-metadata is a polyfill library that adds metadata APIs to class definitions and class properties. In DI frameworks (like Angular or NestJS), the compiler reads constructor parameter types using reflect-metadata, allowing the DI container to resolve dependencies automatically at runtime.

Optimizing builds guarantees fast compilation times in large projects:

• Incremental Builds: Set incremental: true in tsconfig to cache file dependency structures, compiling only modified files.
• Project References: Splits a monolithic workspace into independent projects (using `references`), allowing separate compilations.
• skipLibCheck: Skips type-checking declaration files (.d.ts) of npm dependencies, reducing compile times.

These terms define how type relationships behave under transformations:

• Covariance: Retains type relationships. A subtype can be assigned to a base type (e.g. object property types).
• Contravariance: Reverses type relationships. A base type can be assigned to a subtype. This applies to function parameters (under strictFunctionTypes).

- Function returns are **covariant**: A function returning a Subtype is compatible with a signature returning a BaseType.
- Function arguments are **contravariant**: A function accepting a BaseType is compatible with a signature accepting a Subtype.

Recursive types reference themselves in their definition, which allows modeling nested data structures:

// Nested JSON structure type
type JSONValue = 
  | string 
  | number 
  | boolean 
  | null 
  | { [key: string]: JSONValue } 
  | JSONValue[];

// Deep Readonly utility
type DeepReadonly<T> = {
  readonly [K in keyof T]: DeepReadonly<T[K]>;
};

Control Flow Analysis (CFA) narrows types dynamically based on execution paths.

• The Failure: When narrowing a variable and reference it inside a closure (e.g. an arrow function), the type narrowing is lost.
• Why it Fails: The compiler cannot guarantee when the closure will run. If the variable is mutated between declaration and execution, the type check is no longer valid.

let val: string | null = 'hello';
if (val !== null) {
  // Val is narrowed to string here
  const callback = () => {
    // val is string | null here because it could have mutated!
    console.log(val.toUpperCase()); // Compile Error!
  };
}

TypeScript is erased at runtime, meaning compile-time type checks cannot prevent invalid API responses. To design type-safe APIs, combine compile-time types with runtime validation using libraries like **Zod** or **io-ts**:

• Schema: Define validation schemas.
• Inference: Infer TypeScript types directly from the schemas, keeping types and validations in sync.

import { z } from 'zod';

const UserSchema = z.object({
  id: z.string(),
  email: z.string().email()
});

// Infer type dynamically
type User = z.infer<typeof UserSchema>;

You can use template literal types and recursive inference to extract route parameter types directly from route path strings.

type ExtractParams<T extends string> = 
  T extends `${string}/:${infer Param}/${infer Rest}`
    ? { [K in Param | keyof ExtractParams<`/${Rest}`>]: string }
    : T extends `${string}/:${infer Param}`
      ? { [K in Param]: string }
      : {};

// Usage
type Params = ExtractParams<'/users/:id/posts/:postId'>; // { id: string, postId: string }

Tools like Vite and ESBuild compile TypeScript files individually without performing type-checking.

• isolatedModules: This setting warns you if you use features that require cross-file type analysis (e.g. ambient namespaces, const enums, or type-only exports).
• Resolution: Force clean imports/exports using import type to allow bundlers to compile files independently and safely.

A type-safe state engine should map action types to their payloads statically, preventing dispatch of invalid payload shapes.

interface ActionMap {
  ADD_USER: { id: string; name: string };
  DELETE_USER: { id: string };
}

class Store<S> {
  dispatch<K extends keyof ActionMap>(action: K, payload: ActionMap[K]) {
    console.log('Dispatching action:', action, payload);
  }
}

TypeScript is structurally typed, which can allow mixing up different identifiers (e.g. passing a User ID to a Product ID argument). To prevent this, use **Branded Types** to simulate nominal typing by attaching unique property flags to types.

type Brand<K, T> = K & { __brand: T };

type UserId = Brand<string, 'user'>;
type ProductId = Brand<string, 'product'>;

function deleteUser(id: UserId) {}

const userId = '101' as UserId;
const productId = '101' as ProductId;

// deleteUser(productId); // Compile Error: types are incompatible!
deleteUser(userId); // Works

A DI container resolves dependencies recursively. It uses generic registrations to map token keys to target class constructors, ensuring that resolved instances match their registered classes.

Migrating a large codebase requires an incremental, step-by-step approach to avoid breaking builds:

• Phase 1: Tooling: Configure TypeScript to allow JavaScript files (allowJs: true, checkJs: false) and set noImplicitAny: false.
• Phase 2: JSDoc Types: Add types to core libraries using JSDoc comments.
• Phase 3: Core Conversion: Convert critical utility and model files to TypeScript (.ts).
• Phase 4: Strict Mode: Enable strict options (like strictNullChecks) progressively across folders.

The Dependency Inversion Principle states that high-level modules should depend on abstractions (interfaces), not concrete implementations. In TypeScript, interfaces do not exist in compiled JavaScript, so we must inject dependencies using Injection Tokens (using unique classes or symbols) to resolve implementations at runtime.

Map table schemas to types using generic types. We can define column types programmatically, allowing query methods to return type-safe row entities.

Create a middleware factory that accepts a validation schema (like Zod). If validation fails, return a 400 response; if it passes, attach the validated object to the request with proper types.

Use a validation schema to parse environment variables, set default values, and freeze the output object (using Object.freeze) to prevent runtime modifications.

In JavaScript, object keys are converted to strings, numbers, or symbols during lookup. As a result, keyof any resolves to the union type string | number | symbol, which represents any valid object key type.

The non-null assertion operator (!) tells the compiler that a variable is not null or undefined, bypassing strict null checks.

• The Hazard: It does not perform runtime checks. If the value is nullish at runtime, the code will fail with an error.
• Alternatives: Use optional chaining (?.), nullish coalescing (??), or type narrowing checks.

TypeScript's private modifier is a compile-time check; compiled JavaScript classes do not enforce private properties, making them accessible at runtime.

• ES Private Fields: Native private fields (using #) are enforced by the JavaScript engine at runtime. Accessing them from outside the class throws a syntax error.

This difference is caused by **Excess Property Checks**:

• Object Literal: Passed directly as a parameter, the compiler performs strict check to catch typos, throwing errors if extra properties are found.
• Variable Assignment: Assigned to a variable first, compatibility is checked structurally. If the required properties exist, extra properties are allowed and ignored.

These types differ in key indexing capabilities:

• {}: Represents any non-nullish value, which can prevent accessing properties dynamically.
• object: Represents any non-primitive type, but does not allow key lookup accesses.
• Record<string, unknown>: Explicitly defines an object with string keys, allowing property access while enforcing type safety.

The second parameter of Omit<T, K> is typed as any string, which disables key auto-completion in IDEs.

Solution: Restrict keys using keyof T in your custom type definition:

type StrictOmit<T, K extends keyof T> = Omit<T, K>;

Like shallow copying, the readonly modifier is shallow. It only prevents re-assigning top-level properties. If a property is a reference type (like an array or object), its nested properties can still be mutated.

The as const assertion sets literal types as read-only and prevents type widening:

• Arrays are converted to read-only tuples.
• Object properties are set as read-only.
• Strings, numbers, and booleans are restricted to their exact literal values.

An application compiled without errors, but crashed in production with Cannot read property of undefined when processing API responses.

The developer used type assertions (as User) on an HTTP request promise. Since assertions are compile-time directives, they do not validate the API payload shape at runtime. If the API returns unexpected data shapes, the code will fail with runtime errors.

• Validate API response shapes at runtime using schema validation libraries like Zod or io-ts before processing data.

After adding complex utility types to a shared library, build times spiked across all applications in the monorepo.

The shared library introduced deeply recursive mapped types. These types require excessive calculations by the compiler to resolve properties, causing compilation bottlenecks.

• Simplify recursive types or use interfaces instead of complex type aliases where possible.
• Analyze compiler performance using tsc --extendedDiagnostics to identify slow type checks.

The application builds successfully, but crashes on page load with ReferenceError: MyNamespace is not defined.

The developer used ambient namespaces inside declaration files (.d.ts) but referenced them as runtime values instead of type-only definitions. Since declarations are erased during compilation, accessing them at runtime throws ReferenceErrors.

• Only use declaration files for type declarations. Never export runtime values or variables from declaration files.

The compiler resolves imports successfully, but the application throws import errors at runtime when loading lazy-routed modules.

The developer configured path mapping aliases (e.g. @core/*) in tsconfig.json, but did not configure the bundler (like Webpack or Vite) to resolve these aliases in the output bundle.

• Ensure path mappings are configured in both tsconfig.json and your bundler config (e.g. using `tsconfig-paths-webpack-plugin` or `vite-tsconfig-paths`).

A Node.js backend using class decorators builds without errors, but fails to run inside the ESM runtime, throwing syntax errors.

ESM runtimes verify imports strictly. If compile targets (e.g. `target`) or decorator configurations are misaligned, Node.js cannot parse decorators at runtime.

After importing a shared module, the client bundle size doubled unexpectedly.

The shared module used namespaces instead of ES Modules. Namespaces compile to IIFE closures, which bundlers cannot analyze statically for tree-shaking, including unused code in the final bundle.

• Refactor namespaces to ES Modules (using `export`/`import` statements) to enable tree-shaking and bundle optimization.

Implement a recursive mapped type that removes the optional modifier (-?) from all properties and nested objects.

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

Create an EventEmitter class that accepts a generic event contract map, enforcing event payload types statically.

class TypedEmitter<Events extends Record<string, any>> {
  private listeners = new Map();

  on<K extends keyof Events>(event: K, listener: (payload: Events[K]) => void) {
    if (!this.listeners.has(event)) this.listeners.set(event, new Set());
    this.listeners.get(event).add(listener);
  }

  emit<K extends keyof Events>(event: K, payload: Events[K]) {
    const list = this.listeners.get(event);
    if (list) list.forEach(fn => fn(payload));
  }
}

Implement a recursive template literal type that joins elements of a string array using a separator character.

type Join<T extends readonly string[], D extends string> = 
  T extends readonly [] ? ''
    : T extends readonly [infer F extends string]
      ? F
      : T extends readonly [infer F extends string, ...infer R extends string[]]
        ? `${F}${D}${Join<R, D>}`
        : string;

// Usage
type Joined = Join<['a', 'b', 'c'], '-'>; // 'a-b-c'

Implement a recursive mapped type that makes all properties (and nested properties) optional.

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

Write a deep-merging function in TypeScript that merges two config objects, returning an intersected type of both parameters.

function deepMerge<T extends object, U extends object>(target: T, source: U): T & U {
  const result = { ...target } as any;
  for (const key in source) {
    if (Object.prototype.hasOwnProperty.call(source, key)) {
      if (typeof source[key] === 'object' && source[key] !== null && typeof target[key as any] === 'object') {
        result[key] = deepMerge(target[key as any] as any, source[key] as any);
      } else {
        result[key] = source[key];
      }
    }
  }
  return result;
}

Create a mapped type that updates function signatures: if a function takes a callback as its last argument, return a Promise instead.

Using Record<keyof any, any> widens key mappings to general string index signatures, losing specific literal key types. As a result, mapped types cannot resolve literal keys, disabling compile-time autocomplete checks.

Resolution: Restrict keys using string or specific literal unions (e.g. K extends keyof any) to preserve type definitions.

Key remapping (as NewKey) evaluates keys dynamically. When operating on generic types, the compiler cannot verify the key relationships at compile time, which widens keys to string and loses type constraints.

By default, if the checked type is a naked generic parameter, conditional types **distribute** over union elements (evaluating each union item individually).

• How to Disable: Wrap the extends check parameters in square brackets ([T] extends [any]) to disable distribution and evaluate the union as a single type.

// Distributive (evaluates string | number individually)
type Distributive<T> = T extends any ? T[] : never;

// Non-distributive (evaluates the union as a single type)
type NonDistributive<T> = [T] extends [any] ? T[] : never;

TypeScript enforces a recursion depth limit (typically 50-100 stack frames) to prevent compiler hangs. Deep recursive template literal types quickly exceed this limit, throwing the instantiation error.

Optimization: Flatten recursion steps or use tail-call recursive templates (matching patterns where the accumulator is passed in the tail position), which allows the compiler to optimize stack usage.

JavaScript engines do not support generics natively. During compilation, TypeScript erases all generic parameters. As a result, metadata reflection queries (via `reflect-metadata`) resolve class parameters to their base compiled type (Object), losing the generic context.

With isolatedModules: true, compilers (like ESBuild or Babel) process files individually without reading other files. Because ambient namespaces rely on cross-file declaration lookups, the compiler cannot verify them, causing compile errors. This prevents compiling namespaces as modular entities in monorepo bundles.

Mapped types operate on property descriptors. Removing the optional modifier (-?) on dynamic class getters can widen properties to include undefined, which breaks type inference for class methods.

Resolution: Filter out getters using key remapping (as) or map properties explicitly to prevent modifying class method signatures.

This behavior is caused by **Contravariance**:

• Function returns: Covariant. Inferred type variables resolve to **union types** because outputs are additive.
• Function parameters: Contravariant. Inferred type variables resolve to **intersection types** because parameters must satisfy all possible usage contracts simultaneously.

In conditional types, never is treated as an empty union. When a union is evaluated distributively, an empty union has nothing to distribute over, so the check returns never immediately without evaluating the conditional branches.

Resolution: Wrap the parameter in square brackets ([T] extends [never]) to disable distribution and evaluate the parameter correctly.

In TypeScript, void and undefined represent different values:

• undefined: An active JavaScript value. A function typed as returning undefined **must** return undefined explicitly.
• void: Represents a function where the return value is ignored. Assigning a void-returning function to an undefined-returning callback throws errors because the compiler cannot guarantee the return value is undefined.

The satisfies operator validates the type structure without changing its inferred type, which preserves specific literal value types. Type assertions (as) force the compiler to treat the object as the asserted type, which widens literal properties to base types (e.g. 'red' becomes string), disabling exact key lookups.

According to declaration merging specifications, namespaces can merge with interfaces and classes because they represent different entities (namespaces create values; interfaces represent types). Type aliases are static declarations and cannot merge with other declarations, throwing duplicate identifier errors if names conflict.