@zzzen/pyright-internal 1.2.0-dev.20231231 → 1.2.0-dev.20240114

package/dist/localization/package.nls.cs.json

@@ -69,6 +69,7 @@
         "classPatternBuiltInArgPositional": "Vzor třídy přijímá pouze poziční dílčí vzor",
         "classPatternPositionalArgCount": "Příliš mnoho pozičních vzorů pro třídu \"{type}\"; očekávalo se {expected}, ale přijalo se {received}",
         "classPatternTypeAlias": "Typ „{type}“ nelze použít ve vzorci třídy, protože se jedná o specializovaný alias typu",
+        "classPropertyDeprecated": "Vlastnosti třídy jsou v Pythonu 3.11 zastaralé a v Pythonu 3.13 se nebudou podporovat.",
         "classTypeParametersIllegal": "Syntaxe parametru typu třídy vyžaduje Python 312 nebo novější",
         "classVarFirstArgMissing": "Za ClassVar byl očekáván argument typu",
         "classVarNotAllowed": "ClassVar se v tomto kontextu nepovoluje",
@@ -242,6 +243,7 @@
         "inconsistentIndent": "Množství zrušeného odsazení neodpovídá předchozímu odsazení",
         "inconsistentTabs": "Nekonzistentní použití tabulátorů a mezer v odsazení",
         "initMustReturnNone": "Návratový typ __init__ musí být None",
+        "initSubclassCallFailed": "Nesprávné argumenty klíčového slova pro metodu __init_subclass__",
         "initSubclassClsParam": "Přepsání __init_subclass__ by mělo mít parametr cls",
         "instanceMethodSelfParam": "Metody instance by měly mít parametr self",
         "instanceVarOverridesClassVar": "Proměnná instance „{name}“ přepíše proměnnou třídy se stejným názvem ve třídě „{className}“",
@@ -265,6 +267,7 @@
         "listAssignmentMismatch": "Výraz s typem {type} se nedá přiřadit k cílovému seznamu",
         "listInAnnotation": "Výraz seznamu není v poznámce typu povolený",
         "literalEmptyArgs": "Za literálem se očekával jeden nebo více argumentů typu",
+        "literalNotAllowed": "„Literal“ nejde v tomto kontextu použít bez argumentu typu.",
         "literalNotCallable": "Není možné vytvořit instanci typu literálu",
         "literalUnsupportedType": "Argumenty typu pro Literal musí být None, hodnota literálu (int, bool, str nebo bytes) nebo hodnota výčtu",
         "matchIncompatible": "Příkazy match vyžadují Python 3.10 nebo novější",
@@ -333,8 +336,10 @@
         "overlappingKeywordArgs": "Slovník silného typu se překrývá s parametrem klíčového slova: {names}",
         "overlappingOverload": "Přetížení {obscured} pro {name} se nikdy nepoužije, protože jeho parametry se překrývají s přetížením {obscuredBy}",
         "overloadAbstractMismatch": "Přetížené metody musí být všechny abstraktní nebo ne",
+        "overloadClassMethodInconsistent": "Přetížení pro {name} používají @classmethod nekonzistentně.",
         "overloadImplementationMismatch": "Přetížená implementace není konzistentní se signaturou přetížení {index}",
         "overloadReturnTypeMismatch": "Přetížení {prevIndex} pro {name} se překrývá s přetížením {newIndex} a vrací nekompatibilní typ",
+        "overloadStaticMethodInconsistent": "Přetížení pro {name} používají @staticmethod nekonzistentně.",
         "overloadWithoutImplementation": "„{name}“ je označen(é/o) jako přetížení, ale není zadaná žádná implementace",
         "overriddenMethodNotFound": "Metoda „{name}“ je označená jako přepsání, ale neexistuje žádná základní metoda se stejným názvem",
         "overrideDecoratorMissing": "Metoda „{name}“ není označená jako přepsání, ale přepisuje metodu ve třídě „{className}“",
@@ -375,6 +380,7 @@
         "protocolBaseClass": "Třída protokolu „{classType}“ se nemůže odvozovat od třídy,která není protokolem „{baseType}“",
         "protocolBaseClassWithTypeArgs": "Argumenty typu nejsou u třídy Protocol povoleny při použití syntaxe parametru typu",
         "protocolIllegal": "Použití protokolu vyžaduje Python 3.7 nebo novější",
+        "protocolNotAllowed": "„Protocol“ nejde v tomto kontextu použít.",
         "protocolVarianceContravariant": "Proměnná typu „{variable}“ použitá v obecném protokolu „{class}“ by měla být kontravariantní",
         "protocolVarianceCovariant": "Proměnná typu „{variable}“ použitá v obecném protokolu „{class}“ by měla být kovariantní",
         "protocolVarianceInvariant": "Proměnná typu „{variable}“ použitá v obecném protokolu „{class}“ by měla být invariantní",
@@ -441,6 +447,7 @@
         "typeAliasIsRecursiveDirect": "Alias typu „{name}“ nemůže ve své definici používat sám sebe",
         "typeAliasNotInModuleOrClass": "Typ TypeAlias je možné definovat pouze v rámci oboru modulu nebo třídy",
         "typeAliasRedeclared": "{name} se deklaruje jako TypAlias a dá se přiřadit jenom jednou",
