Errores

El mismo nombre de tipo no fusionable se declaró dos veces en un ámbito.

El compilador buscó este nombre en todos los ámbitos que ve y no encontró nada. Suele ser una errata, un tipo sin importar, o un valor usado donde corresponde un tipo.

Una interfaz intentó heredar de una unión cuyos miembros no se conocen todos a la vez.

Se usó un alias genérico sin proporcionar el parámetro de tipo que requiere.

Se proporcionaron argumentos a un alias que no declara parámetros de tipo.

El error más común de TypeScript. Un valor de un tipo se puso donde se requería otro, y ambos no son compatibles en esa dirección.

Buscaste una propiedad que el tipo no tiene. A menudo el tipo es correcto y la ortografía no; a veces el tipo es más estrecho que el valor real.

Un argumento de tipo fue rechazado en la puerta. El genérico dijo qué aceptaría, y esto no lo es.

El mismo fallo de asignabilidad que TS2322, pero en una llamada. Un código aparte porque el arreglo casi siempre está en otro sitio.

Se usan paréntesis como llamada a función, pero la expresión no tiene firma de llamada.

El valor después de `new` no tiene firma de constructor, así que no puede crear una instancia.

Una aserción salta entre tipos no relacionados y no realizará la conversión en tiempo de ejecución que su escritura sugiere.

La firma promete que algo vuelve y el cuerpo nunca lo entrega.

Los dos lados nunca pueden ser iguales, así que la comparación siempre es falsa y el compilador asume que no querías escribirla.

Dos cuerpos de función comparten nombre en el mismo ámbito; las sobrecargas pueden tener muchas firmas, pero una sola implementación.

El miembro existe, por eso no es TS2420 — pero su tipo no es compatible con el que declaró la base.

La clase dijo `implements` y luego no lo hizo. El detalle de debajo nombra exactamente qué falta o qué no encaja.

El alias se define en términos de sí mismo sin nada en medio, así que no hay punto alguno en el que signifique algo.

Una tupla sabe exactamente cuánto mide, así que indexar más allá del final es un error de compilación y no un `undefined` que descubres después.

Se lee una propiedad directamente de una expresión cuyo resultado puede ser `undefined`.

Indexaste un parámetro de tipo con otro parámetro de tipo, y el compilador no tiene motivos para creer que la clave exista.

La propiedad está marcada como `readonly`, que es una promesa en tiempo de compilación de no reasignarla — y nada más.

El objeto acepta cualquier clave de cadena, y todas ellas son de solo lectura. Es TS2540 aplicado a toda una familia de claves a la vez.

La firma de llamada seleccionada requiere más argumentos de los que proporciona esta llamada.

La clase declara una propiedad a la que nunca se le da un valor, así que cada instancia empezaría con `undefined` en un hueco que el tipo dice que siempre es un número.

Le dijiste al compilador que la línea siguiente fallaría, y no falló. Son buenas noticias informadas como error, y es exactamente para lo que sirve la directiva.

Un tipo recursivo fue más lejos de lo que el compilador está dispuesto a seguir — normalmente unos cincuenta niveles, y casi siempre porque la recursión cuenta en vez de encogerse.

Se hizo referencia a un alias en el espacio de valores, pero los alias se borran del JavaScript emitido.

El tipo de destino requiere varios miembros y el objeto proporcionado no tiene ninguno.

El objeto tiene la forma correcta hasta donde llega — simplemente no llega lo bastante lejos. Toda propiedad que el destino exige debe estar presente.

Se escribió una variable de ejecución en el espacio de tipos; usa `typeof` para obtener el tipo de ese valor.

La función tiene varias firmas y los argumentos no encajan en ninguna. El compilador informa entonces de cada intento, y por eso este error es tan largo.

El modo estricto encontró un parámetro sin anotación ni contexto del que inferir su tipo.

Los arrays describen posiciones numéricas; una clave de texto como `first` no es una de ellas.

Una función recursiva pide a la inferencia conocer su tipo de retorno antes de que ese mismo tipo se haya establecido.

Un patrón de desestructuración nombra un campo, pero el objeto que lo contiene no tiene un tipo conocido.

Indexaste un objeto con un `string` a secas, y el compilador no puede saber a qué propiedad te referías — el resultado sería `any`, y `strict` no lo deja pasar en silencio.

`unknown` es el tipo que se niega a ser usado hasta que demuestres qué es. Esa negativa es toda la característica.

Se usa un valor anulable como si la rama `null` ya hubiera sido descartada.

Se usó una propiedad opcional sin comprobarla. Bajo `strictNullChecks`, «opcional» significa que la ausencia forma parte del tipo y hay que gestionarla.