Errors

A default value already makes a parameter optional, so the question mark is not merely redundant — it contradicts the guarantee the default is there to give.

break and continue steer the loop they are written in. A callback is a different function, and that loop is not its to steer.

The parser reached a position where only a value may appear and found something that cannot start one — usually a line left half-written.

A conditional type must say what happens when the check fails. There is no optional else at the type level, because every type has to resolve to something.

JavaScript lets anything be thrown, so the compiler cannot promise that what lands in a catch clause is an Error. unknown is the only honest annotation.

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.

With allowJs on, a .js file is both an input and the name of an output. If the output goes where the input lives, the compiler would overwrite the file it just read.

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.