Types

A | B is one of the two, so only the members both share are usable until you narrow it. A & B satisfies both at once, so the members of both are available. Widening the value set narrows usable members; constraints add them.

any opts out of type checking — it is assignable to and from anything, so it gives no safety and is best avoided. unknown is the type-safe counterpart: any value is assignable to it, but you must narrow it with a type guard before use. never is the empty type with no values; it is the return type of a function that always throws or never returns, and the type of an exhausted union.

undefined is a real type with one value, undefined. void is the return type of a function that completes without returning a useful value — the caller must ignore the result. never is the empty type with no values at all; it types a function that never finishes normally (one that always throws or loops forever) and marks exhausted branches. So void returns nothing useful, while never never returns.

A literal type's only inhabitant is one exact value — 'a', 42, or true. 'a' | 'b' admits exactly those two strings, while string admits every string. So the compiler rejects a typo like 'c' right at the call site.

unknown is the type-safe top type: every value is assignable to it, but it is assignable to nothing else. You cannot call, index, or read a property from it until narrowed — typeof, instanceof, a type guard. any permits it all unchecked.

An enum defines a named set of related constants. Numeric enums auto-assign 0, 1, 2… from the first member, while string enums take explicit string values. Use one to replace magic numbers or strings with readable names and to group related options like HTTP methods or statuses. Numeric enums emit a runtime object with reverse mapping (value → name); string enums read clearly in output but have no reverse map.

A tuple fixes the length and each position's type: t[0] is string, t[1] number. (string | number)[] fixes no length and types every index as the union, so reads need narrowing. The guarantee is compile-time only: push still runs.

In a type position typeof x is a type query: it yields the static type inferred for x. It is erased and never runs, unlike the JavaScript operator returning a runtime string. It bridges a value into the type world: type Cfg = typeof config.

any disables checking and spreads into every derived value, so mistakes surface at run time. unknown takes the same values but is assignable to nothing, forcing a typeof check or type guard first — errors surface while type-checking.

The primitives are boolean, number (one numeric type for ints and floats), string, plus bigint and symbol. Collections come as arrays (number[] or Array<number>) and tuples — fixed-length arrays with a type per position ([string, number]). TypeScript also adds enum and the special types any, unknown, void, never, and null/undefined.

object is any non-primitive value — never a string or a number. Object is the Object.prototype interface, satisfied by almost every value, primitives included, so it barely constrains. {} is anything but null and undefined.

A numeric enum auto-numbers from 0 and emits a reverse map, so E[0] yields 'A'. A string enum needs an explicit value per member, emits no reverse map, and is self-describing at run time. Both emit a real object, unlike a literal union.

A regular enum compiles to a runtime object — extra JavaScript that supports reverse mapping (value → name) and can be iterated. A const enum is fully inlined at compile time: each member usage is replaced by its literal value and no object is emitted, which shrinks the output. The trade-off is that you lose reverse mapping and any runtime presence, and const enum clashes with isolatedModules and some bundlers, so it cannot be used where a runtime object is needed.

An intersection admits only values meeting both constraints; nothing is both string and number. That empty set is never, and the compiler reduces it while type-checking. Object intersections stay inhabitable unless a property clashes.

A rest element preserves positions: prepend typed [H, ...T] keeps every index, while a plain array gives only T[]. Object spread overwrites, as at run time: a key present in both takes the second object's type. No any, no assertion.