+        "typeAliasStatementBadScope": "Příkaz type se dá použít jenom v rámci oboru modulu nebo třídy.",
         "typeAliasStatementIllegal": "Příkaz alias typu vyžaduje Python 3.12 nebo novější",
         "typeAliasTypeMustBeAssigned": "Typ TypeAliasType musí být přiřazen proměnné se stejným názvem jako alias typu",
         "typeAliasTypeNameArg": "První argument typeAliasType musí být řetězcový literál představující název aliasu typu",
@@ -517,8 +524,11 @@
         "typedDictEntryName": "Očekával se řetězcový literál pro název položky slovníku",
         "typedDictEntryUnique": "Názvy ve slovníku musí být jedinečné",
         "typedDictExtraArgs": "Nadbytečné argumenty TypedDict nejsou podporovány",
-        "typedDictFieldReadOnlyRedefinition": "Pole TypedDict {name} nejde předefinovat jako jen pro čtení",
+        "typedDictFieldNotRequiredRedefinition": "Pole TypedDict {name} nejde předefinovat jako NotRequired.",
+        "typedDictFieldReadOnlyRedefinition": "Pole TypedDict {name} nejde předefinovat jako ReadOnly.",
+        "typedDictFieldRequiredRedefinition": "Pole TypedDict {name} nejde předefinovat jako Required.",
         "typedDictFirstArg": "Jako první argument byl očekáván název třídy TypedDict",
+        "typedDictNotAllowed": "„TypedDict“ se v tomto kontextu nedá použít.",
         "typedDictSecondArgDict": "Jako druhý parametr se očekával parametr diktování nebo klíčového slova",
         "typedDictSecondArgDictEntry": "Očekávaná jednoduchá položka slovníku",
         "typedDictSet": "Nelze přiřadit položku v TypedDict",
@@ -613,13 +623,16 @@
         "functionReturnTypeMismatch": "Návratový typ funkce „{sourceType}“ není kompatibilní s typem „{destType}“",
         "functionTooFewParams": "Funkce přijímá příliš málo pozičních parametrů; očekávaný počet: {expected}, počet, který byl přijat: {received}",
         "functionTooManyParams": "Funkce přijímá příliš mnoho pozičních parametrů; očekávaný počet: {expected}, počet, který byl přijat: {received}",
+        "genericClassNotAllowed": "Obecný typ s argumenty obecného typu se pro kontroly instancí nebo tříd nepovoluje.",
         "incompatibleDeleter": "Metoda odstranění vlastnosti je nekompatibilní",
         "incompatibleGetter": "Metoda getter vlastnosti je nekompatibilní",
         "incompatibleSetter": "Metoda setter vlastnosti je nekompatibilní",
         "initMethodLocation": "Metoda __init__ je definována ve třídě {type}",
         "initMethodSignature": "Podpis __init__ je {type}",
+        "initSubclassLocation": "Metoda __init_subclass__ je definována ve třídě {name}.",
         "invariantSuggestionDict": "Zvažte přepnutí z „diktování“ na „mapování“, které je v typu hodnoty kovariantní",
         "invariantSuggestionList": "Zvažte přepnutí ze „seznamu“ na „sekvenci“, která je kovavariantní",
+        "invariantSuggestionSet": "Consider switching from \"set\" to \"Container\" which is covariant",
         "keyNotRequired": "„{name}! není v typu „{type}“ povinný klíč, takže přístup může vést k výjimce modulu runtime",
         "keyReadOnly": "{name} je klíč jen pro čtení v {type}",
         "keyRequiredDeleted": "{name} je povinný klíč a nedá se odstranit",
@@ -651,6 +664,7 @@
         "newMethodLocation": "Metoda __new__ je definována ve třídě {type}",
         "newMethodSignature": "Podpis __new__ je {type}",
         "noOverloadAssignable": "Typ {type} neodpovídá žádné přetížené funkci",
+        "noneNotAllowed": "Žádné se nedají použít pro kontroly instancí nebo tříd.",
         "orPatternMissingName": "Chybějící názvy: {name}",
         "overloadIndex": "Přetížení {index} je nejbližší shoda.",
         "overloadNotAssignable": "Nejméně jedno přetížení {name} není možné přiřadit",
@@ -670,7 +684,7 @@
         "overrideParamName": "Neshoda názvu parametru {index}: základní parametr má název „{baseName}“, parametr přepsání má název „{overrideName}“",
         "overrideParamNameExtra": "V základu chybí parametr {name}",
         "overrideParamNameMissing": "V přepsání chybí parametr „{name}“",
-        "overrideParamNamePositionOnly": "Neshoda parametru {index}: základní parametr {baseName} je parametr klíčového slova, přepisující parametr je pouze pozice",
+        "overrideParamNamePositionOnly": "Parameter {index} mismatch: base parameter \"{baseName}\" is keyword parameter, override parameter is position-only",
         "overrideParamNoDefault": "Neshoda parametru {index}: Základní parametr má výchozí hodnotu argumentu, parametr přepsání se neshoduje.",
         "overrideParamType": "Neshoda typu parametru {index}: Základní parametr je typu „{baseType}“, parametr přepsání je typu „{overrideType}“.",
         "overridePositionalParamCount": "Neshoda počtu pozičních parametrů; Základní metoda má „{baseCount}“, ale přepsání má {overrideCount}",
@@ -686,8 +700,8 @@
         "propertyMissingDeleter": "Vlastnost {name} nemá definovaný odstraňovač",
         "propertyMissingSetter": "Vlastnost {name} nemá definovanou metodu setter",
         "protocolIncompatible": "{sourceType} není kompatibilní s protokolem {destType}",
