TypeScript Intersection Type

type TypeA = { a: number };
type TypeB = { b: string };
type TypeC = { c: boolean };

type IntersectedType = TypeA & TypeB & TypeC;

type Identifiable = { id: string };
type Auditable = { createdAt?: Date; updatedAt?: Date };

type Entity = Identifiable & Auditable;
// Preserved as `Identifiable & Auditable`.
// Structurally equivalent to an object requiring 'id', with optional 'createdAt' and 'updatedAt'.

type Left = { shared: { a: number }; uniqueLeft: string };
type Right = { shared: { b: boolean }; uniqueRight: number };

type Combined = Left & Right;
// Combined['shared'] is evaluated as `{ a: number } & { b: boolean }`

type OptionalProp = { a?: string; b: number };
type RequiredProp = { a: string; c: boolean };

type MergedProps = OptionalProp & RequiredProp;
// Structurally equivalent to { a: string; b: number; c: boolean }
// 'a' becomes strictly required.

type StringAndNumber = string & number; // Evaluates to 'never'

type X = { status: string };
type Y = { status: number };

type Z = X & Y; 
// Z evaluates to { status: never }

type Success = { status: 'success'; data: string };
type Failure = { status: 'error'; code: number };

type Result = Success & Failure;
// Result evaluates directly to 'never' because 'success' and 'error' are disjoint unit types.

type StringProcessor = (x: string) => void;
type NumberProcessor = (x: number) => void;

type Processor = StringProcessor & NumberProcessor;
// Evaluates to an overloaded function type:
// ((x: string) => void) & ((x: number) => void)

type WithAny = string & any;         // Evaluates to 'any'
type AnyAndNever = any & never;      // Evaluates to 'never'
type WithUnknown = string & unknown; // Evaluates to 'string'

type UnionA = 'x' | 'y';
type UnionB = 'y' | 'z';

type Intersection = UnionA & UnionB;

// Step 1: Distribute
// ('x' & 'y') | ('x' & 'z') | ('y' & 'y') | ('y' & 'z')

// Step 2: Evaluate intersections
// never | never | 'y' | never

// Step 3: Simplify
// Intersection evaluates to 'y'