TypeScript Bitwise AND

type IntersectedType = TypeA & TypeB & TypeC;

type Alpha = { a: string };
type Beta = { b: number };

type Gamma = Alpha & Beta; 
// Structurally equivalent to an object with both 'a' and 'b', 
// but represented internally and in tooltips as Alpha & Beta.

type ConfigA = { settings: { theme: string } };
type ConfigB = { settings: { telemetry: boolean } };

type AppConfig = ConfigA & ConfigB;
// The 'settings' property is intersected: { theme: string } & { telemetry: boolean }

type EntityA = { id: string };
type EntityB = { id: number };

type IntersectedEntity = EntityA & EntityB;
// The 'id' property becomes string & number, resolving to never.

type DiscriminatedA = { kind: 'a', value: string };
type DiscriminatedB = { kind: 'b', count: number };

type ImpossibleIntersection = DiscriminatedA & DiscriminatedB;
// The entire type resolves to never, because the mutually exclusive 
// literal types in the 'kind' discriminant make the intersection impossible.

type Impossible = string & number;  // never
type AlsoImpossible = true & false; // never

type WithAny = string & any;         // any
type WithUnknown = string & unknown; // string
type WithNever = string & never;     // never

type LoggerA = (msg: string) => void;
type LoggerB = (code: number) => boolean;

type CombinedLogger = LoggerA & LoggerB;
// Structurally equivalent to an overloaded function accepting either a string or a number.

type A = { type: 'A' };
type B = { type: 'B' };
type C = { shared: boolean };

type Distributed = (A | B) & C;
// Resolves to: (A & C) | (B & C)