-        "protocolMemberClassVar": "{name} není proměnná třídy",
         "protocolMemberMissing": "{name} není k dispozici",
+        "protocolRequiresRuntimeCheckable": "Třída protokolu musí být @runtime_checkable, aby se použila při kontrolách instancí a tříd.",
         "protocolSourceIsNotConcrete": "„{sourceType}“ není konkrétní typ třídy a nedá se přiřadit k typu „{destType}“",
         "pyrightCommentIgnoreTip": "Pokud chcete potlačit diagnostiku pro jeden řádek, použijte # pyright: ignore[<diagnostic rules>]",
         "readOnlyAttribute": "Atribut {name} je jen pro čtení",
@@ -715,8 +729,9 @@
         "typeVarIsContravariant": "Parametr typu „{name}“ je kontravariantní, ale „{sourceType}“ není nadtyp „{destType}“.",
         "typeVarIsCovariant": "Parametr typu „{name}“ je kovariantní, ale „{sourceType}“ není podtyp „{destType}“.",
         "typeVarIsInvariant": "Parametr typu „{name}“ je invariantní, ale „{sourceType}“ není stejný jako „{destType}“.",
-        "typeVarNotAllowed": "TypeVar nebo obecný typ s argumenty typu není povolený",
+        "typeVarNotAllowed": "TypeVar se pro kontroly instancí nebo tříd nepovoluje.",
         "typeVarTupleRequiresKnownLength": "Typ TypeVarTuple nemůže být vázaný na řazenou kolekci členů neznámé délky",
+        "typeVarUnnecessarySuggestion": "Místo toho použijte {type}.",
         "typeVarUnsolvableRemedy": "Zadejte přetížení, které určuje návratový typ, pokud argument není zadán",
         "typeVarsMissing": "Chybějící proměnné typu: {names}",
         "typedDictBaseClass": "Třída „{type}“ není TypedDict.",

package/dist/localization/package.nls.de.json

@@ -69,6 +69,7 @@
         "classPatternBuiltInArgPositional": "Das Klassenmuster akzeptiert nur positionsbezogenes Untermuster.",
         "classPatternPositionalArgCount": "Zu viele Positionsmuster für Klasse \"{type}\". Erwartet: {expected}, empfangen: {received}.",
         "classPatternTypeAlias": "\"{type}\" kann nicht in einem Klassenmuster verwendet werden, da es sich um einen spezialisierten Typalias handelt.",
+        "classPropertyDeprecated": "Klasseneigenschaften sind in Python 3.11 veraltet und werden in Python 3.13 nicht unterstützt.",
         "classTypeParametersIllegal": "Die Syntax des Klassentypparameters erfordert Python 3.12 oder höher.",
         "classVarFirstArgMissing": "Nach \"ClassVar\" wurde ein Typargument erwartet.",
         "classVarNotAllowed": "\"ClassVar\" ist in diesem Kontext nicht zulässig.",
@@ -242,6 +243,7 @@
         "inconsistentIndent": "Der Betrag für Nichteinzug stimmt nicht mit dem vorherigen Einzug überein.",
         "inconsistentTabs": "Inkonsistente Verwendung von Tabulatoren und Leerzeichen im Einzug.",
         "initMustReturnNone": "Der Rückgabetyp von \"__init__\" muss \"None\" sein.",
+        "initSubclassCallFailed": "Falsche Schlüsselwortargumente für __init_subclass__ Methode.",
         "initSubclassClsParam": "__init_subclass__ Außerkraftsetzung sollte einen \"cls\"-Parameter annehmen.",
         "instanceMethodSelfParam": "Instanzmethoden sollten einen \"self\"-Parameter verwenden.",
         "instanceVarOverridesClassVar": "Die Instanzvariable \"{name}\" überschreibt die Klassenvariable desselben Namens in der Klasse \"{className}\"",
@@ -265,6 +267,7 @@
         "listAssignmentMismatch": "Ein Ausdruck vom Typ \"{type}\" kann der Zielliste nicht zugewiesen werden.",
         "listInAnnotation": "Ein Listenausdruck ist in der Typanmerkung nicht zulässig.",
         "literalEmptyArgs": "Nach \"Literal\" wurde mindestens ein Typargument erwartet.",
+        "literalNotAllowed": "\"Literal\" kann in diesem Kontext nicht ohne Typargument verwendet werden.",
         "literalNotCallable": "Der Literaltyp kann nicht instanziiert werden.",
         "literalUnsupportedType": "Typargumente für \"Literal\" müssen None, ein Literalwert (int, bool, str oder bytes) oder ein Enumerationswert sein.",
         "matchIncompatible": "Übereinstimmungsanweisungen erfordern Python 3.10 oder höher",
@@ -333,8 +336,10 @@
         "overlappingKeywordArgs": "Typisierte Wörterbuchüberlappungen mit Schlüsselwortparameter: {names}",
         "overlappingOverload": "Überladung {obscured} für \"{name}\" wird nie verwendet, da sich die Parameter überlappen, {obscuredBy}",
         "overloadAbstractMismatch": "Überladene Methoden müssen alle abstrakt sein oder nicht.",
