Interfaces & Type Aliases

That type describes any function taking one number argument and returning a Promise of User. Parameter names inside a function type are labels for readers only — matching is positional, so an implementation may name the parameter anything.

A type alias can name any type — unions, tuples, primitives and types derived from other types — while an interface declares an object type only. Reach for an alias whenever the type is not a plain object shape.

A class declaration creates two separate things: a type named Person that describes instances, and a value named Person that is the constructor. A parameter receiving the class itself must be typed typeof Person, or new (name: string) => Person.

Two interface declarations sharing a name in the same scope merge into one type carrying both sets of members. Repeating a type alias name is a duplicate-identifier error instead: interfaces are open, aliases are closed.

Declare an index signature: interface UserNames { [id: string]: string }. Any string key may then be read or written and is typed string, but the type guarantees that no particular key actually exists.

Marking a property with ? makes it optional: an object may omit the key, and reading it yields string | undefined under strictNullChecks. The modifier is compile-time only and changes nothing in the emitted JavaScript.

It compiles. Assignability requires the source to have at least the members the target declares; it never requires the source to have only those members, so the extra retries property is ignored. This allowance is called width subtyping.

A type alias names a type, it does not create one: both aliases are exactly string, and TypeScript compares types by structure. Branding intersects one with a phantom property, string & { __brand: 'UserId' }, that a plain string does not have.

It is a construct signature: it describes a value you invoke with new, taking a string and producing a Person. Classes and class expressions with a matching constructor are assignable; plain functions and arrow functions are not.

TypeScript applies an extra excess-property check to fresh object literals assigned straight to a typed target. Storing the literal in a variable first widens it and drops that freshness, leaving only ordinary structural assignability, which happily permits extra properties.

extends overrides the inherited member and errors right at the declaration when the new type is not assignable to the old one. An intersection instead combines both types, so id becomes string & number, which reduces to never — a failure you only meet at the use site.

TypeScript reads an overload list top-down and commits to the first signature the arguments satisfy — not the most specific one. A broader signature listed above a narrower one therefore shadows it, and the narrower form's return type is never seen.

The index signature promises that every string key holds a string, and retries is a string key holding a number, so TypeScript rejects it. Fix it by widening the signature's value type, moving the open bag into its own property, or dropping the signature.

The optional form lets the key be omitted; the union form requires the key to be present, even if its value is undefined. Both read as string | undefined, and under default settings the optional form also accepts an explicit undefined.

By default an index-signature read is typed as the value type, because the checker cannot know which keys exist and assuming presence keeps everyday code ergonomic. Enable noUncheckedIndexedAccess to make such reads yield the value type plus undefined.

It compiles to const id = 'u_1';. The type and the assertion are erased, so the value is an ordinary string primitive and id.__brand is undefined at runtime — the brand exists only during type checking.

Yes, the property is still there. TypeScript erases types and never rewrites values, so nothing strips undeclared keys. The excess-property check is a compile-time typo guard only; serialising the object sends the extra key over the wire.

An interface can extend an alias that resolves to an object type, or to an intersection of object types, as long as its members are statically known. Aliases for unions, primitives or unresolved type parameters are rejected.

The emitted JavaScript contains exactly one function — overload signatures are types and are erased. Callers may use only the overload signatures; the implementation signature is invisible to them and cannot be called on its own terms.

{} requires no members, so under strictNullChecks every value except null and undefined is assignable to it, primitives included. object excludes primitives but still accepts any non-primitive. Neither lets you read a property, so {} says almost nothing.

The first fails: a member that is optional on the source may be absent, so it cannot satisfy a required member on the target. The reverse compiles, because a required member always satisfies an optional one.

Declare the callable as a call-signature member of an object type or interface, alongside the properties. The arrow shorthand is one closed type expression with nowhere to put extra members; an intersection of a function type and an object type is the equivalent.

Use a typeof type query: writing typeof parseConfig in type position yields the type the compiler already inferred for that value, including its parameters, its return type, and any properties hung on the function.

Object-literal type aliases receive an implicit index signature; interfaces do not, because an interface can gain members from a later declaration, so the compiler will not treat its member list as final. Add an explicit index signature or use an alias.

An abstract class cannot be instantiated, so its constructor type is an abstract constructor type, which TypeScript refuses to assign to a plain new () => Shape. Type the parameter abstract new () => Shape, which accepts abstract and concrete classes alike.

Wrap the declaration in a declare global block inside a module file: it reopens the global declaration space so interface Window { ... } merges with the DOM's Window instead of creating a new module-local interface.

Write a module augmentation: in a file that is itself a module, a declare module 'pkg' block re-declares one of the package's exported interfaces, and the members merge into the original. It can only patch existing declarations.

Options is a weak type — every property is optional — so almost anything is structurally assignable to it. TypeScript adds a weak-type check: a source with properties but none in common with the target is rejected, and it applies to variables too.

TypeScript checks only that each overload signature is compatible with the implementation signature, and that check is deliberately loose. It never verifies that the body returns the type a particular overload promised, so overloads are an unchecked promise.