Errors

The same non-mergeable type name was declared twice in one scope.

The compiler looked for this name in every scope it can see and found nothing. Usually a typo, an unimported type, or a value being used where a type belongs.

An interface tried to inherit from a union whose members are not all known at once.

A generic alias was used without supplying the type parameter it requires.

Type arguments were supplied to an alias that declares no type parameters.

The most common error TypeScript has. A value of one type was put where another was required, and the two are not compatible in that direction.

You reached for a property the type does not have. Often the type is right and the spelling is wrong; sometimes the type is narrower than the value really is.

A type argument was rejected at the door. The generic said what it would accept, and this is not it.

The same assignability failure as TS2322, at a call site. A separate code because the fix is almost always in a different place.

Parentheses are being used as a function call, but the expression has no call signature.

The value after `new` has no construct signature, so it cannot create an instance.

A type assertion jumps between unrelated types and would not perform the runtime conversion its spelling suggests.

The signature promises something comes back and the body never delivers it.

The two sides can never be equal, so the comparison is always false and the compiler assumes you did not mean to write it.

Two function bodies share one name in the same scope; overloads may have many signatures but only one implementation.

The member exists, which is why this is not TS2420 — but its type is not compatible with the one the base declared.

The class said `implements` and then did not. The detail underneath names exactly what is missing or mismatched.

The alias is defined in terms of itself with nothing in between, so there is no point at which it means anything.

A tuple knows exactly how long it is, so indexing past the end is a compile-time error rather than an `undefined` you find out about later.

A property is read directly from an expression whose result may be `undefined`.

You indexed a type parameter with another type parameter, and the compiler has no reason to believe the key exists.

The property is marked `readonly`, which is a compile-time promise not to reassign it — and nothing more than that.

The object accepts any string key, and every one of them is read-only. This is TS2540 applied to a whole family of keys at once.

The selected call signature requires more arguments than this call supplies.

The class declares a property that is never given a value, so every instance would start out with `undefined` in a slot the type says is always a number.

You told the compiler the next line would fail, and it did not. That is good news reported as an error, and it is exactly what the directive is for.

A recursive type went further than the compiler is willing to follow — usually around fifty levels, and almost always because the recursion is counting rather than shrinking.

A type alias was referenced in value space, but aliases are erased from the emitted JavaScript.

The target type requires several members, and the supplied object has none of them.

The object is the right shape as far as it goes — it just does not go far enough. Every property the target requires must be present.

A runtime variable was written in type space; use `typeof` to ask for the type of that value.

The function has several signatures and the arguments fit none of them. The compiler then reports every attempt, which is why this error is so long.

Strict mode found a function parameter with no annotation and no surrounding context from which to infer one.

Arrays describe numeric positions; a string key such as `first` is not one of those positions.

A recursive function asks inference to know its return type before that same return type has been established.

A destructuring pattern names a field, but the object containing that field has no known type.

You indexed an object with a plain `string`, and the compiler cannot tell which property you meant — so the result would be `any`, and `strict` will not allow that quietly.

`unknown` is the type that refuses to be used until you prove what it is. That refusal is the entire feature.

A nullable value is used as though the `null` branch had already been ruled out.

An optional property was used without checking it. Under `strictNullChecks`, "optional" means the absence is part of the type and has to be handled.