+        "overloadClassMethodInconsistent": "Überladungen für \"{name}\" verwenden @classmethod inkonsistent",
         "overloadImplementationMismatch": "Die überladene Implementierung ist nicht konsistent mit der Signatur der Überladung {index}",
         "overloadReturnTypeMismatch": "Überladung {prevIndex} für \"{name}\" überlappt {newIndex} und gibt einen inkompatiblen Typ zurück.",
+        "overloadStaticMethodInconsistent": "Überladungen für \"{name}\" verwenden @staticmethod inkonsistent",
         "overloadWithoutImplementation": "\"{name}\" ist als Überladen markiert, es wurde jedoch keine Implementierung bereitgestellt.",
         "overriddenMethodNotFound": "Die Methode \"{name}\" ist als Überschreibung markiert, aber es ist keine Basismethode mit demselben Namen vorhanden.",
         "overrideDecoratorMissing": "Die Methode \"{name}\" ist nicht als Überschreibung markiert, überschreibt jedoch eine Methode in der Klasse \"{className}\"",
@@ -375,6 +380,7 @@
         "protocolBaseClass": "Die Protokollklasse \"{classType}\" kann nicht von einer Nichtprotokollklasse \"{baseType}\" abgeleitet werden",
         "protocolBaseClassWithTypeArgs": "Typargumente sind mit der Protokollklasse nicht zulässig, wenn die Typparametersyntax verwendet wird.",
         "protocolIllegal": "Die Verwendung von \"Protocol\" erfordert Python 3.7 oder höher.",
+        "protocolNotAllowed": "\"Protocol\" kann in diesem Kontext nicht verwendet werden.",
         "protocolVarianceContravariant": "Die Typvariable \"{variable}\", die im generischen Protokoll \"{class}\" verwendet wird, muss \"contravariant\" sein.",
         "protocolVarianceCovariant": "Die Typvariable \"{variable}\", die im generischen Protokoll \"{class}\" verwendet wird, muss \"covariant\" sein.",
         "protocolVarianceInvariant": "Die Typvariable \"{variable}\", die im generischen Protokoll \"{class}\" verwendet wird, muss \"invariant\" sein.",
@@ -441,6 +447,7 @@
         "typeAliasIsRecursiveDirect": "Der Typalias \"{name}\" kann sich nicht selbst in seiner Definition verwenden.",
         "typeAliasNotInModuleOrClass": "TypeAlias kann nur innerhalb eines Moduls oder Klassenbereichs definiert werden.",
         "typeAliasRedeclared": "\"{name}\" ist als TypeAlias deklariert und kann nur einmal zugewiesen werden.",
+        "typeAliasStatementBadScope": "Eine Typanweisung kann nur innerhalb eines Moduls oder Klassenbereichs verwendet werden.",
         "typeAliasStatementIllegal": "Die Typaliasanweisung erfordert Python 3.12 oder höher.",
         "typeAliasTypeMustBeAssigned": "TypeAliasType muss einer Variablen mit dem gleichen Namen wie der Typalias zugewiesen werden.",
         "typeAliasTypeNameArg": "Das erste Argument für TypeAliasType muss ein Zeichenfolgenliteral sein, das den Namen des Typalias darstellt.",
@@ -517,8 +524,11 @@
         "typedDictEntryName": "Für den Wörterbucheintragsnamen wurde ein Zeichenfolgenliteral erwartet.",
         "typedDictEntryUnique": "Namen innerhalb eines Wörterbuchs müssen eindeutig sein.",
         "typedDictExtraArgs": "Zusätzliche TypedDict-Argumente werden nicht unterstützt.",
-        "typedDictFieldReadOnlyRedefinition": "Das TypedDict-Feld \"{name}\" kann nicht als schreibgeschützt neu definiert werden.",
+        "typedDictFieldNotRequiredRedefinition": "Das TypedDict-Feld \"{name}\" kann nicht als nicht erforderlich neu definiert werden",
+        "typedDictFieldReadOnlyRedefinition": "Das TypedDict-Feld \"{name}\" kann nicht als schreibgeschützt neu definiert werden",
+        "typedDictFieldRequiredRedefinition": "Das TypedDict-Feld \"{name}\" kann nicht als erforderlich neu definiert werden",
         "typedDictFirstArg": "Der Klassenname \"TypedDict\" wird als erstes Argument erwartet.",
+        "typedDictNotAllowed": "\"TypedDict\" kann in diesem Kontext nicht verwendet werden.",
         "typedDictSecondArgDict": "Es wird ein dict- oder Schlüsselwortparameter als zweiter Parameter erwartet.",
         "typedDictSecondArgDictEntry": "Einfacher Wörterbucheintrag erwartet",
         "typedDictSet": "Element konnte in TypedDict nicht zugewiesen werden.",
@@ -613,13 +623,16 @@
         "functionReturnTypeMismatch": "Der Funktionsrückgabetyp \"{sourceType}\" ist nicht mit dem Typ \"{destType}\" kompatibel.",
         "functionTooFewParams": "Die Funktion akzeptiert zu wenige Positionsparameter; {expected} erwartet, aber {received} empfangen",
         "functionTooManyParams": "Die Funktion akzeptiert zu viele Positionsparameter; {expected} erwartet, aber {received} empfangen",
