In TypeScript, which kinds of `type` alias can an `interface` extend in its `extends` clause, and which ones does the compiler reject?

## What the clause actually requires An interface's `extends` clause is not restricted to other interfaces. The requirement is on the *kind of type*, not the syntax that produced it: the parent must be an **object type, or an intersection of object types, with statically known members**. That phrasing is lifted straight from the compiler's own diagnostic, and every accepted and rejected case follows from it. Accepted: ```typescript interface Named { name: string } type Point = { x: number; y: number }; type Timestamps = { created: Date } & { updated: Date }; type Fixed = { [K in "a" | "b"]: number }; class Widget { render(): string { return ""; } } interface P1 extends Named { id: string } // an interface interface P2 extends Point { z: number } // an object-type alias interface P3 extends Timestamps { id: string } // an intersection of object types interface P4 extends Fixed { c: number } // a mapped type with fixed keys interface P5 extends Widget { label: string } // a class's instance type interface P6 extends Named, Point { id: string } // several parents at once ``` Rejected: ```typescript type Shape = { kind: "circle" } | { kind: "square" }; type Id = string; // interface Tagged extends Shape { id: string } // Error: An interface can only extend an object type or // intersection of object types with statically known members. // interface Wrapper extends Id { } // same error: a primitive is not an object type ``` ## Why unions are refused Declaring `interface B extends A` obliges the compiler to do two things at the declaration site: build B's member list by adding B's own members to A's, and check that B is assignable to A. A union has no single member list — `Shape` above is *either* a circle or a square, and the properties available depend on which. There is no well-defined "inherit its members" operation, so the clause is refused rather than given a surprising meaning. "Statically known members" also excludes a mapped type over an unresolved type parameter, because until the parameter is instantiated the key set is unknown: ```typescript type Copy<T> = { [K in keyof T]: T[K] }; // interface Bad<T> extends Copy<T> { } // members are not statically known ``` A mapped type over a fixed key union, like `Fixed` above, is fine — its keys are decided the moment the alias is written. ## The intersection escape hatch This is the clearest case where the two composition forms are genuinely *not* interchangeable, and it is why the question gets asked. `&` is an operator, not a check, so it has no member-list requirement: ```typescript type Shape = { kind: "circle"; r: number } | { kind: "square"; side: number }; type Identified = Shape & { id: string }; const c: Identified = { kind: "circle", r: 2, id: "a" }; // OK const s: Identified = { kind: "square", side: 2, id: "b" }; // OK ``` `Identified` still narrows on `kind` the way the original union did, with `id` available on both branches. If you had reached for an interface here you would have been stuck. ## Extending a class `interface I extends SomeClass` refers to the class's **instance type** — its properties and method signatures, with no implementations, and without the constructor or any static members. This is legal and occasionally useful, but note it also drags in the class's `private` and `protected` members, which restricts who can implement the interface. ## What this is not about None of this concerns which of `interface` or `type` you should reach for stylistically, and none of it survives to runtime: whichever form you pick, the emitted JavaScript contains no trace of it. The only thing at stake is whether the compiler will accept the declaration and what member list it computes. ## Quick checklist - Object-type alias, intersection of object types, interface, class instance type, fixed-key mapped type: `extends` works. - Union alias, primitive alias, unresolved generic mapped type: `extends` is refused; use `&` in an alias instead. - Multiple parents are allowed, but a property inherited from two of them must be identical in both unless you redeclare it.