Interfaces & Type Aliases

readonly stops the checker from accepting an assignment to that property through that type. It is shallow, so the object the property points at stays fully mutable, and it is erased at compile time, so nothing is protected at runtime.

An object type is a lower bound: it requires at least the declared members and never forbids others. Callers legitimately pass wider objects, and since types are erased, the extra fields are still there when JSON.stringify walks the value at runtime.

Confine the assertion to one exported factory that checks the value first and returns the branded type or a failure, and export the type without any other way to mint it. The brand still guarantees nothing at runtime: it records that a value passed through that factory, nothing about the value itself.

Function says only that a value is callable: any argument list type-checks and every call produces any. Replace it with an explicit call signature giving parameter and return types, or with a constraint such as (...args: never[]) => unknown where the function is never actually called.

An arrow function satisfies the call signature but has no level property, so the initializer is missing a member. Build the value with Object.assign, whose result type is the callable intersected with the properties, or assign properties onto a function declaration so the compiler folds them into its type.

Consumers can add members to an exported interface from their own code by redeclaring it in a module augmentation; an exported type alias is closed and a second declaration is an error. That extensibility is a public commitment you cannot easily withdraw.

An implements clause checks only the instance side, so static members and construct signatures written in the interface are never enforced on the class. Declare a separate static-side interface and check the class value against it, with an annotated const or a satisfies expression.

Method-syntax members of the same name become an overload set when interfaces merge. Ordinary properties, including function-typed ones, must be unique or declared with an identical type — otherwise the compiler reports that subsequent property declarations must have the same type.

as removes the literal's freshness, so it silences every excess-property complaint in that literal, not just the intended one — future typos included. The honest fixes change the type: declare the extra property, or widen the contract. satisfies checks without widening but still rejects undeclared keys.

For property members, no: each member's type is the intersection of both contributions, and that is commutative, so the two orderings are mutually assignable. Order does matter for call and construct signatures, which are concatenated in operand order and resolved first-match-wins.

Overload resolution commits to one signature, and neither accepts a union, so a string | number argument matches nothing and the compiler reports no matching overload. Fix it by narrowing at the call site, or drop overloads for a single union-parameter signature.

With exactOptionalPropertyTypes on, a property marked ? means only "the key may be missing" — writing the key with the value undefined becomes an error. To allow that, declare the type explicitly as name?: string | undefined.

Assignability ignores readonly on object properties, so the value can be assigned to an alias typed without it and written through that alias. The modifier is also shallow and erased, so nested data, assertions, and untyped callers bypass it entirely.

An open dictionary never goes stale but gives up autocomplete, typo detection and any presence guarantee; a closed object type restores all three but becomes a false claim the moment the service ships a flag it does not list. The usual answer is both, separated by a validating boundary.

Private and protected members are matched by declaration, not by name and type. Each class declares its own value, so the two never match and the classes compare nominally instead of structurally — the one place TypeScript is nominal by default.

The namespace merges with the other declaration, so one name serves as both a type and a container of values — a companion for an interface, or static members hung on a class, function or enum. The namespace must come after the declaration it merges with.

The interface inherits the class's instance-side members — property and method types, without any implementations, and without the constructor or statics. It also inherits private and protected members, and because those are nominal, only the class itself or a subclass can implement the interface.

When a type declares both index signatures, the numeric signature's value type must be assignable to the string signature's, because a numeric key is reachable as a string key too. Here string | number does not fit string, so it is rejected.

A unique symbol key cannot be written by code that does not have the symbol, so brands cannot be forged or matched by accident, and it cannot collide with a real data property. Give each brand its own symbol and several brands can compose on one value.

Set a default rather than a mandate: interface for declared object shapes, type alias for everything else, with language-forced exceptions for unions, tuples, primitives and derived types. Apply it to new code only, and reserve real review attention for published, extensible surfaces.

Augmentation is program-wide, unconditional and unenforced: every file sees the field whether or not it imports yours, two packages adding the same name collide hard, and the type promises something no runtime code checks. Prefer a local type unless third-party code must see the change.