+        "genericClassNotAllowed": "Ein generischer Typ mit Typargumenten ist für Instanz- oder Klassenprüfungen nicht zulässig.",
         "incompatibleDeleter": "Die Deletermethode der Eigenschaft ist nicht kompatibel.",
         "incompatibleGetter": "Die Gettermethode der Eigenschaft ist nicht kompatibel.",
         "incompatibleSetter": "Die Settermethode der Eigenschaft ist nicht kompatibel.",
         "initMethodLocation": "Die __init__ Methode ist in der Klasse \"{type}\" definiert.",
         "initMethodSignature": "Die Signatur von __init__ ist \"{type}\".",
+        "initSubclassLocation": "Die __init_subclass__ Methode ist in der Klasse \"{name}\" definiert.",
         "invariantSuggestionDict": "Erwägen Sie den Wechsel von \"dict\" zu \"Mapping\" (im Werttyp covariant).",
         "invariantSuggestionList": "Erwägen Sie den Wechsel von \"list\" zu \"Sequence\" (covariant).",
+        "invariantSuggestionSet": "Consider switching from \"set\" to \"Container\" which is covariant",
         "keyNotRequired": "\"{name}\" ist kein erforderlicher Schlüssel in \"{type}\". Der Zugriff kann daher zu einer Laufzeitausnahme führen.",
         "keyReadOnly": "\"{name}\" ist ein schreibgeschützter Schlüssel in \"{type}\"",
         "keyRequiredDeleted": "\"{name}\" ist ein erforderlicher Schlüssel und kann nicht gelöscht werden.",
@@ -651,6 +664,7 @@
         "newMethodLocation": "Die __new__ Methode ist in der Klasse \"{type}\" definiert.",
         "newMethodSignature": "Signatur von __new__ ist \"{type}\"",
         "noOverloadAssignable": "Keine überladene Funktion stimmt mit dem Typ \"{type}\" überein.",
+        "noneNotAllowed": "\"None\" kann nicht für Instanz- oder Klassenprüfungen verwendet werden.",
         "orPatternMissingName": "Fehlende Namen: {name}",
         "overloadIndex": "Überladung \"{index}\" ist die nächste Übereinstimmung.",
         "overloadNotAssignable": "Mindestens eine Überladung von \"{name}\" kann nicht zugewiesen werden.",
@@ -670,7 +684,7 @@
         "overrideParamName": "Namenskonflikt mit Parameter {index}: Der Basisparameter hat den Namen \"{baseName}\", der Außerkraftsetzungsparameter ist \"{overrideName}\"",
         "overrideParamNameExtra": "Der Parameter \"{name}\" fehlt in der Basis.",
         "overrideParamNameMissing": "Der Parameter \"{name}\" fehlt in der Außerkraftsetzung.",
-        "overrideParamNamePositionOnly": "Parameter \"{index}\" stimmt nicht überein: Basisparameter \"{baseName}\" ist Schlüsselwortparameter, Außerkraftsetzungsparameter ist \"position-only\".",
+        "overrideParamNamePositionOnly": "Parameter {index} mismatch: base parameter \"{baseName}\" is keyword parameter, override parameter is position-only",
         "overrideParamNoDefault": "Konflikt mit Parameter {index}: Der Basisparameter hat einen Standardargumentwert, der Außerkraftsetzungsparameter ist nicht identisch.",
         "overrideParamType": "Parameter {index} Typenkonflikt: Basisparameter ist Typ \"{baseType}\", Überschreibungsparameter ist Typ \"{overrideType}\"",
         "overridePositionalParamCount": "Anzahl der Positionsparameter stimmt nicht überein; die Basismethode hat {baseCount}, aber die Überschreibung hat {overrideCount}",
@@ -686,8 +700,8 @@
         "propertyMissingDeleter": "Die Eigenschaft \"{name}\" hat keinen definierten Deleter.",
         "propertyMissingSetter": "Die Eigenschaft \"{name}\" hat keinen definierten Setter.",
         "protocolIncompatible": "\"{sourceType}\" ist nicht mit dem Protokoll \"{destType}\" kompatibel.",
-        "protocolMemberClassVar": "\"{name}\" ist keine Klassenvariable.",
         "protocolMemberMissing": "\"{name}\" ist nicht vorhanden.",
+        "protocolRequiresRuntimeCheckable": "Die Protokollklasse muss @runtime_checkable sein, damit sie mit Instanz- und Klassenprüfungen verwendet werden kann.",
         "protocolSourceIsNotConcrete": "\"{sourceType}\" ist kein konkreter Klassentyp und kann dem Typ \"{destType}\" nicht zugewiesen werden.",
         "pyrightCommentIgnoreTip": "Verwenden Sie \"# pyright: ignore[<diagnostic rules>]\", um die Diagnose für eine einzelne Zeile zu unterdrücken.",
         "readOnlyAttribute": "Das Attribut \"{name}\" ist schreibgeschützt.",
@@ -715,8 +729,9 @@
         "typeVarIsContravariant": "Der Typparameter \"{name}\" ist kontravariant, aber \"{sourceType}\" ist kein Supertyp von \"{destType}\"",
         "typeVarIsCovariant": "Der Typparameter \"{name}\" ist kovariant, aber \"{sourceType}\" ist kein Untertyp von \"{destType}\"",
         "typeVarIsInvariant": "Der Typparameter \"{name}\" ist invariant, \"{sourceType}\" ist jedoch nicht identisch mit \"{destType}\"",
-        "typeVarNotAllowed": "TypeVar oder generischer Typ mit Typargumenten sind nicht zulässig.",
+        "typeVarNotAllowed": "TypeVar ist für Instanz- oder Klassenprüfungen nicht zulässig.",
         "typeVarTupleRequiresKnownLength": "TypeVarTuple kann nicht an ein Tupel unbekannter Länge gebunden werden.",
