@zzzen/pyright-internal 1.2.0-dev.20230709 → 1.2.0-dev.20230723

package/dist/localization/package.nls.es.json

@@ -1 +1,719 @@
-{}
+{
+    "CodeAction": {
+        "addOptionalToAnnotation": "Agregar \"Optional\" a la anotación de tipo",
+        "createTypeStub": "Crear Tipo Stub",
+        "createTypeStubFor": "Crear Tipo Stub Para \"{moduleName}\"",
+        "executingCommand": "Ejecutando el comando",
+        "filesToAnalyzeCount": "{count} archivos para analizar",
+        "filesToAnalyzeOne": "1 archivo para analizar",
+        "findingReferences": "Buscando referencias",
+        "organizeImports": "Organizar Importaciones",
+        "renameShadowedFile": "Cambie el nombre de \"{oldFile}\" a \"{newFile}\""
+    },
+    "Diagnostic": {
+        "abstractMethodInvocation": "El método \"{method}\" no puede ser llamado porque es abstracto",
+        "annotatedParamCountMismatch": "El recuento de anotaciones del parámetro no coincide: se esperaba {expected}, pero se recibió {received}",
+        "annotatedTypeArgMissing": "Se espera un argumento de tipo y una o más anotaciones para \"Anotado\".",
+        "annotationFormatString": "Las anotaciones de tipo no pueden utilizar literales de cadena de formato (cadenas f)",
+        "annotationNotSupported": "No se admite la anotación de tipo para esta declaración",
+        "annotationSpansStrings": "Las anotaciones de tipo no pueden abarcar varios literales de cadena",
+        "annotationStringEscape": "Las anotaciones de tipo no pueden contener caracteres de escape",
+        "argAssignment": "Argumento de tipo \"{argType}\" no puede ser asignado a parámetro de tipo \"{paramType}\"",
+        "argAssignmentFunction": "El argumento de tipo \"{argType}\" no puede ser asignado a parámetro de tipo \"{paramType}\" en función \"{functionName}\"",
+        "argAssignmentParam": "Argumento de tipo \"{argType}\" no puede ser asignado a parámetro \"{paramName}\" de tipo \"{paramType}\"",
+        "argAssignmentParamFunction": "Argumento de tipo \"{argType}\" no puede ser asignado a parámetro \"{paramName}\" de tipo \"{paramType}\" en función \"{functionName}\"",
+        "argMissingForParam": "Falta el argumento para el parámetro {name}",
+        "argMissingForParams": "Faltan argumentos para los parámetros {names}",
+        "argMorePositionalExpectedCount": "Más argumentos posicionales {expected} esperados",
+        "argMorePositionalExpectedOne": "Se espera 1 argumento posicional más",
+        "argPositional": "Argumento posicional esperado",
+        "argPositionalExpectedCount": "Argumentos posicionales esperados {expected}",
+        "argPositionalExpectedOne": "Se espera 1 argumento posicional",
+        "argTypePartiallyUnknown": "El tipo de argumento es parcialmente desconocido",
+        "argTypeUnknown": "Tipo de argumento desconocido",
+        "assertAlwaysTrue": "La expresión Assert siempre se evalúa como verdadero",
+        "assertTypeArgs": "\"assert_type\" espera dos argumentos posicionales",
+        "assertTypeTypeMismatch": "Error de coincidencia \"assert_type\": se esperaba \"{expected}\" pero se ha recibido \"{received}\"",
+        "assignmentExprComprehension": "El destino de la expresión de asignación \"{name}\" no puede usar el mismo nombre que la comprensión para el destino",
+        "assignmentExprContext": "La expresión de asignación debe estar dentro de un módulo, función o lambda",
+        "assignmentExprInSubscript": "Las expresiones de asignación dentro de un subíndice solo se admiten en Python 3.10 y versiones posteriores.",
+        "assignmentInProtocol": "Las variables de instancia o clase dentro de una clase Protocol deben declararse explícitamente en el cuerpo de la clase.",
+        "assignmentTargetExpr": "La expresión no puede ser objetivo de asignación",
+        "asyncNotInAsyncFunction": "No se permite el uso de \"async\" fuera de la función asincrónica",
+        "awaitIllegal": "El uso de \"await\" requiere Python 3.5 o posterior.",
+        "awaitNotInAsync": "\"await\" solo se permite dentro de una función async",
+        "backticksIllegal": "En Python 3.x no se admiten expresiones rodeadas de puntos suspensivos; utilice repr en su lugar.",
+        "baseClassCircular": "La clase no se puede derivar de sí misma",
+        "baseClassFinal": "La clase base \"{type}\" está marcada como final y no puede ser subclasificada",
+        "baseClassInvalid": "El argumento de la clase debe ser una clase base",
+        "baseClassMethodTypeIncompatible": "Las clases base para la clase \"{classType}\" definen el método \"{name}\" de forma incompatible",
+        "baseClassUnknown": "Se desconoce el tipo de la clase base, lo que oculta el tipo de la clase derivada.",
+        "baseClassVariableTypeIncompatible": "Las clases base para la clase \"{classType}\" definen la variable \"{name}\" de forma incompatible",
+        "bindTypeMismatch": "No se pudo enlazar el método \"{methodName}\" porque \"{type}\" no se puede asignar al parámetro \"{paramName}\"",
+        "breakOutsideLoop": "\"break\" solo se puede usar dentro de un bucle",
+        "callableExtraArgs": "Se esperaban solo dos argumentos de tipo para \"Exigible\".",
+        "callableFirstArg": "Lista de tipos de parámetros esperados o \"...\"",
+        "callableNotInstantiable": "No se puede instanciar el tipo \"{type}\"",
+        "callableSecondArg": "Tipo de retorno esperado como segundo argumento de tipo para \"Exigible\"",
+        "casePatternIsIrrefutable": "El patrón irrefutable solo se permite para la última instrucción case",
+        "classAlreadySpecialized": "El tipo \"{type}\" ya está especializado",
+        "classDecoratorTypeUnknown": "El decorador de clase sin tipo oculta el tipo de clase; omitiendo el elemento Decorator",
+        "classDefinitionCycle": "La definición de clase para \"{name}\" depende de sí misma.",
+        "classGetItemClsParam": "__class_getitem__ debe tomar un parámetro \"cls\"",
+        "classMethodClsParam": "Los métodos de clase deben tomar un parámetro \"cls\"",
+        "classNotRuntimeSubscriptable": "El subíndice para la clase \"{name}\" generará una excepción en tiempo de ejecución; encierre la anotación de tipo entre comillas",
+        "classPatternBuiltInArgCount": "El patrón de clase acepta como máximo 1 subpatrón posicional",
+        "classPatternBuiltInArgPositional": "El patrón de clase solo acepta subpatrones posicionales",
+        "classPatternTypeAlias": "\"{type}\" no se puede usar en un patrón de clase porque es un alias de tipo especializado",
+        "classTypeParametersIllegal": "La sintaxis de los parámetros de tipo de clase requiere Python 3.12 o posterior.",
+        "classVarFirstArgMissing": "Se esperaba un argumento de tipo después de \"ClassVar\"",
+        "classVarNotAllowed": "\"ClassVar\" no está permitido en este contexto",
+        "classVarOverridesInstanceVar": "La variable de clase \"{name}\" anula la variable de instancia del mismo nombre en la clase \"{className}\"",
+        "classVarTooManyArgs": "Solo se esperaba un argumento de tipo después de \"ClassVar\"",
+        "classVarWithTypeVar": "El tipo \"ClassVar\" no puede incluir variables de tipo",
+        "clsSelfParamTypeMismatch": "El tipo de parámetro \"{name}\" debe ser un supertipo de su clase \"{classType}\"",
+        "codeTooComplexToAnalyze": "El código es demasiado complejo para analizarlo; reduzca la complejidad refactorizándolo en subrutinas o reduciendo las rutas de código condicional.",
+        "collectionAliasInstantiation": "No se puede crear una instancia del tipo \"{type}\"; use \"{alias}\" en su lugar.",
+        "comparisonAlwaysFalse": "La condición siempre se evaluará como Falso, ya que los tipos \"{leftType}\" y \"{rightType}\" no se superponen.",
+        "comparisonAlwaysTrue": "La condición siempre se evaluará como Verdadero, ya que los tipos \"{leftType}\" y \"{rightType}\" no se superpone.",
+        "comprehensionInDict": "La comprensión no puede utilizarse con otras entradas del diccionario",
+        "comprehensionInSet": "La comprensión no se puede usar con otras entradas de conjunto",
+        "concatenateParamSpecMissing": "El último argumento de tipo para \"Concatenatar\" debe ser un ParamSpec",
+        "concatenateTypeArgsMissing": "\"Concatenar\" requiere al menos dos argumentos de tipo",
+        "conditionalOperandInvalid": "Operando condicional no válido de tipo \"{type}\"",
+        "constantRedefinition": "\"{name}\" es constante (porque está en mayúsculas) y no se puede volver a definir",
+        "constructorNoArgs": "No se esperaban argumentos para el constructor \"{type}\"",
+        "constructorParametersMismatch": "Error de coincidencia entre la firma de __new__ y __init__ en la clase \"{classType}\"",
+        "containmentAlwaysFalse": "La expresión siempre se evaluará como False, ya que los tipos \"{leftType}\" y \"{rightType}\" no tienen superposición",
+        "containmentAlwaysTrue": "La expresión siempre se evaluará como True, ya que los tipos \"{leftType}\" y \"{rightType}\" no tienen superposición",
+        "continueInFinally": "\"continue\" no puede utilizarse dentro de una cláusula finally",
+        "continueOutsideLoop": "\"continue\" solo puede utilizarse dentro de un bucle",
+        "dataClassBaseClassFrozen": "Una clase no inmovilizada no puede heredar de una clase inmovilizada",
+        "dataClassBaseClassNotFrozen": "Una clase congelada no puede heredar de una clase que no esté congelada",
+        "dataClassConverterFunction": "Argumento de tipo \"{argType}\" no es un convertidor válido para el campo \"{fieldName}\" de tipo \"{fieldType}\"",
+        "dataClassConverterOverloads": "No hay sobrecargas de \"{funcName}\" que sean convertidores válidos para el campo \"{fieldName}\" de tipo \"{fieldType}\"",
+        "dataClassFieldWithDefault": "Los campos sin valores predeterminados no pueden aparecer después de los campos con valores predeterminados",
+        "dataClassFieldWithPrivateName": "El campo Dataclass no puede utilizar un nombre privado",
+        "dataClassFieldWithoutAnnotation": "El campo Dataclass sin anotación de tipo provocará una excepción en tiempo de ejecución",
+        "dataClassPostInitParamCount": "Dataclass __post_init__ recuento de parámetros incorrecto; el número de campos InitVar es {esperado}.",
+        "dataClassPostInitType": "El tipo de parámetro del método __post_init__ de la clase de datos no coincide con el del campo \"{fieldName}\".",
+        "dataClassSlotsOverwrite": "__slots__ ya está definido en la clase",
+        "dataClassTransformExpectedBoolLiteral": "Expresión esperada que se evalúa estáticamente como True o False",
+        "dataClassTransformFieldSpecifier": "Se esperaba una tupla de clases o funciones, pero se recibió el tipo \"{type}\"",
+        "dataClassTransformPositionalParam": "Todos los argumentos de \"dataclass_transform\" deben ser argumentos de palabra clave",
+        "dataClassTransformUnknownArgument": "El argumento \"{name}\" no es compatible con dataclass_transform",
+        "declaredReturnTypePartiallyUnknown": "El tipo de retorno declarado, \"{returnType}\", es parcialmente desconocido",
+        "declaredReturnTypeUnknown": "El tipo de retorno declarado es desconocido",
+        "defaultValueContainsCall": "No se permiten llamadas de función y objetos mutables dentro de la expresión de valor predeterminado del parámetro",
+        "defaultValueNotAllowed": "Los parámetros con \"*\" o \"**\" no pueden tener valor por defecto",
+        "delTargetExpr": "No se puede eliminar la expresión",
+        "deprecatedClass": "La clase \"{name}\" está en desuso",
+        "deprecatedConstructor": "El constructor de la clase \"{name}\" está obsoleto",
+        "deprecatedFunction": "Esta función \"{name}\" está obsoleta",
+        "deprecatedType": "Este tipo está obsoleto a partir de la {version} de Python; utilice en su lugar \"{replacement}\".",
+        "dictExpandIllegalInComprehension": "No se permite la ampliación del diccionario en la comprensión",
+        "dictInAnnotation": "Expresión de diccionario no permitida en anotación de tipo",
+        "dictKeyValuePairs": "Las entradas del diccionario deben contener pares clave/valor",
+        "dictUnpackIsNotMapping": "Asignación esperada para el operador de desempaquetado del diccionario",
+        "dunderAllSymbolNotPresent": "\"{name}\" se especifica en __all__ pero no está presente en el módulo",
+        "duplicateArgsParam": "Solo se permite un parámetro \"*\".",
+        "duplicateBaseClass": "Clase base duplicada no permitida",
+        "duplicateCapturePatternTarget": "El destino de captura \"{name}\" no puede aparecer más de una vez dentro del mismo patrón",
+        "duplicateCatchAll": "Solo se permite una cláusula de excepción",
+        "duplicateEnumMember": "El miembro Enum \"{name}\" ya está declarado",
+        "duplicateGenericAndProtocolBase": "Solo se permite una clase base Genérica[...] o Protocolar[...].",
+        "duplicateImport": "\"{importName}\" se importa más de una vez",
+        "duplicateKeywordOnly": "Solo se permite un separador \"*\".",
+        "duplicateKwargsParam": "Solo se permite un parámetro \"**\".",
+        "duplicateParam": "Parámetro duplicado \"{name}\"",
+        "duplicatePositionOnly": "Solo se permite un parámetro \"/\"",
+        "duplicateStarPattern": "Solo se permite un patrón \"*\" en una secuencia de patrones",
+        "duplicateStarStarPattern": "Solo se permite una entrada \"**\"",
+        "duplicateUnpack": "Solo se permite una operación de desempaquetado en la lista",
+        "ellipsisContext": "\"...\" no está permitido en este contexto",
+        "ellipsisSecondArg": "\"...\" permitido sólo como el segundo de dos argumentos",
+        "enumClassOverride": "La clase Enum \"{name}\" es final y no puede ser subclasificada",
+        "exceptionGroupIncompatible": "La sintaxis de grupo de excepciones (\"except*\") requiere Python 3.11 o posterior.",
+        "exceptionTypeIncorrect": "\"{type}\" no se deriva de BaseException",
+        "exceptionTypeNotClass": "\"{type}\" no es una clase de excepción válida",
+        "exceptionTypeNotInstantiable": "El constructor para el tipo de excepción \"{type}\" requiere uno o más argumentos",
+        "expectedAfterDecorator": "Se esperaba una declaración de función o clase después del decorador",
+        "expectedArrow": "Se esperaba \"->\" seguido de una anotación de tipo de retorno",
+        "expectedAsAfterException": "Se esperaba \"as\" después del tipo de excepción",
+        "expectedAssignRightHandExpr": "Expresión esperada a la derecha de \"=\"",
+        "expectedBinaryRightHandExpr": "Expresión esperada a la derecha del operador",
+        "expectedBoolLiteral": "Se esperaba True o False",
+        "expectedCase": "Declaración \"case\" esperada",
+        "expectedClassName": "Nombre de clase esperado",
+        "expectedCloseBrace": "\"{\" no estaba cerrado",
+        "expectedCloseBracket": "\"[\" no estaba cerrado",
+        "expectedCloseParen": "\"(\" no estaba cerrado",
+        "expectedColon": "Se esperaba \":\"",
+        "expectedComplexNumberLiteral": "Número complejo literal esperado para la concordancia de patrones",
+        "expectedDecoratorExpr": "Forma de expresión no compatible con Decorator anterior a Python 3.9",
+        "expectedDecoratorName": "Nombre esperado del Decorator",
+        "expectedDecoratorNewline": "Nueva línea esperada al final de Decorator",
+        "expectedDelExpr": "Expresión esperada después de \"del\"",
+        "expectedElse": "Se espera \"else\"",
+        "expectedEquals": "Se esperaba \"=\"",
+        "expectedExceptionClass": "Clase o objeto de excepción no válido",
+        "expectedExceptionObj": "Objeto de excepción esperado, clase de excepción o Ninguno",
+        "expectedExpr": "Se esperaba una expresión",
+        "expectedFunctionAfterAsync": "Definición de función esperada después de \"async\"",
+        "expectedFunctionName": "Se esperaba nombre de la función luego de \"def\"",
+        "expectedIdentifier": "Identificador esperado",
+        "expectedImport": "Se espera \"import\"",
+        "expectedImportAlias": "Símbolo esperado después de \"como\"",
+        "expectedImportSymbols": "Se esperan uno o más nombres de símbolos tras la importación",
+        "expectedIn": "Se esperaba \"in\"",
+        "expectedInExpr": "Expresión esperada después de \"in\"",
+        "expectedIndentedBlock": "Bloque con sangría previsto",
+        "expectedMemberName": "Nombre de miembro esperado después de \".\"",
+        "expectedModuleName": "Nombre de módulo esperado",
+        "expectedNameAfterAs": "Se esperaba un nombre de símbolo después de \"as\"",
+        "expectedNamedParameter": "El parámetro de palabra clave debe ir después de \"*\".",
+        "expectedNewline": "Nueva línea esperada",
+        "expectedNewlineOrSemicolon": "Las declaraciones deben ir separadas por nuevas líneas o punto y coma",
+        "expectedOpenParen": "Se espera \"(\"",
+        "expectedParamName": "Nombre esperado del parámetro",
+        "expectedPatternExpr": "Expresión del patrón esperado",
+        "expectedPatternSubjectExpr": "Expresión de asunto de patrón esperada",
+        "expectedPatternValue": "Expresión de valor de patrón esperada de la forma \"a.b\"",
+        "expectedReturnExpr": "Expresión esperada después de \"return\"",
+        "expectedSliceIndex": "Expresión de índice o segmento esperada",
+        "expectedTypeNotString": "Se esperaba un tipo pero se ha recibido una cadena literal",
+        "expectedTypeParameterName": "Nombre de parámetro de tipo esperado",
+        "expectedYieldExpr": "Expresión esperada en la instrucción yield",
+        "finalClassIsAbstract": "La clase \"{type}\" está marcada como final y debe implementar todos los métodos abstractos",
+        "finalContext": "\"Final\" no está permitido en este contexto",
+        "finalMethodOverride": "El método \"{name}\" no puede anular el método final definido en la clase \" {className}\"",
+        "finalReassigned": "\"{name}\" se declara como Final y no se puede reasignar",
+        "finalRedeclaration": "\"{name}\" se declaró anteriormente como Final",
+        "finalRedeclarationBySubclass": "\"{name}\" no puede ser redeclarado porque la clase padre \"{className}\" lo declara como Final",
+        "finalTooManyArgs": "Se esperaba un único argumento de tipo después de \"Final\".",
+        "finalUnassigned": "\"{name}\" se declara Final, pero no se asigna valor",
+        "formatStringBrace": "No se permite una llave de cierre única dentro del literal de cadena f; usar llave de cierre doble",
+        "formatStringBytes": "Los literales de cadena de formato (f-strings) no pueden ser binarios",
+        "formatStringDebuggingIllegal": "El especificador de depuración de cadena F \"=\" requiere Python 3.8 o posterior",
+        "formatStringEscape": "Secuencia de escape (barra diagonal inversa) no permitida en la parte de expresión de f-string anterior a Python 3.12",
+        "formatStringExpectedConversion": "Se esperaba un especificador de conversión después de \"!\" en f-string",
+        "formatStringIllegal": "Los literales de cadena de formato (f-strings) requieren Python 3.6 o posterior",
+        "formatStringInPattern": "Cadena de formato no permitida en el patrón",
+        "formatStringNestedFormatSpecifier": "Expresiones anidadas demasiado profundamente dentro del especificador de cadena de formato",
+        "formatStringNestedQuote": "Las cadenas anidadas dentro de una cadena f no pueden usar el mismo carácter de comillas que la cadena f anterior a Python 3.12",
+        "formatStringUnicode": "Los literales de cadena de formato (cadenas f) no pueden ser unicode",
+        "formatStringUnterminated": "Expresión sin terminar en f-string; se esperaba \"}\"",
+        "functionDecoratorTypeUnknown": "Un decorator de función no tipificado oculta el tipo de función; ignorar el decorator",
+        "functionInConditionalExpression": "La expresión condicional hace referencia a una función que siempre se evalúa como Verdadero",
+        "functionTypeParametersIllegal": "La sintaxis del parámetro de tipo de función requiere Python 3.12 o posterior",
+        "futureImportLocationNotAllowed": "Las importaciones desde __future__ deben estar al principio del fichero",
+        "generatorAsyncReturnType": "El tipo de retorno de la función generadora asíncrona debe ser compatible con \"AsyncGenerator[{yieldType}, Any]\"",
+        "generatorNotParenthesized": "Las expresiones del generador deben ir entre paréntesis si no son el único argumento",
+        "generatorSyncReturnType": "El tipo de retorno de la función generadora debe ser compatible con \"Generator[{yieldType}, Any, Any]\"",
+        "genericBaseClassNotAllowed": "La clase base \"Generic\" no se puede usar con la sintaxis de parámetro de tipo",
+        "genericClassAssigned": "No se puede asignar un tipo de clase genérico",
+        "genericClassDeleted": "No se puede eliminar el tipo de clase genérica",
+        "genericNotAllowed": "\"Generic\" no es válido en este contexto",
+        "genericTypeAliasBoundTypeVar": "Los alias de tipo genérico dentro de una clase no pueden utilizar variables de tipo vinculadas {names}.",
+        "genericTypeArgMissing": "\"Generic\" requiere al menos un argumento de tipo",
+        "genericTypeArgTypeVar": "El argumento de tipo para \"Generic\" debe ser una variable de tipo",
+        "genericTypeArgUnique": "Los argumentos de tipo para \"Generic\" deben ser únicos",
+        "globalReassignment": "\"{name}\" se asigna antes de la declaración global",
+        "globalRedefinition": "\"{name}\" ya ha sido declarado global",
+        "implicitStringConcat": "No se permite la concatenación implícita de cadenas",
+        "importCycleDetected": "Ciclo detectado en la cadena de importación",
+        "importDepthExceeded": "La profundidad de la cadena de importación superó {depth}",
+        "importResolveFailure": "No se ha podido resolver la importación \"{importName}\".",
+        "importSourceResolveFailure": "La importación \"{importName}\" no se ha podido resolver desde el origen",
+        "importSymbolUnknown": "\"{name}\" es un símbolo de importación desconocido",
+        "incompatibleMethodOverride": "El método \"{name}\" sobrescribe la clase \"{className}\" de forma incompatible",
+        "inconsistentIndent": "La cantidad sin sangría no coincide con la sangría anterior",
+        "inconsistentTabs": "Uso incoherente de tabuladores y espacios en la sangría",
+        "initMustReturnNone": "El tipo de retorno de \"__init__\" debe ser None",
+        "initSubclassClsParam": "__init_subclass__ debe tomar un parámetro \"cls\"",
+        "instanceMethodSelfParam": "Los métodos de instancia deben tomar un parámetro \"auto\"",
+        "instanceVarOverridesClassVar": "La variable de instancia \"{name}\" invalida la variable de clase del mismo nombre en la clase \"{className}\"",
+        "instantiateAbstract": "No se puede instanciar la clase abstracta \"{tipo}\"",
+        "instantiateProtocol": "No se puede crear una instancia de la clase de protocolo \"{type}\"",
+        "internalBindError": "Se ha producido un error interno al vincular el archivo \"{file}\": {message}",
+        "internalParseError": "Se ha producido un error interno al procesar el archivo \"{file}\": {message}",
+        "internalTypeCheckingError": "Se ha producido un error interno al comprobar el tipo de archivo \"{file}\":{message}",
+        "invalidIdentifierChar": "Carácter no válido en el identificador",
+        "invalidStubStatement": "La declaración no tiene sentido dentro de un archivo de tipo stub",
+        "invalidTokenChars": "Carácter \"{text}\" no válido en el token",
+        "isInstanceInvalidType": "El segundo argumento de \"isinstance\" debe ser una clase o tupla de clases",
+        "isSubclassInvalidType": "El segundo argumento de \"issubclass\" debe ser una clase o tupla de clases",
+        "keyValueInSet": "No se permiten pares de clave/valor dentro de un conjunto",
+        "keywordArgInTypeArgument": "No se pueden usar argumentos de palabra clave en listas de argumentos de tipo",
+        "keywordOnlyAfterArgs": "No se permite el separador de argumentos por palabra clave después del parámetro \"*\".",
+        "keywordParameterMissing": "Uno o varios parámetros de palabra clave deben seguir el parámetro \"*\"",
+        "keywordSubscriptIllegal": "No se admiten argumentos de palabra clave dentro de subíndices",
+        "lambdaReturnTypePartiallyUnknown": "El tipo de retorno de la lambda \"{returnType}\" es parcialmente desconocido.",
+        "lambdaReturnTypeUnknown": "Se desconoce el tipo de retorno de la lambda",
+        "listAssignmentMismatch": "La expresión con el tipo \"{type}\" no puede asignarse a la lista de destino",
+        "listInAnnotation": "Expresión de lista no permitida en anotación de tipo",
+        "literalEmptyArgs": "Se esperaban uno o varios argumentos de tipo después de \"Literal\"",
+        "literalNotCallable": "El tipo literal no puede instanciarse",
+        "literalUnsupportedType": "Los argumentos de tipo para \"Literal\" deben ser None, un valor literal (int, bool, str, o bytes), o un valor enum",
+        "matchIncompatible": "Las declaraciones de coincidencia requieren Python 3.10 o posterior",
+        "matchIsNotExhaustive": "Los casos dentro de la declaración de coincidencia no tratan exhaustivamente todos los valores",
+        "maxParseDepthExceeded": "Se ha superado la profundidad máxima de análisis; divida la expresión en subexpresiones más pequeñas.",
+        "memberAccess": "No se puede acceder al miembro \"{name}\" para el tipo \" {type} \"",
+        "memberDelete": "No se puede eliminar el miembro \"{name}\" para el tipo \"{type}\"",
+        "memberSet": "No se puede asignar el miembro \"{name}\" para el tipo \"{type}\"",
+        "metaclassConflict": "La metaclase de una clase derivada debe ser una subclase de las metaclases de todas sus clases base",
+        "metaclassDuplicate": "Solo se puede proporcionar una metaclase",
+        "metaclassIsGeneric": "La metaclase no puede ser genérica",
+        "methodNotDefined": "Método \"{name}\" no definido",
+        "methodNotDefinedOnType": "Método \"{name}\" no definido en el tipo \"{type}\"",
+        "methodOrdering": "No se puede crear una ordenación coherente de los métodos",
+        "methodOverridden": "\"{name}\" invalida el método del mismo nombre en la clase \"{className}\" con el tipo incompatible \"{type}\"",
+        "methodReturnsNonObject": "El método \"{name}\" no devuelve un objeto",
+        "missingProtocolMembers": "La clase deriva de una o varias clases de protocolo, pero no implementa todos los miembros necesarios",
+        "missingSuperCall": "El método \"{methodName}\" no llama al método del mismo nombre en la clase principal.",
+        "moduleAsType": "El módulo no se puede usar como tipo.",
+        "moduleNotCallable": "No se puede llamar al módulo",
+        "moduleUnknownMember": "\"{memberName}\" no es un miembro conocido del módulo \"{moduleName}\"",
+        "namedExceptAfterCatchAll": "Una cláusula except con nombre no puede aparecer después de la cláusula catch-all except",
+        "namedParamAfterParamSpecArgs": "El parámetro de palabra clave \"{name}\" no puede aparecer en la firma después del parámetro ParamSpec args",
+        "namedTupleEmptyName": "Los nombres de una tupla con nombre no pueden estar vacíos",
+        "namedTupleFirstArg": "Nombre de clase de tupla como primer argumento",
+        "namedTupleMultipleInheritance": "No se admite la herencia múltiple con NamedTuple",
+        "namedTupleNameKeyword": "Los nombres de campo no pueden ser una palabra clave",
+        "namedTupleNameType": "Tupla de dos entradas esperada que especifica el nombre y el tipo de entrada",
+        "namedTupleNameUnique": "Los nombres dentro de una tupla con nombre deben ser únicos",
+        "namedTupleNoTypes": "\"namedtuple\" no proporciona tipos para las entradas de tupla; utilice en su lugar \"NamedTuple\".",
+        "namedTupleSecondArg": "Lista de entradas de tupla con nombre esperada como segundo argumento",
+        "newClsParam": "__new__ debe tomar un parámetro \"cls\"",
+        "newTypeBadName": "El primer argumento de NewType debe ser una cadena literal",
+        "newTypeLiteral": "NewType no se puede usar con el tipo Literal",
+        "newTypeNotAClass": "Clase esperada como segundo argumento de NewType",
+        "newTypeParamCount": "NewType requiere dos argumentos posicionales",
+        "newTypeProtocolClass": "NewType no puede utilizarse con la clase de protocolo",
+        "noOverload": "Ninguna sobrecarga para \"{name}\" coincide con los argumentos proporcionados",
+        "noReturnContainsReturn": "La función con tipo de retorno declarado \"NoReturn\" no puede incluir una sentencia volver",
+        "noReturnContainsYield": "La función con tipo de retorno declarado \"NoReturn\" no puede incluir una instrucción yield",
+        "noReturnReturnsNone": "Una función con el tipo declarado \"NoReturn\" no puede devolver \"None\".",
+        "nonDefaultAfterDefault": "El argumento no predeterminado sigue al argumento predeterminado",
+        "nonLocalInModule": "Declaración no local no permitida a nivel de módulo",
+        "nonLocalNoBinding": "No se ha encontrado ningún enlace para \"{name}\" no local.",
+        "nonLocalReassignment": "\"{name}\" se asigna antes de la declaración no local",
+        "nonLocalRedefinition": "\"{name}\" ya fue declarado no local",
+        "noneNotCallable": "No se puede llamar al objeto de tipo \"None\"",
+        "noneNotIterable": "No se puede utilizar un objeto de tipo \"Ninguno\" como valor iterable",
+        "noneNotSubscriptable": "El objeto de tipo \"None\" no se puede suscribir",
+        "noneNotUsableWith": "El objeto de tipo \"None\" no puede utilizarse con \"with\".",
+        "noneOperator": "El operador \"{operator}\" no es compatible con \"None\".",
+        "noneUnknownMember": "\"{name}\" no es un miembro conocido de \"None\"",
+        "notRequiredArgCount": "Se esperaba un único argumento de tipo después de \"NotRequired\".",
+        "notRequiredNotInTypedDict": "\"NotRequired\" no está permitido en este contexto",
+        "objectNotCallable": "El objeto de tipo \"{type}\" no es invocable",
+        "obscuredClassDeclaration": "La declaración de clase \"{name}\" queda oculta por una declaración del mismo nombre",
+        "obscuredFunctionDeclaration": "La declaración de función \"{name}\" queda oculta por una declaración del mismo nombre",
+        "obscuredMethodDeclaration": "La declaración de método \"{name}\" queda oculta por una declaración del mismo nombre",
+        "obscuredParameterDeclaration": "La declaración de parámetro \"{name}\" queda oculta por una declaración del mismo nombre",
+        "obscuredTypeAliasDeclaration": "La declaración de alias de tipo \"{name}\" queda oculta por una declaración del mismo nombre",
+        "obscuredVariableDeclaration": "La declaración \"{name}\" está oculta por una declaración del mismo nombre",
+        "operatorLessOrGreaterDeprecated": "El operador \"<>\" no es admitido en Python 3; utilice en su lugar \"!=\".",
+        "optionalExtraArgs": "Se esperaba un argumento de tipo después de \"Optional\"",
+        "orPatternIrrefutable": "El patrón irrefutable solo se permite como el último subpatrón en un patrón \"or\".",
+        "orPatternMissingName": "Todos los subpatrones de un patrón \"o\" deben tener los mismos nombres",
+        "overlappingOverload": "La sobrecarga {obscured} para \"{name}\" nunca se utilizará porque sus parámetros se superpone con la sobrecarga {obscuredBy}.",
+        "overloadAbstractMismatch": "Todos los métodos sobrecargados deben ser abstractos o no",
+        "overloadImplementationMismatch": "La implementación de la sobrecarga no es consistente con la firma de la sobrecarga {index}",
+        "overloadReturnTypeMismatch": "La sobrecarga {prevIndex} para \" {name}\" se superpone con la sobrecarga {newIndex} y devuelve un tipo incompatible",
+        "overloadWithImplementation": "\"{name}\" está marcado como sobrecarga, pero incluye una implementación",
+        "overloadWithoutImplementation": "\"{name}\" está marcado como sobrecarga, pero no se proporciona ninguna implementación.",
+        "overriddenMethodNotFound": "El método \"{name}\" está marcado como invalidación, pero no existe ningún método base con el mismo nombre",
+        "overrideDecoratorMissing": "El método \"{name}\" no está marcado como invalidación, pero está reemplazando un método de la clase \"{className}\"",
+        "paramAfterKwargsParam": "El parámetro no puede seguir el parámetro \"**\"",
+        "paramAlreadyAssigned": "El parámetro \"{name}\" ya está asignado",
+        "paramAnnotationMissing": "Falta la anotación de tipo para el parámetro \"{name}\"",
+        "paramAssignmentMismatch": "La expresión de tipo \"{sourceType}\" no se puede asignar al parámetro de tipo \"{paramType}\"",
+        "paramNameMissing": "Ningún parámetro llamado \"{name}\"",
+        "paramSpecArgsKwargsUsage": "Los miembros \"args\" y \"kwargs\" de ParamSpec deben aparecer ambos dentro de una firma de función",
+        "paramSpecArgsMissing": "Faltan argumentos para ParamSpec \"{type}\".",
+        "paramSpecArgsUsage": "El miembro \"args\" de ParamSpec solo es válido cuando se usa con el parámetro *args.",
+        "paramSpecAssignedName": "ParamSpec debe asignarse a una variable llamada \"{name} \"",
+        "paramSpecContext": "ParamSpec no permitido en este contexto",
+        "paramSpecDefaultNotTuple": "Se esperaban puntos suspensivos, una expresión de tupla o ParamSpec para el valor predeterminado de ParamSpec",
+        "paramSpecFirstArg": "Se esperaba el nombre de ParamSpec como primer argumento",
+        "paramSpecKwargsUsage": "El miembro \"kwargs\" de ParamSpec solo es válido cuando se utiliza con el parámetro **kwargs",
+        "paramSpecNotBound": "La especificación de parámetro \"{type}\" no tiene valor vinculado",
+        "paramSpecNotUsedByOuterScope": "ParamSpec \"{name}\" no tiene significado en este contexto",
+        "paramSpecScopedToReturnType": "El ámbito de ParamSpec \"{name}\" es un ámbito al que se puede llamar dentro del tipo de valor devuelto y no se puede hacer referencia a él en el cuerpo de la función.",
+        "paramSpecUnknownArg": "ParamSpec no admite más de un argumento",
+        "paramSpecUnknownMember": "\"{name}\" no es un miembro conocido de ParamSpec",
+        "paramSpecUnknownParam": "\"{name}\" es un parámetro desconocido para ParamSpec",
+        "paramTypeCovariant": "La variable de tipo covariante no puede utilizarse en el tipo de parámetro",
+        "paramTypePartiallyUnknown": "El tipo de parámetro \"{paramName}\" es parcialmente desconocido",
+        "paramTypeUnknown": "Se desconoce el tipo del parámetro \"{paramName}\".",
+        "parenthesizedContextManagerIllegal": "Los paréntesis dentro de la instrucción \"with\" requieren Python 3.9 o posterior",
+        "patternNeverMatches": "El patrón nunca coincidirá para el tipo de asunto \"{type}\"",
+        "positionArgAfterNamedArg": "El argumento posicional no puede aparecer después de los argumentos de palabra clave",
+        "positionOnlyAfterArgs": "No se permite el separador de argumentos por posición tras el parámetro \"*\".",
+        "positionOnlyAfterKeywordOnly": "El parámetro \"/\" debe aparecer antes del parámetro \"*\".",
+        "positionOnlyFirstParam": "Separador de argumentos de solo posición no permitido como primer parámetro",
+        "positionOnlyIncompatible": "El separador de argumentos por posición requiere Python 3.8 o posterior.",
+        "privateImportFromPyTypedModule": "\"{name}\" no se exporta desde el módulo \"{module}\"",
+        "privateUsedOutsideOfClass": "\"{name}\" es privado y se utiliza fuera de la clase en la que se declara",
+        "privateUsedOutsideOfModule": "\"{name}\" es privado y se utiliza fuera del módulo en el que se declara",
+        "propertyOverridden": "\"{name}\" invalida incorrectamente la propiedad del mismo nombre en la clase \"{className}\"",
+        "propertyStaticMethod": "Métodos estáticos no permitidos para los valores getter, setter o deleter de propiedades",
+        "protectedUsedOutsideOfClass": "\"{name}\" está protegido y se usa fuera de la clase en la que se declara",
+        "protocolBaseClass": "La clase de protocolo \"{classType}\" no se puede derivar de la clase que no es de protocolo \"{baseType}\"",
+        "protocolBaseClassWithTypeArgs": "No se permiten argumentos de tipo con la clase Protocol cuando se usa la sintaxis de parámetro de tipo",
+        "protocolIllegal": "El uso de \"Protocolo\" requiere Python 3.7 o posterior.",
+        "protocolNotAllowedInTypeArgument": "\"Protocol\" no puede utilizarse como argumento de tipo",
+        "protocolUsedInCall": "La clase de protocolo no puede utilizarse en la llamada \"{name}\".",
+        "protocolVarianceContravariant": "La variable de tipo \"{variable}\" usada en el protocolo genérico \"{class}\" debe ser contravariante.",
+        "protocolVarianceCovariant": "La variable de tipo \"{variable}\" usada en el protocolo genérico \"{class}\" debe ser covariante",
+        "protocolVarianceInvariant": "La variable de tipo \"{variable}\" usada en el protocolo genérico \"{class}\" debe ser invariable.",
+        "pyrightCommentInvalidDiagnosticBoolValue": "La directiva de comentario Pyright debe ir seguida de \"=\" y un valor de true o false",
+        "pyrightCommentInvalidDiagnosticSeverityValue": "La directiva de comentario Pyright debe ir seguida de \"=\" y un valor de verdadero, falso, error, advertencia, información o ninguno.",
+        "pyrightCommentMissingDirective": "El comentario de copyright debe ir seguido de una directiva (básica o estricta) o de una regla de diagnóstico",
+        "pyrightCommentNotOnOwnLine": "Los comentarios de copyright utilizados para controlar los ajustes a nivel de archivo deben aparecer en su propia línea",
+        "pyrightCommentUnknownDiagnosticRule": "\"{rule}\" es una regla de diagnóstico desconocida para el comentario pyright",
+        "pyrightCommentUnknownDiagnosticSeverityValue": "\"{value}\" es un valor no válido para el comentario pyright; se espera verdadero, falso, error, advertencia, información o ninguno.",
+        "pyrightCommentUnknownDirective": "\"{directive}\" es una directiva desconocida para el comentario pyright; se esperaba \"strict\" o \"basic\".",
+        "readOnlyArgCount": "Se esperaba un único argumento de tipo después de \"ReadOnly\"",
+        "readOnlyNotInTypedDict": "\"ReadOnly\" no está permitido en este contexto",
+        "recursiveDefinition": "No se pudo determinar el tipo de \"{name}\" porque hace referencia a sí mismo.",
+        "relativeImportNotAllowed": "Las importaciones relativas no pueden utilizarse con la forma \"import .a\"; utilice en su lugar \"from . import a\"",
+        "requiredArgCount": "Se esperaba un único argumento de tipo después de \"Required\"",
+        "requiredNotInTypedDict": "\"Required\" no está permitido en este contexto",
+        "returnInAsyncGenerator": "No se permite la instrucción Return con valor en el generador asincrónico",
+        "returnMissing": "La función con el tipo declarado \"{returnType}\" debe devolver un valor en todas las rutas de acceso del código.",
+        "returnOutsideFunction": "\"return\" solo se puede usar dentro de una función",
+        "returnTypeContravariant": "La variable de tipo contravariante no se puede usar en el tipo de valor devuelto",
+        "returnTypeMismatch": "La expresión del tipo \"{exprType}\" no puede asignarse al tipo de retorno \"{returnType}\"",
+        "returnTypePartiallyUnknown": "El tipo de retorno, \"{returnType}\", es parcialmente desconocido",
+        "returnTypeUnknown": "Tipo de retorno desconocido",
+        "revealLocalsArgs": "No se esperaba ningún argumento para la llamada \"reveal_locals\"",
+        "revealLocalsNone": "No hay locales en este ámbito",
+        "revealTypeArgs": "Se esperaba un único argumento posicional para la llamada \"reveal_type\"",
+        "revealTypeExpectedTextArg": "El argumento \"expected_text\" de la función \"reveal_type\" debe ser un valor literal str.",
+        "revealTypeExpectedTextMismatch": "El tipo de texto no coincide; se esperaba \"{expected}\" pero se ha recibido \"{received}\".",
+        "revealTypeExpectedTypeMismatch": "Error de coincidencia de tipos; se esperaba \"{expected}\", pero se recibió \"{received}\"",
+        "selfTypeContext": "\"Self\" no es válido en este contexto",
+        "selfTypeWithTypedSelfOrCls": "\"Auto\" no puede utilizarse en una función con un parámetro `self` o `cls` que tenga una anotación de tipo distinta de \"Auto\".",
+        "setterGetterTypeMismatch": "El tipo de valor setter de propiedad no se puede asignar al tipo devuelto por el valor setter",
+        "singleOverload": "\"{name}\" está marcado como sobrecarga, pero faltan sobrecargas adicionales",
+        "slotsAttributeError": "\"{name}\" no se especificó en __slots__",
+        "slotsClassVarConflict": "\"{name}\" entra en conflicto con la variable de instancia declarada en __slots__",
+        "starPatternInAsPattern": "El patrón estrella no puede utilizarse con el objetivo \"as\"",
+        "starPatternInOrPattern": "El patrón de estrella no puede unirse a otros patrones",
+        "starStarWildcardNotAllowed": "** no puede utilizarse con el comodín \"_\".",
+        "staticClsSelfParam": "Los métodos estáticos no deben tomar un parámetro \"auto\" o \"cls\".",
+        "stdlibModuleOverridden": "\"{path}\" está reemplazando el módulo stdlib \"{name}\"",
+        "strictTypeGuardReturnType": "El tipo de retorno de StrictTypeGuard (\"{returnType}\") no es asignable al tipo de parámetro de valor (\"{type}\")",
+        "stringNonAsciiBytes": "Carácter no ASCII no permitido en el literal de cadena de bytes",
+        "stringNotSubscriptable": "La expresión de cadena no puede ir entre comillas en la anotación de tipo; encierre toda la anotación entre comillas.",
+        "stringUnsupportedEscape": "Secuencia de escape no admitida en el literal de cadena",
+        "stringUnterminated": "La cadena literal no está terminada",
+        "stubFileMissing": "Archivo Stub no encontrado para \"{importName}\"",
+        "stubUsesGetAttr": "El archivo stub de tipo está incompleto; \"__getattr__\" oculta errores de tipo para el módulo",
+        "sublistParamsIncompatible": "Los parámetros de sublista no están soportados en Python 3.x",
+        "superCallArgCount": "No se esperaban más de dos argumentos para la llamada \"super\"",
+        "superCallFirstArg": "Se esperaba el tipo de clase como primer argumento de la llamada a \"super\" pero se recibió \"{type}\"",
+        "superCallSecondArg": "El segundo argumento de la llamada a \"super\" debe ser un objeto o clase que derive de \"{type}\"",
+        "superCallZeroArgForm": "La forma sin argumentos de la llamada \"super\" sólo es válida dentro de una clase",
+        "symbolIsPossiblyUnbound": "\"{name}\" está posiblemente desvinculado",
+        "symbolIsUnbound": "\"{name}\" está sin consolidar",
+        "symbolIsUndefined": "\"{name}\" no está definido",
+        "symbolOverridden": "\"{name}\" anula el símbolo del mismo nombre en la clase \"{className}\"",
+        "totalOrderingMissingMethod": "La clase debe definir uno de \"__lt__\", \"__le__\", \"__gt__\", o \"__ge__\" para utilizar total_ordering",
+        "trailingCommaInFromImport": "No se permite la coma final sin paréntesis alrededor",
+        "tryWithoutExcept": "La instrucción Try debe tener al menos una cláusula except o finally",
+        "tupleAssignmentMismatch": "La expresión con el tipo \"{type}\" no se puede asignar a la tupla de destino",
+        "tupleInAnnotation": "No se permite la expresión de tupla en la anotación de tipo",
+        "tupleIndexOutOfRange": "El índice {index} está fuera de rango para el tipo {type}.",
+        "typeAliasIllegalExpressionForm": "Forma de expresión no válida para la definición de alias de tipo",
+        "typeAliasIsRecursiveDirect": "El alias de tipo \"{name}\" no puede usarse a sí mismo en su definición",
+        "typeAliasNotInModuleOrClass": "Un TypeAlias solo puede definirse en el ámbito de un módulo o de una clase",
+        "typeAliasRedeclared": "\"{name}\" se declara como TypeAlias y solo puede asignarse una vez",
+        "typeAliasStatementIllegal": "La sentencia Type alias requiere Python 3.12 o posterior",
+        "typeAliasTypeMustBeAssigned": "TypeAliasType debe asignarse a una variable con el mismo nombre que el alias de tipo",
+        "typeAliasTypeNameArg": "El primer argumento de TypeAliasType debe ser un literal de cadena que represente el nombre del alias de tipo",
+        "typeAliasTypeNameMismatch": "El nombre del alias de tipo debe coincidir con el nombre de la variable a la que se asigna",
+        "typeAliasTypeParamInvalid": "La lista de parámetros de tipo debe ser una tupla que contenga solo TypeVar, TypeVarTuple o ParamSpec.",
+        "typeAnnotationCall": "Anotación de tipo no válida: no se permite la expresión de llamada",
+        "typeAnnotationVariable": "Anotación de tipo ilegal: variable no permitida a menos que sea un alias de tipo",
+        "typeArgListExpected": "ParamSpec esperado, elipsis o lista de tipos",
+        "typeArgListNotAllowed": "Expresión de lista no permitida para este argumento de tipo",
+        "typeArgsExpectingNone": "No se esperaban argumentos de tipo para la clase \"{name}\"",
+        "typeArgsMismatchOne": "Se esperaba un argumento de tipo pero ha recibido {received}",
+        "typeArgsMissingForAlias": "Argumentos de tipo esperados para el alias de tipo genérico \"{name}\"",
+        "typeArgsMissingForClass": "Se esperaban argumentos de tipo para la clase genérica \"{name}\"",
+        "typeArgsTooFew": "Se han proporcionado muy pocos argumentos de tipo para \"{name}\"; se esperaba {expected} pero se ha recibido {received}.",
+        "typeArgsTooMany": "Se proporcionaron demasiados argumentos de tipo para \"{name}\"; se esperaba {expected}, pero se recibieron {received}",
+        "typeAssignmentMismatch": "La expresión del tipo \"{sourceType}\" no puede asignarse al tipo declarado \"{destType}\"",
+        "typeCallNotAllowed": "la llamada a type() no debe utilizarse en la anotación de tipo",
+        "typeCommentDeprecated": "El uso de comentarios de tipo está obsoleto; utilice en su lugar anotaciones de tipo.",
+        "typeExpectedClass": "Se esperaba una expresión de tipo pero se ha recibido \"{type}\"",
+        "typeGuardArgCount": "Se esperaba un único argumento de tipo después de \"TypeGuard\".",
+        "typeGuardParamCount": "Las funciones y métodos de protección de tipo definidos por el usuario deben tener al menos un parámetro de entrada",
+        "typeNotAwaitable": "\"{type}\" no se puede esperar",
+        "typeNotCallable": "\"{expression}\" tiene el tipo \"{type}\" y no se puede llamar",
+        "typeNotIntantiable": "\"{type}\" no puede crear instancias",
+        "typeNotIterable": "\"{type}\" no es iterable",
+        "typeNotSpecializable": "No se pudo especializar el tipo \"{type}\"",
+        "typeNotSubscriptable": "Objeto de tipo \"{type}\" no es subscriptible",
+        "typeNotSupportBinaryOperator": "El operador \"{operator}\" no se admite para los tipos \"{leftType}\" y \"{rightType}\"",
+        "typeNotSupportBinaryOperatorBidirectional": "No se admite el operador \"{operator}\" para los tipos \"{leftType}\" y \"{rightType}\" cuando el tipo esperado es \"{expectedType}\"",
+        "typeNotSupportUnaryOperator": "El operador \"{operator}\" no se admite para el tipo \"{type}\"",
+        "typeNotSupportUnaryOperatorBidirectional": "Operador \"{operator}\" no admitido para el tipo \"{type}\" cuando el tipo esperado es \"{expectedType}\"",
+        "typeNotUsableWith": "El objeto de tipo \"{type}\" no puede utilizarse con \"con\" porque no implementa {method}.",
+        "typeParameterBoundNotAllowed": "No se pueden usar límites o restricciones con un parámetro de tipo variádico o ParamSpec",
+        "typeParameterConstraintTuple": "La restricción del parámetro de tipo debe ser una tupla de dos o más tipos",
+        "typeParameterExistingTypeParameter": "El parámetro de tipo \"{name}\" ya está en uso",
+        "typeParameterNotDeclared": "El parámetro de tipo \"{name}\" no está incluido en la lista de parámetros de tipo para \"{container}\"",
+        "typeParametersMissing": "Debe especificarse al menos un parámetro de tipo",
+        "typePartiallyUnknown": "El tipo de \"{name}\" es parcialmente desconocido",
+        "typeUnknown": "El tipo de \"{name} \" es desconocido",
+        "typeVarAssignedName": "TypeVar debe asignarse a una variable llamada \"{name}\"",
+        "typeVarAssignmentMismatch": "No se puede asignar el tipo \"{type}\" a la variable de tipo \"{name}\"",
+        "typeVarBoundAndConstrained": "TypeVar no puede estar ligado y restringido a la vez",
+        "typeVarBoundGeneric": "El tipo vinculado TypeVar no puede ser genérico",
+        "typeVarConstraintGeneric": "El tipo de restricción TypeVar no puede ser genérico",
+        "typeVarDefaultBoundMismatch": "El tipo predeterminado TypeVar debe ser un subtipo del tipo enlazado.",
+        "typeVarDefaultConstraintMismatch": "El tipo predeterminado TypeVar debe ser uno de los tipos restringidos.",
+        "typeVarDefaultIllegal": "Los tipos predeterminados de variable de tipo requieren Python 3.13 o posterior",
+        "typeVarDefaultInvalidTypeVar": "El parámetro de tipo \"{name}\" tiene un tipo por defecto que hace referencia a una o más variables de tipo que están fuera de ámbito.",
+        "typeVarFirstArg": "Nombre esperado de TypeVar como primer argumento",
+        "typeVarNoMember": "TypeVar \"{type}\" no tiene miembro \"{name}\"",
+        "typeVarNotSubscriptable": "TypeVar \"{type}\" no es subscribible",
+        "typeVarNotUsedByOuterScope": "La variable de tipo \"{name}\" no tiene ningún significado en este contexto",
+        "typeVarPossiblyUnsolvable": "La variable de tipo \"{name}\" puede quedar sin resolver si el autor de la llamada no proporciona ningún argumento para el parámetro \"{param}\"",
+        "typeVarScopedToReturnType": "La variable de tipo \"{name}\" tiene como ámbito una llamada dentro del tipo de valor devuelto y no se puede hacer referencia a ella en el cuerpo de la función.",
+        "typeVarSingleConstraint": "TypeVar debe tener al menos dos tipos restringidos",
+        "typeVarTupleContext": "TypeVarTuple no permitido en este contexto",
+        "typeVarTupleDefaultNotUnpacked": "El tipo predeterminado TypeVarTuple debe ser una tupla desempaquetada o TypeVarTuple",
+        "typeVarTupleMustBeUnpacked": "Se requiere el operador Unpack para el valor TypeVarTuple.",
+        "typeVarTupleUnknownParam": "\"{name}\" es un parámetro desconocido para TypeVarTuple",
+        "typeVarUnknownParam": "\"{name}\" es un parámetro desconocido para TypeVar",
+        "typeVarUsedByOuterScope": "TypeVar \"{name}\" ya está en uso por un ámbito externo",
+        "typeVarUsedOnlyOnce": "TypeVar \"{name}\" solo aparece una vez en la firma de la función genérica",
+        "typeVarVariance": "TypeVar no puede ser covariante y contravariante",
+        "typeVarWithoutDefault": "\"{name}\" no puede aparecer después de \"{other}\" en la lista de parámetros de tipo porque no tiene ningún tipo predeterminado",
+        "typeVarsNotInGenericOrProtocol": "Generic[] o Protocol[] deben incluir todas las variables de tipo",
+        "typedDictAccess": "No se ha podido acceder al elemento en TypedDict",
+        "typedDictBadVar": "Las clases TypedDict solo pueden contener anotaciones de tipo",
+        "typedDictBaseClass": "Todas las clases base de las clases TypedDict deben ser también clases TypedDict",
+        "typedDictBoolParam": "Se esperaba que el parámetro \"{name}\" tuviera un valor de Verdadero o Falso.",
+        "typedDictDelete": "No se puede eliminar un elemento en TypedDict",
+        "typedDictEmptyName": "Los nombres de un TypedDict no pueden estar vacíos",
+        "typedDictEntryName": "Cadena literal esperada para el nombre de la entrada del diccionario",
+        "typedDictEntryUnique": "Los nombres dentro de un diccionario deben ser únicos",
+        "typedDictExtraArgs": "No se admiten argumentos TypedDict adicionales",
+        "typedDictFieldReadOnlyRedefinition": "El campo TypedDict \"{name}\" no puede redefinirse como de solo lectura",
+        "typedDictFieldTypeRedefinition": "No se puede redefinir el tipo del campo TypedDict \"{name}\".",
+        "typedDictFirstArg": "Nombre de clase TypedDict esperado como primer argumento",
+        "typedDictSecondArgDict": "Parámetro dict o palabra clave esperado como segundo parámetro",
+        "typedDictSecondArgDictEntry": "Entrada de diccionario simple esperada",
+        "typedDictSet": "No se pudo asignar el elemento en TypedDict",
+        "unaccessedClass": "No se tiene acceso a la clase \"{name}\"",
+        "unaccessedFunction": "No se accede a la función \"{name}",
+        "unaccessedImport": "No se accede a la importación \"{name}",
+        "unaccessedSymbol": "No se puede acceder a \"{name}\"",
+        "unaccessedVariable": "No se accede a la variable \"{name} \".",
+        "unannotatedFunctionSkipped": "Se omite el análisis de la función \"{name}\" porque no está anotada",
+        "unexpectedAsyncToken": "Se esperaba que \"def\", \"with\" o \"for\" siguieran a \"async\".",
+        "unexpectedExprToken": "Token inesperado al final de la expresión",
+        "unexpectedIndent": "sangSangría inesperadaría inesperada",
+        "unexpectedUnindent": "No se espera sangría",
+        "unhashableDictKey": "La clave del diccionario debe ser hash",
+        "unhashableSetEntry": "La entrada del conjunto debe ser hashable",
+        "uninitializedAbstractVariables": "Las variables definidas en la clase base abstracta no se inicializan en la clase final \"{classType}\"",
+        "uninitializedInstanceVariable": "La variable de instancia \"{name}\" no está inicializada en el cuerpo de la clase o en el método __init__.",
+        "unionForwardReferenceNotAllowed": "Union syntax cannot be used with string operand; use quotes around entire expression",
+        "unionSyntaxIllegal": "La sintaxis alternativa para las uniones requiere Python 3.10 o posterior.",
+        "unionTypeArgCount": "La unión requiere dos o más argumentos de tipo",
+        "unmatchedEndregionComment": "A #endregion le falta la #region correspondiente",
+        "unmatchedRegionComment": "Falta la #región correspondiente #endregion",
+        "unnecessaryCast": "Llamada \"cast\" innecesaria; el tipo ya es \"{type}\"",
+        "unnecessaryIsInstanceAlways": "Llamada isinstance innecesaria; \"{testType}\" es siempre una instancia de \"{classType}\"",
+        "unnecessaryIsSubclassAlways": "Llamada de issubclass innecesaria; \"{testType}\" siempre es una subclase de \"{classType}\"",
+        "unnecessaryPyrightIgnore": "Comentario \"# pyright: ignore\" innecesario",
+        "unnecessaryPyrightIgnoreRule": "Regla innecesaria \"# pyright: ignore\": \"{name}\"",
+        "unnecessaryTypeIgnore": "Comentario \"# type: ignore\" innecesario",
+        "unpackArgCount": "Se esperaba un único argumento de tipo después de \"Desempaquetar\"",
+        "unpackExpectedTypeVarTuple": "Se esperaba TypeVarTuple o Tuple como argumento de tipo para desempaquetar",
+        "unpackExpectedTypedDict": "Se esperaba un argumento de tipo TypedDict para Unpack",
+        "unpackIllegalInComprehension": "Operación de desempaquetado no permitida en la comprensión",
+        "unpackInAnnotation": "No se permite el operador desempaquetado en la anotación de tipo",
+        "unpackInDict": "Operación de desempaquetado no permitida en diccionarios",
+        "unpackInSet": "No se permite el operador Unpack dentro de un conjunto",
+        "unpackNotAllowed": "Desembalaje no permitido en este contexto",
+        "unpackOperatorNotAllowed": "Operación de desempaquetado no permitida en este contexto",
+        "unpackTuplesIllegal": "Operación de desempaquetado no permitida en tuplas anteriores a Python 3.8",
+        "unpackedArgInTypeArgument": "Los argumentos sin empaquetar no pueden utilizarse en listas de argumentos de tipo",
+        "unpackedArgWithVariadicParam": "No se puede usar un argumento desempaquetado para el parámetro TypeVarTuple",
+        "unpackedDictArgumentNotMapping": "La expresión del argumento después de ** debe ser un mapeo con un tipo de clave \"str\".",
+        "unpackedDictSubscriptIllegal": "El operador de desempaquetado del diccionario en el subíndice no está permitido",
+        "unpackedSubscriptIllegal": "El operador de desempaquetado en el subíndice requiere Python 3.11 o posterior.",
+        "unpackedTypeVarTupleExpected": "Se espera un TypeVarTuple desempaquetado; use Unpack[{nombre1}] o *{name2}",
+        "unpackedTypedDictArgument": "No se puede emparejar el argumento TypedDict desempaquetado con los parámetros",
+        "unreachableCode": "El código es inalcanzable",
+        "unreachableExcept": "La cláusula Excepto es inalcanzable porque la excepción ya está administrada",
+        "unsupportedDunderAllOperation": "No se admite la operación en \"__all__\", por lo que la lista de símbolos exportada puede ser incorrecta.",
+        "unusedCallResult": "El resultado de la expresión de llamada es de tipo \"{type}\" y no se usa; asignar a la variable \"_\" si esto es intencionado",
+        "unusedCoroutine": "El resultado de la llamada a una función asíncrona no se utiliza; utilice \"await\" o asigne el resultado a una variable.",
+        "unusedExpression": "El valor de expresión no se usa",
+        "varAnnotationIllegal": "Las anotaciones de tipo para variables requieren Python 3.6 o posterior; utilice el comentario de tipo para la compatibilidad con versiones anteriores.",
+        "variableFinalOverride": "La variable \"{name}\" está marcada como Final y anula la variable no Final del mismo nombre en la clase \"{className}\".",
+        "variadicTypeArgsTooMany": "La lista de argumentos de tipo puede tener como máximo una TypeVarTuple o Tupla desempaquetada",
+        "variadicTypeParamTooManyAlias": "Los alias de tipo pueden tener como máximo un parámetro de tipo TypeVarTuple, pero reciben varios ({names})",
+        "variadicTypeParamTooManyClass": "La clase genérica puede tener como máximo un parámetro de tipo TypeVarTuple pero recibió múltiples ({names})",
+        "walrusIllegal": "El operador \":=\" requiere Python 3.8 o posterior",
+        "walrusNotAllowed": "El operador \":=\" no es permitido en este contexto sin paréntesis alrededor",
+        "wildcardInFunction": "No se permite la importación de comodines dentro de una clase o función",
+        "wildcardLibraryImport": "No se permite la importación de caracteres comodín desde una biblioteca",
+        "wildcardPatternTypePartiallyUnknown": "El tipo capturado por el patrón comodín es parcialmente desconocido",
+        "wildcardPatternTypeUnknown": "Se desconoce el tipo capturado por el patrón de caracteres comodín",
+        "yieldFromIllegal": "El uso de \"yield\" requiere Python 3.3 o posterior.",
+        "yieldFromOutsideAsync": "\"yield from\" no permitido en una función asincrónica",
+        "yieldOutsideFunction": "\"yield\" no se permite fuera de una función o lambda",
+        "yieldWithinListCompr": "\"yield\" no está permitido dentro de una comprensión de lista",
+        "zeroCaseStatementsFound": "La instrucción Match debe incluir al menos una instrucción case",
+        "zeroLengthTupleNotAllowed": "Tuple de longitud cero no permitida en este contexto"
+    },
+    "DiagnosticAddendum": {
+        "argParam": "El argumento corresponde al parámetro \"{paramName}\"",
+        "argParamFunction": "El argumento corresponde al parámetro \"{paramName}\" en la función \"{functionName}\"",
+        "argsParamMissing": "El parámetro \"*{paramName}\" no tiene ningún parámetro correspondiente",
+        "argsPositionOnly": "Error de coincidencia del parámetro de solo posición; se esperaba {expected}, pero se recibieron {received}",
+        "argumentType": "El tipo de argumento es \"{type}\"",
+        "argumentTypes": "Tipos de argumento: ({types})",
+        "assignToNone": "El tipo no puede asignarse al tipo \"None\"",
+        "asyncHelp": "¿Quería decir \"async with\"?",
+        "baseClassOverriddenType": "La clase base \"{baseClass}\" proporciona el tipo \"{type}\", que se sobrescribe",
+        "baseClassOverridesType": "Invalidaciones de clase base \"{baseClass}\" con el tipo \"{type}\"",
+        "conditionalRequiresBool": "El método __bool__ para el tipo \"{operandType}\" devuelve el tipo \"{boolReturnType}\" en lugar de \"bool\"",
+        "dataClassFieldLocation": "en declaración de campo",
+        "dataClassFrozen": "\"{name}\" está congelado",
+        "finalMethod": "Método final",
+        "functionParamDefaultMissing": "Falta el argumento predeterminado en el parámetro \"{name}\"",
+        "functionParamName": "Nombre de parámetro no coincidente: \"{destName}\" frente a \"{srcName}\"",
+        "functionReturnTypeMismatch": "El tipo de valor devuelto de la función \"{sourceType}\" no es compatible con el tipo \"{destType}\"",
+        "functionTooFewParams": "La función acepta muy pocos parámetros posicionales; esperado {expected} pero recibido {received}",
+        "functionTooManyParams": "La función acepta demasiados parámetros posicionales; esperado {expected} pero recibido {received}",
+        "incompatibleDeleter": "El método de eliminación de propiedades no es compatible",
+        "incompatibleGetter": "El método captador de propiedad no es compatible",
+        "incompatibleSetter": "El método setter de la propiedad no es compatible",
+        "initMethodLocation": "El método __init__ se define en la clase \"{type}\"",
+        "initMethodSignature": "La firma de __init__ es \"{type}\"",
+        "keyNotRequired": "\"{name}\" no es una clave necesaria en \"{type}\", por lo que el acceso puede dar lugar a una excepción en tiempo de ejecución",
+        "keyReadOnly": "\"{name}\" es una clave de solo lectura en \"{type}\"",
+        "keyRequiredDeleted": "\"{name}\" es una clave necesaria y no se puede eliminar",
+        "keyUndefined": "\"{name}\" no es una clave definida en \"{type}\"",
+        "kwargsParamMissing": "El parámetro \"**{paramName}\" no tiene ningún parámetro correspondiente.",
+        "listAssignmentMismatch": "El tipo \"{type}\" es incompatible con la lista de objetivos",
+        "literalAssignmentMismatch": "\"{sourceType}\" no puede asignarse al tipo \"{tipoDest}\"",
+        "matchIsNotExhaustiveHint": "Si no se pretende un tratamiento exhaustivo, agregue \"case _: pass\"",
+        "matchIsNotExhaustiveType": "Tipo no manejado: \"{type}\"",
+        "memberAssignment": "La expresión de tipo \"{type}\" no se puede asignar al miembro \"{name}\" de la clase \"{classType}\"",
+        "memberIsAbstract": "\"{type}. {name}\" es abstracto",
+        "memberIsAbstractMore": "y {count} más",
+        "memberIsFinalInProtocol": "\"{name}\" está marcado como Final en el protocolo",
+        "memberIsInitVar": "El miembro \"{name}\" es un campo solo de inicialización",
+        "memberIsInvariant": "\"{name}\" es invariable porque es mutable",
+        "memberIsNotFinalInProtocol": "\"{name}\" no está marcado como Final en el protocolo",
+        "memberSetClassVar": "El miembro \"{name}\" no se puede asignar a través de una instancia de clase porque es un ClassVar.",
+        "memberTypeMismatch": "\"{name}\" es un tipo incompatible",
+        "memberUnknown": "El miembro \"{name}\" es desconocido",
+        "missingDeleter": "Falta el método de eliminación de propiedades",
+        "missingGetter": "Falta el método Getter de la propiedad",
+        "missingProtocolMember": "El miembro \"{name}\" está declarado en la clase de protocolo \"{classType}\"",
+        "missingSetter": "Falta el método establecedor de propiedades",
+        "namedParamMissingInDest": "Falta el parámetro de palabra clave \"{name}\" en el destino",
+        "namedParamMissingInSource": "Falta el parámetro de palabra clave \"{name}\" en el origen",
+        "namedParamTypeMismatch": "El parámetro de palabra clave \"{name}\" del tipo \"{sourceType}\" no puede asignarse al tipo \"{destType}\"",
+        "newMethodLocation": "El método __new__ está definido en la clase \"{type}\"",
+        "newMethodSignature": "La firma de __new__ es \"{type}\"",
+        "noOverloadAssignable": "Ninguna función sobrecargada coincide con el tipo \"{type}\"",
+        "orPatternMissingName": "Nombres que faltan: {name}",
+        "overloadNotAssignable": "Una o más sobrecargas de \"{name}\" no es asignable",
+        "overloadSignature": "Aquí se define la firma de la sobrecarga",
+        "overloadWithImplementation": "El cuerpo de una sobrecarga de función debe ser \"...\".",
+        "overriddenMethod": "Método reemplazado",
+        "overriddenSymbol": "Símbolo anulado",
+        "overrideNoOverloadMatches": "Ninguna firma de sobrecarga en anulación es compatible con el método base",
+        "overrideNotClassMethod": "El método base se declara como Método de clase pero el Reemplazar no",
+        "overrideNotInstanceMethod": "El método base se declara como método de instancia, pero la invalidación no",
+        "overrideNotStaticMethod": "El método base se declara como staticmethod pero el reemplazo no",
+        "overrideOverloadNoMatch": "La sobrecarga {index} no es compatible con el método base",
+        "overrideOverloadOrder": "Las sobrecargas para el método de anulación deben estar en el mismo orden que el método base",
+        "overrideParamKeywordNoDefault": "El parámetro de palabra clave \"{name}\" no coincide: el parámetro base tiene el valor de argumento predeterminado, el parámetro de invalidación no",
+        "overrideParamKeywordType": "El parámetro de palabra clave \"{name}\" no coincide: el parámetro base es de tipo \"{baseType}\", el parámetro de invalidación es de tipo \"{overrideType}\"",
+        "overrideParamName": "El nombre del parámetro {index} no coincide: el parámetro base se denomina \"{baseName}\", el parámetro de invalidación se denomina \"{overrideName}\"",
+        "overrideParamNameExtra": "Falta el parámetro \"{name}\" en la base",
+        "overrideParamNameMissing": "Falta el parámetro \"{name}\" en la invalidación",
+        "overrideParamNamePositionOnly": "El nombre del parámetro {index} no coincide: el parámetro base se llama \"{baseName}\", el parámetro de anulación es \"position-only\".",
+        "overrideParamNoDefault": "El parámetro {index} no coincide: el parámetro base tiene un valor de argumento predeterminado, el parámetro de invalidación no",
+        "overrideParamType": "El parámetro {index} no coincide: el parámetro base es de tipo \"{baseType}\", el parámetro de invalidación es de tipo \"{overrideType}\"",
+        "overridePositionalParamCount": "El recuento de parámetros posicionales no coincide; el método base tiene {baseCount}, pero la invalidación tiene {overrideCount}",
+        "overrideReturnType": "Error de tipo de retorno: el método base devuelve el tipo \"{baseType}\", el reemplazo devuelve el tipo \"{overrideType}\".",
+        "overrideType": "La clase base define el tipo como \"{type}\"",
+        "paramAssignment": "Parámetro {index}: el tipo \"{sourceType}\" no puede asignarse al tipo \"{destType}\"",
+        "paramSpecMissingInOverride": "Faltan parámetros ParamSpec en el método de invalidación",
+        "paramType": "El tipo de parámetro es \"{paramType}\"",
+        "privateImportFromPyTypedSource": "Importar desde \"{module}\" en su lugar",
+        "propertyAccessFromProtocolClass": "No se puede tener acceso a una propiedad definida dentro de una clase de protocolo como variable de clase",
+        "propertyMethodIncompatible": "El método de propiedad \"{name}\" no es compatible",
+        "propertyMethodMissing": "Falta el método de propiedad \"{name}\" en la invalidación",
+        "propertyMissingDeleter": "La propiedad \"{name}\" no tiene un supresor definido",
+        "propertyMissingSetter": "La propiedad \"{name}\" no tiene el valor setter definido",
+        "protocolIncompatible": "\"{sourceType}\" no es compatible con el protocolo \"{destType}\"",
+        "protocolMemberClassVar": "\"{name}\" no es una variable de clase",
+        "protocolMemberMissing": "\"{name}\" no está presente.",
+        "protocolSourceIsNotConcrete": "\"{sourceType}\" no es un tipo de clase concreto y no se puede asignar al tipo \"{destType}\"",
+        "pyrightCommentIgnoreTip": "Utilice \"# pyright: ignore[<diagnostic rules>] para suprimir el diagnóstico de una sola línea",
+        "readOnlyAttribute": "El atributo \"{name}\" es de solo lectura",
+        "seeClassDeclaration": "Ver declaración de clase",
+        "seeDeclaration": "Ver declaración",
+        "seeFunctionDeclaration": "Ver declaración de función",
+        "seeMethodDeclaration": "Consulte la declaración del métodoa",
+        "seeParameterDeclaration": "Declaración de parámetro",
+        "seeTypeAliasDeclaration": "Véase la declaración de alias de tipo",
+        "seeVariableDeclaration": "declaración de variable out",
+        "tupleAssignmentMismatch": "El tipo \"{type}\" no es compatible con la tupla de destino",
+        "tupleEntryTypeMismatch": "La entrada {entry} de la tupla es de tipo incorrecto",
+        "tupleSizeMismatch": "Tamaño de elemento no coincidente; esperado {expected} pero recibido {received}",
+        "typeAssignmentMismatch": "El tipo \"{sourceType}\" no puede asignarse al tipo \"{destType}\"",
+        "typeBound": "El tipo \"{sourceType}\" es incompatible con el tipo \"{destType}\" vinculado para la variable de tipo \"{name}\"",
+        "typeConstrainedTypeVar": "El tipo \"{type}\" no es compatible con la variable de tipo restringido \"{name}\"",
+        "typeIncompatible": "\"{sourceType}\" no es compatible con \"{destType}\"",
+        "typeNotCallable": "No se puede llamar al tipo \"{type}\"",
+        "typeNotClass": "\"{type}\" no es una clase",
+        "typeNotStringLiteral": "\"{type}\" no es un literal de cadena",
+        "typeOfSymbol": "El tipo de \"{name}\" es \"{type}\"",
+        "typeParamSpec": "El tipo \"{type}\" no es compatible con ParamSpec \"{name}\"",
+        "typeUnsupported": "El tipo \"{type}\" no es compatible",
+        "typeVarDefaultOutOfScope": "La variable de tipo \"{name} \" no está en el ámbito de aplicación",
+        "typeVarIsContravariant": "TypeVar \"{name}\" es contravariante",
+        "typeVarIsCovariant": "TypeVar \"{name}\" es covariante",
+        "typeVarIsInvariant": "TypeVar \"{name}\" es invariante",
+        "typeVarNotAllowed": "TypeVar o tipo genérico con argumentos de tipo no permitidos",
+        "typeVarTupleRequiresKnownLength": "TypeVarTuple no se puede enlazar a una tupla de longitud desconocida",
+        "typeVarUnsolvableRemedy": "Proporciona una sobrecarga que especifica el tipo de retorno cuando no se proporciona el argumento",
+        "typeVarsMissing": "Faltan variables de tipo: {names}",
+        "typedDictFieldMissing": "\"{name}\" falta en \"{type}\"",
+        "typedDictFieldNotReadOnly": "\"{name}\" no es de solo lectura en \"{type}\"",
+        "typedDictFieldNotRequired": "\"{name}\" no es obligatorio en \"{type}\"",
+        "typedDictFieldRequired": "\"{name}\" es obligatorio en \"{type}\"",
+        "typedDictFieldTypeMismatch": "El tipo \"{type}\" no se puede asignar al campo \"{name}\"",
+        "typedDictFieldTypeRedefinition": "El tipo en la clase principal es \"{parentType}\" y el tipo en la clase secundaria es \"{childType}\".",
+        "typedDictFieldUndefined": "\"{name}\" es un campo no definido en el tipo \"{type}\"",
+        "typedDictFinalMismatch": "\"{sourceType}\" no es compatible con \"{destType}\" debido a una discrepancia @final",
+        "unhashableType": "El tipo \"{type}\" no admite hash",
+        "uninitializedAbstractVariable": "La variable de instancia \"{name}\" está definida en la clase base abstracta \"{classType} \" pero no inicializada.",
+        "unreachableExcept": "\"{exceptionType}\" es una subclase de \"{parentType}\"",
+        "useDictInstead": "Usar Dict[T1, T2] para indicar un tipo de diccionario",
+        "useListInstead": "Usar List[T] para indicar un tipo de lista o Union[T1, T2] para indicar un tipo de unión",
+        "useTupleInstead": "Utilice Tupla[T1, ..., Tn] para indicar un tipo de tupla o Union[T1, T2] para indicar un tipo de unión.",
+        "useTypeInstead": "Utilice Type[T] en su lugar",
+        "varianceMismatchForClass": "La varianza del argumento de tipo \"{typeVarName}\" no es compatible con la clase base \"{className}\"",
+        "varianceMismatchForTypeAlias": "La varianza del argumento de tipo \"{typeVarName}\" no es compatible con \"{typeAliasParam}\""
+    }
+}