Errors

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.

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.

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.

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.

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 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.

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.

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.

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.

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