+        "typeVarUnnecessarySuggestion": "Stattdessen {type} verwenden",
         "typeVarUnsolvableRemedy": "Geben Sie eine Überladung an, die den Rückgabetyp angibt, wenn das Argument nicht angegeben ist.",
         "typeVarsMissing": "Fehlende Typvariablen: {names}",
         "typedDictBaseClass": "Die Klasse \"{type}\" ist kein TypedDict.",

package/dist/localization/package.nls.en-us.json

@@ -1,6 +1,6 @@
 {
     "Diagnostic": {
-        "abstractMethodInvocation": "Method \"{method}\" cannot be called because it is abstract",
+        "abstractMethodInvocation": "Method \"{method}\" cannot be called because it is abstract and unimplemented",
         "annotatedParamCountMismatch": "Parameter annotation count mismatch: expected {expected} but received {received}",
         "annotatedTypeArgMissing": "Expected one type argument and one or more annotations for \"Annotated\"",
         "annotationFormatString": "Type annotations cannot use format string literals (f-strings)",
@@ -71,6 +71,7 @@
         "comparisonAlwaysTrue": "Condition will always evaluate to True since the types \"{leftType}\" and \"{rightType}\" have no overlap",
         "comprehensionInDict": "Comprehension cannot be used with other dictionary entries",
         "comprehensionInSet": "Comprehension cannot be used with other set entries",
+        "concatenateContext": "\"Concatenate\" is not allowed in this context",
         "concatenateParamSpecMissing": "Last type argument for \"Concatenate\" must be a ParamSpec or \"...\"",
         "concatenateTypeArgsMissing": "\"Concatenate\" requires at least two type arguments",
         "conditionalOperandInvalid": "Invalid conditional operand of type \"{type}\"",
@@ -96,6 +97,7 @@
         "dataClassTransformFieldSpecifier": "Expected tuple of classes or functions but received type \"{type}\"",
         "dataClassTransformPositionalParam": "All arguments to \"dataclass_transform\" must be keyword arguments",
         "dataClassTransformUnknownArgument": "Argument \"{name}\" is not supported by dataclass_transform",
+        "dataProtocolInSubclassCheck": "Data protocols (which include non-method attributes) are not allowed in issubclass calls",
         "declaredReturnTypePartiallyUnknown": "Declared return type, \"{returnType}\", is partially unknown",
         "declaredReturnTypeUnknown": "Declared return type is unknown",
         "defaultValueContainsCall": "Function calls and mutable objects not allowed within parameter default value expression",
@@ -293,7 +295,6 @@
         "newTypeBadName": "The first argument to NewType must be a string literal",
         "newTypeLiteral": "NewType cannot be used with Literal type",
         "newTypeNameMismatch": "NewType must be assigned to a variable with the same name",
-        "newTypeNewTypeClass": "NewType cannot be used with a class created with NewType",
         "newTypeNotAClass": "Expected class as second argument to NewType",
         "newTypeParamCount": "NewType requires two positional arguments",
         "newTypeProtocolClass": "NewType cannot be used with structural type (a protocol or TypedDict class)",
@@ -329,6 +330,8 @@
         "overlappingOverload": "Overload {obscured} for \"{name}\" will never be used because its parameters overlap overload {obscuredBy}",
         "overloadAbstractMismatch": "Overloaded methods must all be abstract or not",
         "overloadClassMethodInconsistent": "Overloads for \"{name}\" use @classmethod inconsistently",
+        "overloadFinalInconsistencyImpl": "Overload for \"{name}\" is marked @final but implementation is not",
+        "overloadFinalInconsistencyNoImpl": "Overload {index} for \"{name}\" is marked @final but overload 1 is not",
         "overloadImplementationMismatch": "Overloaded implementation is not consistent with signature of overload {index}",
         "overloadReturnTypeMismatch": "Overload {prevIndex} for \"{name}\" overlaps overload {newIndex} and returns an incompatible type",
         "overloadStaticMethodInconsistent": "Overloads for \"{name}\" use @staticmethod inconsistently",
@@ -373,6 +376,7 @@
         "protocolBaseClassWithTypeArgs": "Type arguments are not allowed with Protocol class when using type parameter syntax",
         "protocolIllegal": "Use of \"Protocol\" requires Python 3.7 or newer",
         "protocolNotAllowed": "\"Protocol\" cannot be used in this context",
+        "protocolUnsafeOverlap": "Class overlaps \"{name}\" unsafely and could produce a match at runtime",
         "protocolVarianceContravariant": "Type variable \"{variable}\" used in generic protocol \"{class}\" should be contravariant",
         "protocolVarianceCovariant": "Type variable \"{variable}\" used in generic protocol \"{class}\" should be covariant",
         "protocolVarianceInvariant": "Type variable \"{variable}\" used in generic protocol \"{class}\" should be invariant",
@@ -443,6 +447,7 @@
         "typeAliasRedeclared": "\"{name}\" is declared as a TypeAlias and can be assigned only once",
         "typeAliasStatementIllegal": "Type alias statement requires Python 3.12 or newer",
         "typeAliasStatementBadScope": "A type statement can be used only within a module or class scope",
+        "typeAliasTypeBaseClass": "A type alias defined in a \"type\" statement cannot be used as a base class",
         "typeAliasTypeMustBeAssigned": "TypeAliasType must be assigned to a variable with the same name as the type alias",
         "typeAliasTypeNameArg": "First argument to TypeAliasType must be a string literal representing the name of the type alias",
         "typeAliasTypeNameMismatch": "Name of type alias must match the name of the variable to which it is assigned",
@@ -522,6 +527,7 @@
         "typeVarTupleContext": "TypeVarTuple is not allowed in this context",
         "typeVarTupleDefaultNotUnpacked": "TypeVarTuple default type must be an unpacked tuple or TypeVarTuple",
         "typeVarTupleMustBeUnpacked": "Unpack operator is required for TypeVarTuple value",
+        "typeVarTupleConstraints": "TypeVarTuple cannot have value constraints",
         "typeVarTupleUnknownParam": "\"{name}\" is unknown parameter to TypeVarTuple",
         "typeVarUnknownParam": "\"{name}\" is unknown parameter to TypeVar",
         "typeVarUsedByOuterScope": "TypeVar \"{name}\" is already in use by an outer scope",
@@ -546,6 +552,8 @@
         "unionTypeArgCount": "Union requires two or more type arguments",
         "uninitializedAbstractVariables": "Variables defined in abstract base class are not initialized in final class \"{classType}\"",
         "uninitializedInstanceVariable": "Instance variable \"{name}\" is not initialized in the class body or __init__ method",
+        "unionUnpackedTuple": "Union cannot include an unpacked tuple",
+        "unionUnpackedTypeVarTuple": "Union cannot include an unpacked TypeVarTuple",
         "unmatchedEndregionComment": "#endregion is missing corresponding #region",
         "unmatchedRegionComment": "#region is missing corresponding #endregion",
         "unnecessaryCast": "Unnecessary \"cast\" call; type is already \"{type}\"",
@@ -611,6 +619,7 @@
         "bytesTypePromotions": "Set disableBytesTypePromotions to false to enable type promotion behavior for \"bytearray\" and \"memoryview\"",
         "conditionalRequiresBool": "Method __bool__ for type \"{operandType}\" returns type \"{boolReturnType}\" rather than \"bool\"",
         "dataClassFieldLocation": "Field declaration",
+        "dataProtocolUnsupported": "\"{name}\" is a data protocol",
         "descriptorAccessBindingFailed": "Failed to bind method \"{name}\" for descriptor class \"{className}\"",
         "descriptorAccessCallFailed": "Failed to call method \"{name}\" for descriptor class \"{className}\"",
         "dataClassFrozen": "\"{name}\" is frozen",
@@ -644,9 +653,12 @@
         "memberAssignment": "Expression of type \"{type}\" cannot be assigned to member \"{name}\" of class \"{classType}\"",
         "memberIsAbstract": "\"{type}.{name}\" is abstract",
         "memberIsAbstractMore": "and {count} more...",
+        "memberIsClassVarInProtocol": "\"{name}\" is defined as a ClassVar in protocol",
         "memberIsFinalInProtocol": "\"{name}\" is marked Final in protocol",
         "memberIsInitVar": "Member \"{name}\" is an init-only field",
         "memberIsInvariant": "\"{name}\" is invariant because it is mutable",
+        "memberIsNotClassVarInClass": "\"{name}\" must be defined as a ClassVar to be compatible with protocol",
+        "memberIsNotClassVarInProtocol": "\"{name}\" is not defined as a ClassVar in protocol",
         "memberIsNotFinalInProtocol": "\"{name}\" is not marked Final in protocol",
         "memberIsWritableInProtocol": "\"{name}\" is writable in protocol",
         "memberTypeMismatch": "\"{name}\" is an incompatible type",
@@ -699,10 +711,10 @@
         "propertyMissingDeleter": "Property \"{name}\" has no defined deleter",
         "propertyMissingSetter": "Property \"{name}\" has no defined setter",
         "protocolIncompatible": "\"{sourceType}\" is incompatible with protocol \"{destType}\"",
-        "protocolMemberClassVar": "\"{name}\" is not a class variable",
         "protocolMemberMissing": "\"{name}\" is not present",
         "protocolRequiresRuntimeCheckable": "Protocol class must be @runtime_checkable to be used with instance and class checks",
         "protocolSourceIsNotConcrete": "\"{sourceType}\" is not a concrete class type and cannot be assigned to type \"{destType}\"",
+        "protocolUnsafeOverlap": "Attributes of \"{name}\" have the same names as the protocol",
         "pyrightCommentIgnoreTip": "Use \"# pyright: ignore[<diagnostic rules>] to suppress diagnostics for a single line",
         "readOnlyAttribute": "Attribute \"{name}\" is read-only",
         "seeDeclaration": "See declaration",
@@ -716,6 +728,7 @@
         "tupleAssignmentMismatch": "Type \"{type}\" is incompatible with target tuple",
         "tupleSizeIndeterminate": "Tuple size mismatch; expected {expected} but received indeterminate",
         "tupleSizeMismatch": "Tuple size mismatch; expected {expected} but received {received}",
+        "typeAliasInstanceCheck": "Type alias created with \"type\" statement cannot be used with instance and class checks",
         "typeAssignmentMismatch": "Type \"{sourceType}\" cannot be assigned to type \"{destType}\"",
         "typeBound": "Type \"{sourceType}\" is incompatible with bound type \"{destType}\" for type variable \"{name}\"",
         "typeConstrainedTypeVar": "Type \"{type}\" is incompatible with constrained type variable \"{name}\"",

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

@@ -69,6 +69,7 @@
         "classPatternBuiltInArgPositional": "El patrón de clase solo acepta subpatrones posicionales",
         "classPatternPositionalArgCount": "Demasiados patrones posicionales para la clase \"{type}\"; esperado {expected} pero recibido {received}",
         "classPatternTypeAlias": "\"{type}\" no se puede usar en un patrón de clase porque es un alias de tipo especializado",
+        "classPropertyDeprecated": "Las propiedades de clase están en desuso en Python 3.11 y no se admitirán en Python 3.13.",
         "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",
@@ -242,6 +243,7 @@
         "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",
+        "initSubclassCallFailed": "Argumentos de palabra clave incorrectos para el método __init_subclass__",
         "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}\"",
@@ -265,6 +267,7 @@
         "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\"",
+        "literalNotAllowed": "\"Literal\" no se puede usar en este contexto sin un argumento de tipo",
         "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",
@@ -333,8 +336,10 @@
         "overlappingKeywordArgs": "El diccionario escrito se superpone con el parámetro de palabra clave: {names}",
         "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",
+        "overloadClassMethodInconsistent": "Las sobrecargas de \"{name}\" usan @classmethod de forma incoherente",
         "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",
+        "overloadStaticMethodInconsistent": "Las sobrecargas de \"{name}\" usan @staticmethod de forma incoherente",
         "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}\"",
@@ -375,6 +380,7 @@
         "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.",
+        "protocolNotAllowed": "\"Protocolo\" no puede utilizarse en este contexto",
         "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.",
@@ -441,6 +447,7 @@
         "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",
+        "typeAliasStatementBadScope": "Una instrucción de tipo solo se puede usar en el ámbito de un módulo o de una clase",
         "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",
@@ -517,8 +524,11 @@
         "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",
+        "typedDictFieldNotRequiredRedefinition": "El campo TypedDict \"{name}\" no puede redefinirse como NotRequired",
+        "typedDictFieldReadOnlyRedefinition": "El campo TypedDict \"{name}\" no puede redefinirse como ReadOnly",
+        "typedDictFieldRequiredRedefinition": "El campo TypedDict \"{name}\" no puede redefinirse como Required",
         "typedDictFirstArg": "Nombre de clase TypedDict esperado como primer argumento",
+        "typedDictNotAllowed": "\"TypedDict\" no puede utilizarse en este contexto",
         "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",
@@ -613,13 +623,16 @@
         "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}",
+        "genericClassNotAllowed": "Tipo genérico con argumentos de tipo no permitidos para comprobaciones de instancia o clase",
         "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}\"",
+        "initSubclassLocation": "El método __init_subclass__ se define en la clase \"{name}\"",
         "invariantSuggestionDict": "Considere cambiar de \"predicción\" a \" Asignación\" que es covariante en el tipo de valor",
         "invariantSuggestionList": "Considere la posibilidad de cambiar de \"lista\" a \"Secuencia\" que es covariante",
+        "invariantSuggestionSet": "Consider switching from \"set\" to \"Container\" which is covariant",
         "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",
@@ -651,6 +664,7 @@
         "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}\"",
+        "noneNotAllowed": "No se puede usar ninguno para comprobaciones de instancia o clase",
         "orPatternMissingName": "Nombres que faltan: {name}",
         "overloadIndex": "La sobrecarga {index} es la coincidencia más cercana",
         "overloadNotAssignable": "Una o más sobrecargas de \"{name}\" no es asignable",
@@ -670,7 +684,7 @@
         "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 parámetro {index} no coincide: el parámetro base \"{baseName}\" es un parámetro de palabra clave, el parámetro de anulación es \"position-only\".",
+        "overrideParamNamePositionOnly": "Parameter {index} mismatch: base parameter \"{baseName}\" is keyword parameter, override parameter is 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}",
@@ -686,8 +700,8 @@
         "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.",
+        "protocolRequiresRuntimeCheckable": "La clase de protocolo debe ser @runtime_checkable para usarse con comprobaciones de instancia y clase",
         "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",
@@ -715,8 +729,9 @@
         "typeVarIsContravariant": "El parámetro de tipo \"{name}\" es contravariante, pero \"{sourceType}\" no es un supertipo de \"{destType}\"",
         "typeVarIsCovariant": "El parámetro de tipo \"{name}\" es covariante, pero \"{sourceType}\" no es un subtipo de \"{destType}\"",
         "typeVarIsInvariant": "El parámetro de tipo \"{name}\" es invariable, pero \"{sourceType}\" no es el mismo que \"{destType}\"",
-        "typeVarNotAllowed": "TypeVar o tipo genérico con argumentos de tipo no permitidos",
+        "typeVarNotAllowed": "TypeVar no se permite para comprobaciones de instancia o clase",
         "typeVarTupleRequiresKnownLength": "TypeVarTuple no se puede enlazar a una tupla de longitud desconocida",
+        "typeVarUnnecessarySuggestion": "Usar {type} en su lugar",
         "typeVarUnsolvableRemedy": "Proporciona una sobrecarga que especifica el tipo de retorno cuando no se proporciona el argumento",
         "typeVarsMissing": "Faltan variables de tipo: {names}",
         "typedDictBaseClass": "La clase “{type}” no es un TypeDict",