@zzzen/pyright-internal 1.2.0-dev.20240107 → 1.2.0-dev.20240121

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

@@ -14,7 +14,7 @@
         "indexValueDetail": "Hodnota indexu"
     },
     "Diagnostic": {
-        "abstractMethodInvocation": "Metodu {method} není možné volat, protože je abstraktní",
+        "abstractMethodInvocation": "Metodu „{method}“ nelze volat, protože je abstraktní a neimplementovaná.",
         "annotatedParamCountMismatch": "Počet poznámek parametrů se neshoduje: očekával(o/y) se {expected}, ale přijal(o/y) se {received}.",
         "annotatedTypeArgMissing": "Byl očekáván jeden argument typu a jedna nebo více poznámek pro Annotated",
         "annotationFormatString": "Poznámky typu nemůžou používat formátovací řetězcové literály (f-strings)",
@@ -44,6 +44,7 @@
         "assignmentTargetExpr": "Výraz nemůže být cílem přiřazení",
         "asyncNotInAsyncFunction": "Použití „async“ není povolené mimo funkci async",
         "awaitIllegal": "Použití operátoru await vyžaduje Python 3.5 nebo novější",
+        "awaitNotAllowed": "Poznámky typu nemůžou používat „await“.",
         "awaitNotInAsync": "Operátor await je povolený jenom v rámci asynchronní funkce",
         "backticksIllegal": "V Pythonu 3.x nejsou podporovány výrazy obklopené zpětnými tečkami; místo toho použijte repr",
         "baseClassCircular": "Třída se nemůže odvozovat od sebe sama",
@@ -53,6 +54,7 @@
         "baseClassMethodTypeIncompatible": "Základní třídy pro třídu {classType} definují metodu {name} nekompatibilním způsobem",
         "baseClassUnknown": "Typ základní třídy je neznámý, co zakrývá typ odvozené třídy",
         "baseClassVariableTypeIncompatible": "Základní třídy pro třídu {classType} definují proměnnou {name} nekompatibilním způsobem",
+        "binaryOperationNotAllowed": "Binární operátor není v poznámce typu povolený",
         "bindTypeMismatch": "Nepovedlo se vytvořit vazbu metody „{methodName}“, protože „{type}“ nejde přiřadit k parametru „{paramName}“",
         "breakOutsideLoop": "„break“ se dá použít jenom ve smyčce",
         "callableExtraArgs": "Pro Callable se očekávaly pouze dva argumenty typu",
@@ -69,6 +71,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",
@@ -82,6 +85,7 @@
         "comparisonAlwaysTrue": "Podmínka se vždy vyhodnotí jako True, protože typy {leftType} a {rightType} se nepřekrývají",
         "comprehensionInDict": "Porozumění není možné použít s jinými položkami slovníku",
         "comprehensionInSet": "Porozumění nelze použít s jinými položkami sady",
+        "concatenateContext": "Možnost „Concatenate“ není v tomto kontextu povolená.",
         "concatenateParamSpecMissing": "Poslední argument typu pro „Concatenate“ musí být „ParamSpec“ nebo „...“",
         "concatenateTypeArgsMissing": "Možnost „Concatenate“ vyžaduje alespoň dva argumenty typu",
         "conditionalOperandInvalid": "Neplatný podmíněný operand typu {type}",
@@ -107,6 +111,7 @@
         "dataClassTransformFieldSpecifier": "Očekávala se řazená kolekce členů tříd nebo funkcí, ale přijatý typ „{type}“",
         "dataClassTransformPositionalParam": "Všechny argumenty dataclass_transform musí být argumenty klíčových slov",
         "dataClassTransformUnknownArgument": "Argument {name} není v dataclass_transform podporován",
+        "dataProtocolInSubclassCheck": "Datové protokoly (které zahrnují atributy bez metody) nejsou ve voláních issubclass povolené.",
         "declaredReturnTypePartiallyUnknown": "Deklarovaný návratový typ {returnType} je částečně neznámý",
         "declaredReturnTypeUnknown": "Deklarovaný návratový typ je neznámý",
         "defaultValueContainsCall": "Volání funkcí a měnitelné objekty nejsou povoleny ve výrazu výchozí hodnoty parametru",
@@ -196,9 +201,10 @@
         "expectedTypeNotString": "Očekával se typ, ale přijal se řetězcový literál",
         "expectedTypeParameterName": "Očekávaný název parametru typu",
         "expectedYieldExpr": "Očekávaný výraz v příkazu yield",
-        "finalClassIsAbstract": "Třída {type} je označená jako konečná a musí implementovat všechny abstraktní metody",
+        "finalClassIsAbstract": "Class \"{type}\" is marked final and must implement all abstract symbols",
         "finalContext": "Final se v tomto kontextu nepovoluje",
         "finalMethodOverride": "Metoda {name} nemůže přepsat konečnou metodu definovanou ve třídě {className}",
+        "finalNonMethod": "Funkci „{name}“ nelze označit @final, protože se nejedná o metodu.",
         "finalReassigned": "„{name}“ se deklaruje jako Final a nedá se znovu přiřadit",
         "finalRedeclaration": "{name} se dříve deklarovalo jako Final",
         "finalRedeclarationBySubclass": "{name} se nedá deklarovat znovu, protože nadřazená třída {className} ji deklaruje jako final",
@@ -242,6 +248,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 +272,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ší",
@@ -281,7 +289,6 @@
         "methodOrdering": "Není možné vytvořit konzistentní řazení metod",
         "methodOverridden": "„{name}“ přepisuje metodu se stejným názvem ve třídě „{className}“ s nekompatibilním typem {type}",
         "methodReturnsNonObject": "Metoda {name} nevrací objekt",
-        "missingProtocolMembers": "Třída je odvozena od jedné nebo více tříd protokolu, ale neimplementuje všechny požadované členy",
         "missingSuperCall": "Metoda {methodName} nevolá metodu se stejným názvem v nadřazené třídě",
         "moduleAsType": "Modul nejde použít jako typ",
         "moduleNotCallable": "Modul není volatelný",
@@ -297,11 +304,13 @@
         "namedTupleNoTypes": "namedtuple neposkytuje žádné typy pro položky řazené kolekce členů; místo toho použijte NamedTuple",
         "namedTupleSecondArg": "Jako druhý argument byl očekáván pojmenovaný seznam řazené kolekce členů",
         "newClsParam": "Přepsání __new__ by mělo mít parametr cls",
+        "newTypeAnyOrUnknown": "Druhý argument pro NewType musí být známá třída, nikoli Any nebo Unknown.",
         "newTypeBadName": "Prvním argumentem pro NewType musí být řetězcový literál",
         "newTypeLiteral": "Typ NewType není možné použít s typem Literal",
+        "newTypeNameMismatch": "Typ NewType musí být přiřazen proměnné se stejným názvem.",
         "newTypeNotAClass": "Očekávaná třída jako druhý argument pro NewType",
         "newTypeParamCount": "NewType vyžaduje dva poziční argumenty",
-        "newTypeProtocolClass": "NewType neí možné použít s třídou protokolu",
+        "newTypeProtocolClass": "NewType nelze použít se strukturálním typem (protokol nebo třída TypedDict).",
         "noOverload": "Zadaným argumentům neodpovídají žádná přetížení pro {name}",
         "noReturnContainsReturn": "Funkce s deklarovaným návratovým typem NoReturn nemůže obsahovat příkaz return",
         "noReturnContainsYield": "Funkce s deklarovaným návratovým typem NoReturn nemůže obsahovat příkaz yield",
@@ -333,8 +342,12 @@
         "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ě.",
+        "overloadFinalInconsistencyImpl": "Přetížení pro „{name}“ je označené @final ale implementace není",
+        "overloadFinalInconsistencyNoImpl": "Přetížení {index} pro „{name}“ je označené @final ale přetížení 1 není",
         "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 +388,8 @@
         "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.",
+        "protocolUnsafeOverlap": "Třída se nebezpečně překrývá s názvem „{name}“ a může vytvořit shodu při spuštění.",
         "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í",
@@ -405,6 +420,7 @@
         "revealTypeExpectedTextMismatch": "Neshoda typu textu; očekávaný počet: {expected}, počet, který byl přijat: {received}",
         "revealTypeExpectedTypeMismatch": "Neshoda typů; Očekával(o/y) se „{expected}“, ale přijal(o/y) se „{received}“",
         "selfTypeContext": "Self není v tomto kontextu platné",
+        "selfTypeMetaclass": "„Self“ nelze použít v rámci metatřídy (podtřídy „type“).",
         "selfTypeWithTypedSelfOrCls": "Self není možné použít ve funkci s parametrem self nebo cls, která má jinou poznámku typu než Self",
         "setterGetterTypeMismatch": "Typ hodnoty metody setter vlastnosti není možné přiřadit návratového typu getter",
         "singleOverload": "{name} je označené jako přetížení, ale chybí další přetížení",
@@ -431,6 +447,7 @@
         "symbolIsUnbound": "Název {name} je nevázaný",
         "symbolIsUndefined": "{name} není definované",
         "symbolOverridden": "{name} přepíše symbol stejného názvu ve třídě {className}",
+        "ternaryNotAllowed": "Výraz ternary není v poznámce typu povolený.",
         "totalOrderingMissingMethod": "Třída musí definovat jednu z __lt__, __le__, __gt__ nebo __ge__, aby bylo možné používat total_ordering",
         "trailingCommaInFromImport": "Koncová čárka není povolena bez okolních závorek",
         "tryWithoutExcept": "Příkaz Try musí mít alespoň jednu klauzuli except nebo finally",
@@ -441,7 +458,9 @@
         "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ší",
+        "typeAliasTypeBaseClass": "A type alias defined in a \"type\" statement cannot be used as a base class",
         "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",
         "typeAliasTypeNameMismatch": "Název aliasu typu se musí shodovat s názvem proměnné, ke které je přiřazená",
@@ -498,6 +517,7 @@
         "typeVarPossiblyUnsolvable": "Proměnná typu „{name}“ může být nevyřešená, pokud volající nezadá žádný argument pro parametr „{param}“",
         "typeVarScopedToReturnType": "Proměnná typu „{name}“ je vymezená na volatelnou proměnnou v rámci návratového typu a nedá se na to odkazovat v těle funkce",
         "typeVarSingleConstraint": "TypeVar musí mít alespoň dva omezené typy",
+        "typeVarTupleConstraints": "TypeVarTuple nemůže mít omezení hodnoty",
         "typeVarTupleContext": "TypeVarTuple se v tomto kontextu nepovoluje",
         "typeVarTupleDefaultNotUnpacked": "Výchozí typ TypeVarTuple musí být rozbalený řazená kolekce členů nebo TypeVarTuple",
         "typeVarTupleMustBeUnpacked": "Pro hodnotu TypeVarTuple se vyžaduje operátor rozbalení",
@@ -509,6 +529,7 @@
         "typeVarWithoutDefault": "„{name}“ se v seznamu parametrů typu nemůže zobrazit za „{other}“ , protože nemá žádný výchozí typ",
         "typeVarsNotInGenericOrProtocol": "Generic[] nebo Protocol[] musí obsahovat všechny proměnné typu",
         "typedDictAccess": "Nepovedlo se získat přístup k položce v TypedDict",
+        "typedDictAssignedName": "TypedDict se musí přiřadit proměnné s názvem „{name}“.",
         "typedDictBadVar": "Třídy TypedDict můžou obsahovat jenom poznámky typu",
         "typedDictBaseClass": "Všechny základní třídy pro třídy TypedDict musí být také třídami TypedDict",
         "typedDictBoolParam": "Očekávalo se, že parametr {name} bude mít hodnotu True nebo False",
@@ -517,8 +538,12 @@
         "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",
+        "typedDictInitsubclassParameter": "TypedDict nepodporuje parametr __init_subclass__ „{name}“.",
+        "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",
@@ -528,6 +553,7 @@
         "unaccessedSymbol": "{name} není přístupné",
         "unaccessedVariable": "Proměnná {name} není přístupná",
         "unannotatedFunctionSkipped": "Analýza funkce „{name}“ se přeskočila, protože není označená",
+        "unaryOperationNotAllowed": "Unární operátor není v poznámce typu povolený.",
         "unexpectedAsyncToken": "Očekávalo se, že za async bude následovat def, with nebo for",
         "unexpectedExprToken": "Neočekávaný token na konci výrazu",
         "unexpectedIndent": "Neočekávané odsazení",
@@ -539,6 +565,8 @@
         "unionForwardReferenceNotAllowed": "Syntaxi sjednocení není možné použít s operandem řetězce; použijte uvozovky kolem celého výrazu",
         "unionSyntaxIllegal": "Alternativní syntaxe pro sjednocení vyžaduje Python 3.10 nebo novější",
         "unionTypeArgCount": "Sjednocení vyžaduje dva nebo více argumentů typu",
+        "unionUnpackedTuple": "Sjednocení nemůže obsahovat rozbalenou řazenou kolekci členů.",
+        "unionUnpackedTypeVarTuple": "Sjednocení nemůže obsahovat rozbalený typ TypeVarTuple.",
         "unmatchedEndregionComment": "#endregion chybí odpovídající #region",
         "unmatchedRegionComment": "#region chybí odpovídající #endregion",
         "unnecessaryCast": "Nepotřebné volání„přetypování“; Typ už je „{type}“.",
@@ -605,21 +633,26 @@
         "conditionalRequiresBool": "Metoda __bool__ pro typ {operandType} vrací typ {boolReturnType} místo bool",
         "dataClassFieldLocation": "Deklarace pole",
         "dataClassFrozen": "{name} je zablokované",
+        "dataProtocolUnsupported": "„{name}“ je datový protokol.",
         "descriptorAccessBindingFailed": "Nepovedlo se vytvořit vazbu metody {name} pro třídu popisovače {className}.",
         "descriptorAccessCallFailed": "Nepovedlo se volat metodu {name} pro třídu popisovače {className}.",
         "finalMethod": "Konečná metoda",
         "functionParamDefaultMissing": "V parametru „{name}“ chybí výchozí argument",
         "functionParamName": "Neshoda názvu parametru: {destName} a {srcName}",
+        "functionParamPositionOnly": "Neshoda parametrů pouze s pozicí; Parametr „{name}“ není jen pro pozici.",
         "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": "Zvažte přepnutí ze „seznamu“ na „sekvenci“, která je kovavariantní",
         "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",
@@ -630,11 +663,14 @@
         "matchIsNotExhaustiveHint": "Pokud není zamýšleno vyčerpávající zpracování, přidejte case _: pass",
         "matchIsNotExhaustiveType": "Nezpracovaný typ: {type}",
         "memberAssignment": "Výraz typu „{type}“ nelze přiřadit členu „{name}“ třídy „{classType}“",
-        "memberIsAbstract": "„{type}. {name}“ je abstraktní",
+        "memberIsAbstract": "\"{type}.{name}\" is not implemented",
         "memberIsAbstractMore": "a tento počet dalších: {count}...",
+        "memberIsClassVarInProtocol": "„{name}“ je v protokolu definován jako ClassVar.",
         "memberIsFinalInProtocol": "{name} je v protokolu označený jako Final",
         "memberIsInitVar": "Člen {name} je pole jen pro inicializaci",
         "memberIsInvariant": "{name} je invariantní, protože je proměnlivé",
+        "memberIsNotClassVarInClass": "\"{name}\" must be defined as a ClassVar to be compatible with protocol",
+        "memberIsNotClassVarInProtocol": "„{name}“ není v protokolu definován jako ClassVar.",
         "memberIsNotFinalInProtocol": "„{name}“ není v protokolu označeno jako Final",
         "memberIsWritableInProtocol": "{name} se dá zapisovat do protokolu.",
         "memberSetClassVar": "Člen „{name}“ nelze přiřadit prostřednictvím instance třídy, protože se jedná o třídu ClassVar",
@@ -643,14 +679,15 @@
         "metaclassConflict": "Metatřída {metaclass1} je v konfliktu s metatřídou {metaclass2}.",
         "missingDeleter": "Chybí metoda odstranění vlastnosti",
         "missingGetter": "Chybí metoda getter vlastnosti",
-        "missingProtocolMember": "Člen {name} je deklarován ve třídě protokolu {classType}",
         "missingSetter": "Chybí metoda nastavovacího kódu vlastnosti",
         "namedParamMissingInDest": "V cíli chybí parametr klíčového slova {name}",
         "namedParamMissingInSource": "Ve zdroji chybí parametr klíčového slova „{name}“",
         "namedParamTypeMismatch": "Parametr klíčového slova {name} typu {sourceType} není možné přiřadit typu {destType}",
         "newMethodLocation": "Metoda __new__ je definována ve třídě {type}",
         "newMethodSignature": "Podpis __new__ je {type}",
+        "newTypeClassNotAllowed": "Třídu vytvořenou pomocí newType nelze použít s kontrolami instancí a tříd.",
         "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",
@@ -686,9 +723,10 @@
         "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}“",
+        "protocolUnsafeOverlap": "Atributy „{name}“ mají stejné názvy jako protokol.",
         "pyrightCommentIgnoreTip": "Pokud chcete potlačit diagnostiku pro jeden řádek, použijte # pyright: ignore[<diagnostic rules>]",
         "readOnlyAttribute": "Atribut {name} je jen pro čtení",
         "seeClassDeclaration": "Viz deklarace třídy",
@@ -702,6 +740,7 @@
         "tupleEntryTypeMismatch": "Položka řazené kolekce členů {entry} je nesprávného typu",
         "tupleSizeIndeterminate": "Neshoda velikosti řazené kolekce členů; Očekávalo se {expected}, ale přijalo se neurčité.",
         "tupleSizeMismatch": "Neshoda velikosti řazené kolekce členů; Očekávalo se {expected}, ale přijalo se {received}.",
+        "typeAliasInstanceCheck": "Type alias created with \"type\" statement cannot be used with instance and class checks",
         "typeAssignmentMismatch": "Typ {sourceType} se nedá přiřadit k typu {destType}",
         "typeBound": "Typ {sourceType} je nekompatibilní s vázaným typem {destType} pro proměnnou typu {name}",
         "typeConstrainedTypeVar": "Typ {type} není kompatibilní s proměnnou omezeného typu {name}",
@@ -715,11 +754,13 @@
         "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.",
+        "typedDictClassNotAllowed": "Třída TypedDict není povolená pro kontroly instancí nebo tříd.",
         "typedDictFieldMissing": "V {type} chybí {name}",
         "typedDictFieldNotReadOnly": "{name} není v {type} jen pro čtení",
         "typedDictFieldNotRequired": "{name} se v typu {type} nevyžaduje",

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

@@ -14,7 +14,7 @@
         "indexValueDetail": "Indexwert"
     },
     "Diagnostic": {
-        "abstractMethodInvocation": "Die Methode \"{method}\" kann nicht aufgerufen werden, da sie abstrakt ist.",
+        "abstractMethodInvocation": "Die Methode „{method}“ kann nicht aufgerufen werden, da sie abstrakt und nicht implementiert ist.",
         "annotatedParamCountMismatch": "Nicht übereinstimmende Parameteranmerkungsanzahl: {expected} erwartet, aber {received} empfangen",
         "annotatedTypeArgMissing": "Es wurde ein Typargument und mindestens eine Anmerkung für \"Annotated\" erwartet.",
         "annotationFormatString": "Typanmerkungen können keine Formatzeichenfolgenliterale (f-strings) verwenden.",
@@ -44,6 +44,7 @@
         "assignmentTargetExpr": "Der Ausdruck kann kein Zuweisungsziel sein.",
         "asyncNotInAsyncFunction": "Die Verwendung von \"async\" ist außerhalb einer asynchronen Funktion nicht zulässig.",
         "awaitIllegal": "Die Verwendung von \"await\" erfordert Python 3.5 oder höher.",
+        "awaitNotAllowed": "Typanmerkungen können „await“ nicht verwenden.",
         "awaitNotInAsync": "\"await\" ist nur innerhalb einer asynchronen Funktion zulässig.",
         "backticksIllegal": "Ausdrücke, die von Backticks umgeben sind, werden in Python 3.x nicht unterstützt; verwenden Sie stattdessen repr",
         "baseClassCircular": "Die Klasse kann nicht von sich selbst abgeleitet werden.",
@@ -53,6 +54,7 @@
         "baseClassMethodTypeIncompatible": "Basisklassen für die Klasse \"{classType}\" definieren die Methode \"{name}\" auf inkompatible Weise.",
         "baseClassUnknown": "Der Basisklassentyp ist unbekannt, sodass der Typ der abgeleiteten Klasse verdeckt wird.",
         "baseClassVariableTypeIncompatible": "Basisklassen für die Klasse \"{classType}\" definieren die Variable \"{name}\" auf inkompatible Weise.",
+        "binaryOperationNotAllowed": "Binärer Operator in Typanmerkung nicht zulässig",
         "bindTypeMismatch": "Die Methode \"{methodName}\" konnte nicht gebunden werden, da \"{type}\" dem Parameter \"{paramName}\" nicht zugewiesen werden kann.",
         "breakOutsideLoop": "\"break\" kann nur innerhalb einer Schleife verwendet werden.",
         "callableExtraArgs": "Es wurden nur zwei Typargumente für \"Callable\" erwartet.",
@@ -69,6 +71,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.",
@@ -82,6 +85,7 @@
         "comparisonAlwaysTrue": "Die Bedingung wird immer als True ausgewertet, da die Typen \"{leftType}\" und \"{rightType}\" keine Überlappung aufweisen.",
         "comprehensionInDict": "Verständnis kann nicht mit anderen Wörterbucheinträgen verwendet werden.",
         "comprehensionInSet": "Verständnis kann nicht mit anderen Satzeinträgen verwendet werden.",
+        "concatenateContext": "„Verketten“ ist in diesem Kontext nicht zulässig.",
         "concatenateParamSpecMissing": "Das letzte Typargument für \"Concatenate\" muss ein ParamSpec oder \"...\" sein.",
         "concatenateTypeArgsMissing": "\"Verketten\" erfordert mindestens zwei Typargumente.",
         "conditionalOperandInvalid": "Ungültiger bedingter Operand vom Typ \"{type}\"",
@@ -107,6 +111,7 @@
         "dataClassTransformFieldSpecifier": "Es wurde ein Tupel von Klassen oder Funktionen erwartet, es wurde jedoch der Typ \"{type}\" empfangen",
         "dataClassTransformPositionalParam": "Alle Argumente für \"dataclass_transform\" müssen Schlüsselwortargumente sein.",
         "dataClassTransformUnknownArgument": "Argument \"{name}\" wird von dataclass_transform nicht unterstützt.",
+        "dataProtocolInSubclassCheck": "Datenprotokolle (die Nicht-Methodenattribute enthalten) sind in „issubclass“-Aufrufen nicht zulässig.",
         "declaredReturnTypePartiallyUnknown": "Der deklarierte Rückgabetyp \"{returnType}\" ist teilweise unbekannt.",
         "declaredReturnTypeUnknown": "Unbekannter Rückgabetyp deklariert",
         "defaultValueContainsCall": "Funktionsaufrufe und änderbare Objekte sind innerhalb des Parameterstandardwertausdrucks nicht zulässig.",
@@ -196,9 +201,10 @@
         "expectedTypeNotString": "Typ erwartet, aber Zeichenfolgenliteral empfangen",
         "expectedTypeParameterName": "Name für Typparameter erwartet",
         "expectedYieldExpr": "Ausdruck in yield-Anweisung erwartet",
-        "finalClassIsAbstract": "Die Klasse \"{type}\" ist als final gekennzeichnet und muss alle abstrakten Methoden implementieren.",
+        "finalClassIsAbstract": "Class \"{type}\" is marked final and must implement all abstract symbols",
         "finalContext": "\"Final\" ist in diesem Kontext nicht zulässig.",
         "finalMethodOverride": "Die Methode \"{name}\" kann die in der Klasse definierte endgültige Methode \"{className}\" nicht überschreiben.",
+        "finalNonMethod": "Die Funktion „{name}“ kann nicht @final markiert werden, da sie keine Methode ist.",
         "finalReassigned": "\"{name}\" ist als \"Final\" deklariert und kann nicht neu zugewiesen werden.",
         "finalRedeclaration": "\"{name}\" wurde zuvor als \"Final\" deklariert.",
         "finalRedeclarationBySubclass": "\"{name}\" kann nicht neu deklariert werden, da die übergeordnete Klasse \"{className}\" es als Final deklariert.",
@@ -242,6 +248,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 +272,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",
@@ -281,7 +289,6 @@
         "methodOrdering": "Es kann keine konsistente Methodenreihenfolge erstellt werden.",
         "methodOverridden": "\"{name}\" überschreibt die Methode mit demselben Namen in der Klasse \"{className}\" mit inkompatiblem Typ \"{type}\"",
         "methodReturnsNonObject": "Die Methode \"{name}\" gibt kein Objekt zurück.",
-        "missingProtocolMembers": "Die Klasse ist von mindestens einer Protokollklasse abgeleitet, implementiert jedoch nicht alle erforderlichen Member.",
         "missingSuperCall": "Die Methode \"{methodName}\" ruft nicht die Methode mit demselben Namen in der übergeordneten Klasse auf.",
         "moduleAsType": "Das Modul kann nicht als Typ verwendet werden.",
         "moduleNotCallable": "Das Modul kann nicht aufgerufen werden.",
@@ -297,11 +304,13 @@
         "namedTupleNoTypes": "\"namedtuple\" stellt keine Typen für Tupeleinträge bereit; verwenden Sie stattdessen \"NamedTuple\".",
         "namedTupleSecondArg": "Benannte Tupeleintragsliste als zweites Argument erwartet",
         "newClsParam": "__new__ Außerkraftsetzung sollte einen \"cls\"-Parameter annehmen.",
+        "newTypeAnyOrUnknown": "Das zweite Argument für NewType muss eine bekannte Klasse sein, nicht „Any“ oder „Unknown“.",
         "newTypeBadName": "Das erste Argument für NewType muss ein Zeichenfolgenliteral sein.",
         "newTypeLiteral": "\"NewType\" kann nicht mit dem Literaltyp verwendet werden.",
+        "newTypeNameMismatch": "NewType muss einer Variablen mit demselben Namen zugewiesen werden.",
         "newTypeNotAClass": "Klasse als zweites Argument für NewType erwartet",
         "newTypeParamCount": "NewType erfordert zwei Positionsargumente.",
-        "newTypeProtocolClass": "NewType kann nicht mit Protokollklasse verwendet werden.",
+        "newTypeProtocolClass": "NewType kann nicht mit strukturellem Typ (Protokoll- oder TypedDict-Klasse) verwendet werden.",
         "noOverload": "Keine Überladungen für \"{name}\" stimmen mit den angegebenen Argumenten überein.",
         "noReturnContainsReturn": "Eine Funktion mit dem deklarierten Rückgabetyp \"NoReturn\" kann keine return-Anweisung enthalten.",
         "noReturnContainsYield": "Eine Funktion mit dem deklarierten Rückgabetyp \"NoReturn\" kann keine yield-Anweisung enthalten.",
@@ -333,8 +342,12 @@
         "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",
+        "overloadFinalInconsistencyImpl": "Die Überladung für „{name}“ ist @final markiert, die Implementierung ist es jedoch nicht.",
+        "overloadFinalInconsistencyNoImpl": "Überladung {index} für „{name}“ ist als @final markiert, Überladung 1 ist es jedoch nicht.",
         "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 +388,8 @@
         "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.",
+        "protocolUnsafeOverlap": "Die Klasse überlappt unsicher mit „{name}“ und könnte zur Laufzeit eine Übereinstimmung erzeugen.",
         "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.",
@@ -405,6 +420,7 @@
         "revealTypeExpectedTextMismatch": "Typentextkonflikt; \"{expected}\" erwartet, aber \"{received}\" empfangen",
         "revealTypeExpectedTypeMismatch": "Typenkonflikt; \"{expected}\" erwartet, aber \"{received}\" empfangen",
         "selfTypeContext": "\"Self\" ist in diesem Kontext ungültig.",
+        "selfTypeMetaclass": "„Self“ kann nicht innerhalb einer Metaklasse (einer Unterklasse von „type“) verwendet werden.",
         "selfTypeWithTypedSelfOrCls": "\"Self\" kann nicht in einer Funktion mit einem Parameter \"self\" oder \"cls\" verwendet werden, der eine andere Typanmerkung als \"Self\" aufweist.",
         "setterGetterTypeMismatch": "Der Werttyp des Eigenschaftensetters kann dem Rückgabetyp des Getters nicht zugewiesen werden.",
         "singleOverload": "\"{name}\" ist als Überladung markiert, aber es fehlen weitere Überladungen.",
@@ -431,6 +447,7 @@
         "symbolIsUnbound": "\"{name}\" ist ungebunden.",
         "symbolIsUndefined": "\"{name}\" ist nicht definiert.",
         "symbolOverridden": "\"{name}\" überschreibt das Symbol desselben Namens in der Klasse \"{className}\"",
+        "ternaryNotAllowed": "Ternärer Ausdruck in Typanmerkung nicht zulässig",
         "totalOrderingMissingMethod": "Die Klasse muss \"__lt__\", \"__le__\", \"__gt__\" oder \"__ge__\" definieren, um total_ordering zu verwenden.",
         "trailingCommaInFromImport": "Nachgestelltes Komma ist ohne umgebende Klammern nicht zulässig.",
         "tryWithoutExcept": "Die try-Anweisung muss mindestens eine except- oder finally-Klausel aufweisen.",
@@ -441,7 +458,9 @@
         "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.",
+        "typeAliasTypeBaseClass": "A type alias defined in a \"type\" statement cannot be used as a base class",
         "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.",
         "typeAliasTypeNameMismatch": "Der Name des Typalias muss mit dem Namen der Variablen übereinstimmen, der er zugewiesen ist.",
@@ -498,6 +517,7 @@
         "typeVarPossiblyUnsolvable": "Die Typvariable \"{name}\" wird möglicherweise nicht aufgelöst, wenn der Aufrufer kein Argument für Parameter \"{param}\" bereitstellt",
         "typeVarScopedToReturnType": "Die Typvariable \"{name}\" ist auf einen Aufruf innerhalb des Rückgabetyps beschränkt und kann im Funktionstext nicht referenziert werden.",
         "typeVarSingleConstraint": "TypeVar muss mindestens zwei eingeschränkte Typen aufweisen.",
+        "typeVarTupleConstraints": "TypeVarTuple darf keine Werteinschränkungen aufweisen.",
         "typeVarTupleContext": "TypeVarTuple ist in diesem Kontext nicht zulässig.",
         "typeVarTupleDefaultNotUnpacked": "Der Standardtyp \"TypeVarTuple\" muss ein entpacktes Tupel oder ein TypeVarTuple sein.",
         "typeVarTupleMustBeUnpacked": "Der Entpackungsoperator ist für den TypeVarTuple-Wert erforderlich.",
@@ -509,6 +529,7 @@
         "typeVarWithoutDefault": "\"{name}\" kann nicht nach \"{other}\" in der Typparameterliste angezeigt werden, da es keinen Standardtyp aufweist.",
         "typeVarsNotInGenericOrProtocol": "Generic[] oder Protocol[] müssen alle Typvariablen enthalten.",
         "typedDictAccess": "Auf das Element in TypedDict konnte nicht zugegriffen werden.",
+        "typedDictAssignedName": "TypedDict muss einer Variablen mit dem Namen „{name}“ zugewiesen werden.",
         "typedDictBadVar": "TypedDict-Klassen dürfen nur Typanmerkungen enthalten.",
         "typedDictBaseClass": "Alle Basisklassen für TypedDict-Klassen müssen auch TypedDict-Klassen sein.",
         "typedDictBoolParam": "Es wird erwartet, dass \"{name}\" Parameter den Wert \"True\" oder \"False\" aufweist.",
@@ -517,8 +538,12 @@
         "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.",
+        "typedDictInitsubclassParameter": "TypedDict unterstützt __init_subclass__ Parameter „{name}“ nicht.",
+        "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.",
@@ -528,6 +553,7 @@
         "unaccessedSymbol": "Auf \"{name}\" kann nicht zugegriffen werden.",
         "unaccessedVariable": "Auf die Variable \"{name}\" kann nicht zugegriffen werden.",
         "unannotatedFunctionSkipped": "Die Analyse der Funktion \"{name}\" wird übersprungen, da sie nicht kommentiert wurde.",
+        "unaryOperationNotAllowed": "Unärer Operator in Typanmerkung nicht zulässig",
         "unexpectedAsyncToken": "Es wurde erwartet, dass \"def\", \"with\" oder \"for\" auf \"async\" folgt.",
         "unexpectedExprToken": "Unerwartetes Token am Ende des Ausdrucks.",
         "unexpectedIndent": "Unerwarteter Einzug",
@@ -539,6 +565,8 @@
         "unionForwardReferenceNotAllowed": "Die Unionsyntax kann nicht mit einem Zeichenfolgenoperanden verwendet werden; verwenden Sie Anführungszeichen um den gesamten Ausdruck",
         "unionSyntaxIllegal": "Alternative Syntax für Unions erfordert Python 3.10 oder höher.",
         "unionTypeArgCount": "Union erfordert mindestens zwei Typargumente.",
+        "unionUnpackedTuple": "Union kann kein entpacktes Tupel enthalten.",
+        "unionUnpackedTypeVarTuple": "Die Union kann kein entpacktes TypeVarTuple enthalten.",
         "unmatchedEndregionComment": "#endregion fehlt die entsprechende #region",
         "unmatchedRegionComment": "#region fehlt die entsprechende #endregion",
         "unnecessaryCast": "Nicht erforderlicher \"cast\"-Aufruf; der Typ ist bereits \"{type}\".",
@@ -605,21 +633,26 @@
         "conditionalRequiresBool": "Die Methode __bool__ für den Typ \"{operandType}\" gibt den Typ \"{boolReturnType}\" anstelle von \"bool\" zurück",
         "dataClassFieldLocation": "Felddeklaration",
         "dataClassFrozen": "\"{name}\" ist fixiert",
+        "dataProtocolUnsupported": "„{name}“ ist ein Datenprotokoll.",
         "descriptorAccessBindingFailed": "Fehler beim Binden der Methode „{name}“ für die Deskriptorklasse „{className}“",
         "descriptorAccessCallFailed": "Fehler beim Aufrufen der Methode „{name}“ für die Deskriptorklasse „{className}“",
         "finalMethod": "Endgültige Methode",
         "functionParamDefaultMissing": "Standardargument für Parameter \"{name}\" fehlt.",
         "functionParamName": "Parameternamen stimmen nicht überein: \"{destName}\" und \"{srcName}\"",
+        "functionParamPositionOnly": "Nicht übereinstimmender Parameter „nur für Position“. Der Parameter „{name}“ ist nicht „nur für Position“.",
         "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": "Erwägen Sie den Wechsel von „set“ zu „Container“, der Kovariante ist.",
         "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.",
@@ -630,11 +663,14 @@
         "matchIsNotExhaustiveHint": "Wenn keine ausführliche Behandlung beabsichtigt ist, fügen Sie \"case _: pass\" hinzu.",
         "matchIsNotExhaustiveType": "Unbehandelter Typ: \"{type}\"",
         "memberAssignment": "Ein Ausdruck vom Typ \"{type}\" kann dem Member \"{name}\" der Klasse \"{classType}\" nicht zugewiesen werden.",
-        "memberIsAbstract": "\"{type}.{name}\" ist abstrakt.",
+        "memberIsAbstract": "\"{type}.{name}\" is not implemented",
         "memberIsAbstractMore": "und {count} weitere...",
+        "memberIsClassVarInProtocol": "„{name}“ ist als ClassVar im Protokoll definiert.",
         "memberIsFinalInProtocol": "\"{name}\" ist im Protokoll als \"Final\" gekennzeichnet.",
         "memberIsInitVar": "Das Element \"{name}\" ist ein init-only-Feld.",
         "memberIsInvariant": "\"{name}\" ist invariant, da es änderbar ist.",
+        "memberIsNotClassVarInClass": "\"{name}\" must be defined as a ClassVar to be compatible with protocol",
+        "memberIsNotClassVarInProtocol": "„{name}“ ist nicht als ClassVar im Protokoll definiert.",
         "memberIsNotFinalInProtocol": "\"{name}\" ist im Protokoll nicht als \"Final\" gekennzeichnet.",
         "memberIsWritableInProtocol": "\"{name}\" ist im Protokoll beschreibbar.",
         "memberSetClassVar": "Der Member \"{name}\" kann nicht über eine Klasseninstanz zugewiesen werden, da es sich um eine ClassVar handelt.",
@@ -643,14 +679,15 @@
         "metaclassConflict": "Die Metaklasse \"{metaclass1}\" verursacht einen Konflikt mit \"{metaclass2}\"",
         "missingDeleter": "Die Eigenschaft-Deleter-Methode fehlt.",
         "missingGetter": "Die Eigenschaft-Getter-Methode fehlt.",
-        "missingProtocolMember": "Member \"{name}\" ist in Protokollklasse \"{classType}\" deklariert.",
         "missingSetter": "Die Eigenschaft-Setter-Methode fehlt.",
         "namedParamMissingInDest": "Der Schlüsselwortparameter \"{name}\" fehlt im Ziel.",
         "namedParamMissingInSource": "Der Schlüsselwortparameter \"{name}\" fehlt in der Quelle.",
         "namedParamTypeMismatch": "Der Stichwortparameter \"{name}\" vom Typ \"{sourceType}\" kann dem Typ \"{destType}\" nicht zugewiesen werden.",
         "newMethodLocation": "Die __new__ Methode ist in der Klasse \"{type}\" definiert.",
         "newMethodSignature": "Signatur von __new__ ist \"{type}\"",
+        "newTypeClassNotAllowed": "Die mit NewType erstellte Klasse kann nicht mit Instanz- und Klassenüberprüfungen verwendet werden.",
         "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 +707,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}“ stimmt nicht überein: Basisparameter „{baseName}“ ist Schlüsselwortparameter, Außerkraftsetzungsparameter ist „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,9 +723,10 @@
         "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.",
+        "protocolUnsafeOverlap": "Attribute von „{name}“ weisen die gleichen Namen wie das Protokoll auf.",
         "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.",
         "seeClassDeclaration": "Siehe Klassendeklaration",
@@ -702,6 +740,7 @@
         "tupleEntryTypeMismatch": "Der Tupeleintrag {entry} ist ein falscher Typ.",
         "tupleSizeIndeterminate": "Nicht übereinstimmende Tupelgröße; {expected} erwartet, aber unbestimmt empfangen",
         "tupleSizeMismatch": "Nicht übereinstimmende Tupelgröße; {expected} erwartet, aber {received} empfangen",
+        "typeAliasInstanceCheck": "Type alias created with \"type\" statement cannot be used with instance and class checks",
         "typeAssignmentMismatch": "Der Typ \"{sourceType}\" kann dem Typ \"{destType}\" nicht zugewiesen werden.",
         "typeBound": "Der Typ \"{sourceType}\" ist nicht mit dem gebundenen Typ \"{destType}\" für die Typvariablen \"{name}\" kompatibel.",
         "typeConstrainedTypeVar": "Der Typ \"{type}\" ist mit der eingeschränkten Typvariablen nicht kompatibel \"{name}\"",
@@ -715,11 +754,13 @@
         "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.",
+        "typedDictClassNotAllowed": "Die TypedDict-Klasse ist für Instanz- oder Klassenüberprüfungen nicht zulässig.",
         "typedDictFieldMissing": "\"{name}\" fehlt in \"{type}\"",
         "typedDictFieldNotReadOnly": "\"{name}\" ist in \"{type}\" nicht schreibgeschützt.",
         "typedDictFieldNotRequired": "\"{name}\" ist in \"{type}\" nicht erforderlich.",