Type System

Everything type-level is erased: annotations, interface, type aliases, generics and as all disappear, and the output is plain JavaScript with unchanged semantics. Only value-level constructs emit code — class, enum, namespace.

Nothing, and it cannot fail. as is erased: it only instructs the compiler to treat the expression as another type, performing no conversion and no check. So await res.json() as User is a claim about the payload, not a verification of it.

Everything about that value. any is assignable in both directions, so you may read any property, call it, index it, and pass it anywhere without a complaint. Each of those operations yields any in turn, so it spreads downstream.

It is defensible in a constraint position a caller never sees — T extends (...args: any[]) => any — and in internal plumbing where the real type is re-established on the way out. At a data boundary it is a smell: unknown forces a guard.

It switches off widening: every property becomes readonly, each literal keeps its literal type instead of widening to string or number, and an array becomes a readonly tuple. That is what lets you derive a union with typeof COLORS[number].

TypeScript compares types by structure, so type UserId = string is simply string: an OrderId, or any raw string, is accepted where a UserId belongs. A brand intersects the base type with a phantom marker that no plain string carries.

Intersect the base type with a phantom field keyed by a unique symbol, so no plain string is assignable to it. Expose one factory that validates the raw value and asserts it into the branded type. The brand is type-only, so the emitted JavaScript is unchanged.

Arrays are covariant, so a Dog[] is accepted where an Animal[] is wanted and a Cat can then be pushed into it. Method parameters stay bivariant even under strictFunctionTypes, and as and any switch checking off outright.

satisfies, added in TypeScript 4.9, checks the expression against a type while keeping the type inferred from the literal. An annotation checks and then widens, losing the exact keys and values; as keeps the type but checks nothing.

Because overloads are types, and types are erased: the emitted JavaScript holds one function. The overload list only describes call signatures to the checker; the single implementation must accept every case and dispatch by hand inside that body.

Follow the any upstream. res.json() is declared to return any, so data and everything derived from it are any too, and the checker stops flagging typos and wrong arguments. noImplicitAny never fires — this any is explicit.

You do not get it from the type system; you re-create it as values. Keep a discriminant field on the data, use a class whose constructor survives for instanceof, or run a schema validator that checks at runtime and infers the static type.

Use satisfies where you want both the check and the precise inferred type — config maps, route tables, as const data you index into. Keep a plain annotation on a public API surface, where the declared type is the contract and widening is the point, not a loss.