Ambient declaration — a declaration (declare module/declare var/declare function) that describes a type/value with no runtime implementation of its own; conventionally lives in .d.ts files. (Ch15, Ch25, Ch32)
Assignability — TypeScript's core compatibility relationship: T is assignable to S if a T value is an acceptable substitute wherever S is expected. Directional — S assignable to T doesn't imply the reverse. (Ch16, Ch28)
Best common type — the inference algorithm used when multiple expressions (e.g. array elements) contribute to one inferred type; picks a candidate compatible with all inputs, falling back to a union or no inference if none exists. (Ch29)
Conditional type — T extends U ? X : Y, a type-level if/else; distributes automatically over a union when T is a bare type parameter. (Ch09, Ch17, Ch28)
Const enum — an enum fully inlined at every use site during compilation, generating no runtime object; restricted to constant-expression members. (Ch20)
Constructor type — a type describing something callable with new, written new (...args) => T; the basis for factory-pattern generics and mixins. (Ch07, Ch13, Ch23)
Contextual typing — inference that flows "backward" from an expression's location (assignment target, call argument, return position) into the expression itself. (Ch29)
Declaration merging — combining two or more same-named declarations (interfaces, namespaces, namespace+class/function/enum) into one definition. (Ch18)
Discriminated union — a union where every member shares one literal-typed field (the discriminant); checking that field narrows to the exact member. (Ch03, Ch20)
Distributive conditional type — a conditional type built from a bare generic parameter that automatically maps itself over each member of a union argument. (Ch09, Ch17)
Excess property check — extra validation applied specifically to object literals assigned/passed directly to a typed target, flagging properties the target type doesn't declare. (Ch05, Ch16, Ch28)
Host — the system (runtime or bundler) that actually consumes emitted/compiled code and directs its module-loading behavior; TypeScript's module analysis exists to model the host accurately. (Ch34)
infer — keyword introducing a new type variable inside a conditional type's extends clause, capturing part of a matched type declaratively. (Ch09, Ch17, Ch30)
Index signature — [key: string]: T, describing an object type whose exact key set isn't known ahead of time. (Ch05, Ch17)
Indexed access type — Type["prop"], extracting a specific property's type from another type; also works with number for array/tuple element types. (Ch08)
keyof — type operator producing a union of an object type's keys (or its index signature's key type). (Ch06)
Literal type — a type representing one specific value ("hello", 42, true); combined into unions to express closed sets of allowed values. (Ch02)
Mapped type — a type built by iterating another type's keys ({ [P in keyof T]: ... }), optionally adding/removing readonly/? modifiers or remapping keys via as. (Ch05, Ch10)
Module augmentation — patching an existing exported declaration from another module via declare module "path" { ... }; easily confused with an ambient module declaration (same syntax, different meaning depending on whether the containing file is a module). (Ch18, Ch32)
Module resolution — the host-defined process of turning an import/require specifier string into a file on disk; governed by the moduleResolution compiler option. (Ch33, Ch34)
Narrowing — refining a value's static type to something more specific than declared, based on runtime checks (typeof, instanceof, in, equality, type predicates, discriminant checks). (Ch03, Ch17)
never — the type of a value that can never occur; assignable to everything, nothing (but never) assignable to it. Also what a fully-narrowed-away union or exhausted conditional collapses to. (Ch02, Ch03, Ch04)
Overload signatures — multiple declared call shapes for one function name, backed by a single, broader (uncallable-from-outside) implementation signature. (Ch04, Ch12)
Parameter property — a constructor parameter prefixed with a visibility modifier (public/private/protected/readonly) that both declares and assigns a same-named class field. (Ch13)
Structural typing — TypeScript's compatibility model: types relate based purely on their shape/members, never on declared names or explicit implements/extends relationships. (Ch12, Ch28)
this type — a type referring dynamically to the current class (or a subclass of it); enables fluent/chainable APIs and this is Type guards. (Ch13, Ch17)
Tuple type — a fixed-length, fixed-position array type ([string, number]), optionally with optional or rest elements at the end. (Ch05)
Type assertion — x as T (or <T>x), telling the compiler to treat a value as a more/less specific type; compile-time only, no runtime check. (Ch02)
Type guard — an expression TypeScript recognizes as narrowing a type within a branch (typeof, instanceof, in, or a user-defined x is T predicate function). (Ch03, Ch17)
unique symbol — a symbol subtype tracking one specific declaration's identity individually; only valid on const/readonly static declarations. (Ch26)
unknown — the type-safe counterpart to any: accepts any value, but nothing can be done with it until narrowed/asserted. (Ch04)
Variance (covariance/contravariance) — how a generic type's subtyping relationship follows (or reverses) its type parameter's; TypeScript infers this automatically in almost all cases. (Ch07)