@zzzen/pyright-internal 1.2.0-dev.20240908 → 1.2.0-dev.20240922

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

@@ -1,7 +1,7 @@
 {
     "CodeAction": {
-        "createTypeStub": "Vytvořit zástupná procedura typu",
-        "createTypeStubFor": "Vytvořit zástupnou proceduru typu pro modul {moduleName}",
+        "createTypeStub": "Vytvořit zástupnou proceduru (Stub) typu",
+        "createTypeStubFor": "Vytvořit zástupnou proceduru typu (Stub) pro modul {moduleName}",
         "executingCommand": "Spouští se příkaz",
         "filesToAnalyzeCount": "Počet souborů k analýze: {count}",
         "filesToAnalyzeOne": "1 soubor k analýze",
@@ -18,12 +18,12 @@
         "annotatedMetadataInconsistent": "Typ metadat s poznámkami „{metadataType}“ není kompatibilní s typem „{type}“.",
         "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",
-        "annotationBytesString": "Poznámky typu nemůžou používat řetězcové literály bajtů.",
-        "annotationFormatString": "Poznámky typu nemůžou používat formátovací řetězcové literály (f-strings)",
+        "annotationBytesString": "Výrazy typu nemůžou používat řetězcové literály bajtů.",
+        "annotationFormatString": "Výrazy typu nemůžou používat formátovací řetězcové literály (f-strings).",
         "annotationNotSupported": "Poznámka typu není pro tento příkaz podporována",
-        "annotationRawString": "Poznámky typu nemůžou používat literály nezpracovaného řetězce.",
-        "annotationSpansStrings": "Poznámky typu nemůžou zahrnovat více řetězcových literálů",
-        "annotationStringEscape": "Poznámky typu nemůžou obsahovat řídicí znaky",
+        "annotationRawString": "Výrazy typu nemůžou používat literály nezpracovaného řetězce.",
+        "annotationSpansStrings": "Výrazy typu nemůžou zahrnovat více řetězcových literálů.",
+        "annotationStringEscape": "Výrazy typu nemůžou obsahovat řídicí znaky.",
         "argAssignment": "Argument typu {argType} není možné přiřadit k parametru typu {paramType}",
         "argAssignmentFunction": "Argument typu {argType} není možné přiřadit k parametru typu {paramType} ve funkci {functionName}",
         "argAssignmentParam": "Argument typu {argType} není možné přiřadit k parametru {paramName} typu {paramType}",
@@ -47,7 +47,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“.",
+        "awaitNotAllowed": "Výrazy typu nemůžou používat výraz 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",
@@ -57,7 +57,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ý",
+        "binaryOperationNotAllowed": "Ve výrazu typu není povolený binární operátor.",
         "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",
@@ -70,7 +70,7 @@
         "classDefinitionCycle": "Definice třídy pro „{name}“ závisí sama na sobě",
         "classGetItemClsParam": "Přepsání __class_getitem__ by mělo mít parametr cls",
         "classMethodClsParam": "Metody třídy by měly mít parametr „cls“",
-        "classNotRuntimeSubscriptable": "Dolní index pro třídu {name} vygeneruje výjimku modulu runtime; anotaci typu uzavřete do uvozovek",
+        "classNotRuntimeSubscriptable": "Dolní index pro třídu {name} vygeneruje výjimku modulu runtime; výraz typu uzavřete do uvozovek.",
         "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",
@@ -87,7 +87,7 @@
         "comparisonAlwaysFalse": "Podmínka se vždy vyhodnotí jako False, protože typy {leftType} a {rightType} se nepřekrývají",
         "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",
+        "comprehensionInSet": "Porozumění nelze použít s jinými položkami sady (set).",
         "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",
@@ -111,7 +111,7 @@
         "dataClassPostInitType": "Neshoda typu parametru metody __post_init__ datové třídy pro pole {fieldName}",
         "dataClassSlotsOverwrite": "__slots__ je už ve třídě definovaný",
         "dataClassTransformExpectedBoolLiteral": "Očekával se výraz, který se staticky vyhodnotí jako True nebo False",
-        "dataClassTransformFieldSpecifier": "Očekávala se řazená kolekce členů tříd nebo funkcí, ale přijatý typ „{type}“",
+        "dataClassTransformFieldSpecifier": "Očekávala se řazená kolekce členů (tuple) tříd nebo funkcí, ale byl 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é.",
@@ -127,12 +127,12 @@
         "deprecatedDescriptorSetter": "Metoda „__set__“ pro popisovač „{name}“ je zastaralá",
         "deprecatedFunction": "Funkce {name} je zastaralá.",
         "deprecatedMethod": "Metoda {name} ve třídě {className} je zastaralá.",
-        "deprecatedPropertyDeleter": "Odstraňovač pro vlastnost „{name}“ je zastaralý",
-        "deprecatedPropertyGetter": "Metoda getter pro vlastnost „{name}“ je zastaralá",
-        "deprecatedPropertySetter": "Metoda setter pro vlastnost „{name}“ je zastaralá",
+        "deprecatedPropertyDeleter": "Metoda deleter pro property „{name}“ je zastaralá.",
+        "deprecatedPropertyGetter": "Metoda getter pro property „{name}“ je zastaralá.",
+        "deprecatedPropertySetter": "Metoda setter pro property „{name}“ je zastaralá.",
         "deprecatedType": "Tento typ je zastaralý jako Python {version}; místo toho použijte {replacement}",
         "dictExpandIllegalInComprehension": "Rozšíření slovníku není v porozumění povoleno",
-        "dictInAnnotation": "Výraz slovníku není v poznámce typu povolený",
+        "dictInAnnotation": "Výraz slovníku není ve výrazu typu povolený.",
         "dictKeyValuePairs": "Položky slovníku musí obsahovat páry klíč/hodnota",
         "dictUnpackIsNotMapping": "Očekávalo se mapování pro operátor rozbalení slovníku",
         "dunderAllSymbolNotPresent": "{name} je zadáno v __all__, ale v modulu se nenachází",
@@ -140,8 +140,8 @@
         "duplicateBaseClass": "Duplicitní základní třída není povolena",
         "duplicateCapturePatternTarget": "Cíl zachytávání {name} se v rámci stejného vzoru nemůže vyskytovat více než jednou",
         "duplicateCatchAll": "Je povolena pouze jedna klauzule catch-all except",
-        "duplicateEnumMember": "Člen výčtu {name} je už deklarovaný",
-        "duplicateGenericAndProtocolBase": "Je povolena pouze jedna základní třída Generic nebo Protocol**",
+        "duplicateEnumMember": "Člen Enum {name} je už deklarovaný.",
+        "duplicateGenericAndProtocolBase": "Je povolena pouze jedna základní třída Generic[...] nebo Protocol[...].",
         "duplicateImport": "Import {importName} je importován více než jednou",
         "duplicateKeywordOnly": "Je povolený jenom jeden oddělovač *",
         "duplicateKwargsParam": "Je povolený jenom jeden parametr **",
@@ -149,14 +149,14 @@
         "duplicatePositionOnly": "Je povolený jenom jeden parametr „/“",
         "duplicateStarPattern": "V sekvenci vzorů je povolený jenom jeden vzor „*“",
         "duplicateStarStarPattern": "Je povolena pouze jedna položka „**“",
-        "duplicateUnpack": "V seznamu je povolena pouze jedna operace rozbalení",
-        "ellipsisAfterUnpacked": "„…“ nelze použít s rozbalenou kolekcí TypeVarTuple nebo řazenou kolekcí členů.",
+        "duplicateUnpack": "V seznamu (list) je povolena pouze jedna operace rozbalení.",
+        "ellipsisAfterUnpacked": "„…“ nelze použít s rozbalenou kolekcí TypeVarTuple nebo tuple.",
         "ellipsisContext": "„...“ se v tomto kontextu nepovoluje",
         "ellipsisSecondArg": "„...“ je povoleno pouze jako druhý ze dvou argumentů",
-        "enumClassOverride": "Třída výčtu {name} je konečná a nemůže být podtřídou",
-        "enumMemberDelete": "Člen výčtu {name} se nedá odstranit.",
-        "enumMemberSet": "Člen výčtu {name} se nedá přiřadit.",
-        "enumMemberTypeAnnotation": "Poznámky typu nejsou pro členy výčtu povolené",
+        "enumClassOverride": "Třída Enum {name} je final a nemůže být podtřídou.",
+        "enumMemberDelete": "Člen Enum {name} se nedá odstranit.",
+        "enumMemberSet": "Člen Enum {name} se nedá přiřadit.",
+        "enumMemberTypeAnnotation": "Poznámky typu nejsou pro členy enum povolené.",
         "exceptionGroupIncompatible": "Syntaxe skupiny výjimek (\"except*\") vyžaduje Python 3.11 nebo novější",
         "exceptionGroupTypeIncorrect": "Typ výjimky v except* se nedá odvodit z BaseGroupException.",
         "exceptionTypeIncorrect": "„{type}“ se neodvozuje od BaseException",
@@ -189,7 +189,7 @@
         "expectedIdentifier": "Očekávaný identifikátor",
         "expectedImport": "Očekával se import",
         "expectedImportAlias": "Za as byl očekáván symbol",
-        "expectedImportSymbols": "Po importu se očekával jeden nebo více názvů symbolů",
+        "expectedImportSymbols": "Po možnosti import se očekával jeden nebo více názvů symbolů.",
         "expectedIn": "Očekávalo se in",
         "expectedInExpr": "Za in byl očekáván výraz",
         "expectedIndentedBlock": "Očekával se odsazený blok",
@@ -209,16 +209,16 @@
         "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í symboly",
+        "finalClassIsAbstract": "Třída „{type}“ je označena jako final a musí implementovat všechny abstraktní symboly.",
         "finalContext": "Final se v tomto kontextu nepovoluje",
         "finalInLoop": "Proměnnou Final nelze přiřadit ve smyčce.",
-        "finalMethodOverride": "Metoda {name} nemůže přepsat konečnou metodu definovanou ve třídě {className}",
+        "finalMethodOverride": "Metoda {name} nemůže přepsat metodu final 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",
+        "finalRedeclarationBySubclass": "{name} se nedá deklarovat znovu, protože nadřazená třída {className} ji deklaruje jako Final.",
         "finalTooManyArgs": "Za Final byl očekáván jeden argument typu",
-        "finalUnassigned": "{name} se deklaruje jako final, ale hodnota není přiřazená",
+        "finalUnassigned": "{name} se deklaruje jako Final, ale hodnota není přiřazená.",
         "formatStringBrace": "Jednoduchá pravá složená závorka není v literálu f-string povolena. použijte dvojitou pravou složenou závorku",
         "formatStringBytes": "Formátovací řetězcové literály (f-strings) nemůžou být binární",
         "formatStringDebuggingIllegal": "Specifikátor ladění F-string „=“ vyžaduje Python 3.8 nebo novější",
@@ -246,8 +246,8 @@
         "genericTypeArgMissing": "Generic vyžaduje alespoň jeden argument typu",
         "genericTypeArgTypeVar": "Argument typu pro Generic musí být proměnná typu",
         "genericTypeArgUnique": "Argumenty typu pro Generic musí být jedinečné",
-        "globalReassignment": "{name} je přiřazen před globální deklarací",
-        "globalRedefinition": "Název {name} už je deklarován jako globální",
+        "globalReassignment": "{name} je přiřazen před deklarací global.",
+        "globalRedefinition": "Název {name} už je deklarován jako global.",
         "implicitStringConcat": "Implicitní zřetězení řetězců není povolené",
         "importCycleDetected": "V řetězci importu byl zjištěn cyklus",
         "importDepthExceeded": "Hloubka řetězu importu překročila {depth}",
@@ -265,16 +265,16 @@
         "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}“",
         "instantiateAbstract": "Nelze vytvořit instanci abstraktní třídy „{type}“",
-        "instantiateProtocol": "Nelze vytvořit instanci třídy protokolu „{type}“",
+        "instantiateProtocol": "Nelze vytvořit instanci třídy Protocol „{type}“.",
         "internalBindError": "Při vytváření vazby souboru {file} došlo k vnitřní chybě: {message}",
         "internalParseError": "Při analýze souboru {file} došlo k vnitřní chybě: {message}",
         "internalTypeCheckingError": "Při kontrole typu souboru {file} došlo k vnitřní chybě: {message}",
         "invalidIdentifierChar": "Neplatný znak v identifikátoru",
-        "invalidStubStatement": "Příkaz je v souboru zástupné procedury typu bezvýznamný",
+        "invalidStubStatement": "Příkaz je v souboru zástupné procedury (stub) typu bezvýznamný.",
         "invalidTokenChars": "Neplatný znak „{text}“ v tokenu",
-        "isInstanceInvalidType": "Druhý argument pro „isinstance“ musí být třída nebo řazená kolekce členů tříd",
-        "isSubclassInvalidType": "Druhý argument pro issubclass musí být třída nebo řazená kolekce členů tříd",
-        "keyValueInSet": "Páry klíč-hodnota nejsou v rámci sady povoleny",
+        "isInstanceInvalidType": "Druhý argument pro „isinstance“ musí být třída nebo řazená kolekce členů (tuple) tříd.",
+        "isSubclassInvalidType": "Druhý argument pro issubclass musí být třída nebo řazená kolekce členů (tuple) tříd.",
+        "keyValueInSet": "Páry klíč-hodnota nejsou v rámci sady (set) povoleny.",
         "keywordArgInTypeArgument": "Argumenty klíčových slov nelze použít v seznamech argumentů typu",
         "keywordArgShortcutIllegal": "Zástupce argumentu klíčového slova vyžaduje Python 3.14 nebo novější.",
         "keywordOnlyAfterArgs": "Oddělovač argumentů jen pro klíčová slova není povolený za parametrem *",
@@ -283,12 +283,12 @@
         "lambdaReturnTypePartiallyUnknown": "Návratový typ lambda {returnType} je částečně neznámý",
         "lambdaReturnTypeUnknown": "Návratový typ výrazu lambda je neznámý",
         "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",
-        "literalNamedUnicodeEscape": "Pojmenované řídicí sekvence Unicode nejsou v řetězcových poznámkách literálů podporovány.",
+        "listInAnnotation": "Výraz List není ve výrazu typu povolený.",
+        "literalEmptyArgs": "Za literálem (Literal) se očekával jeden nebo více argumentů typu.",
+        "literalNamedUnicodeEscape": "Pojmenované řídicí sekvence Unicode nejsou v poznámkách řetězců Literal podporovány.",
         "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",
+        "literalNotCallable": "Není možné vytvořit instanci typu Literal.",
+        "literalUnsupportedType": "Argumenty typu pro Literal musí být None, hodnota literálu (int, bool, str nebo bytes) nebo hodnota enum.",
         "matchIncompatible": "Příkazy match vyžadují Python 3.10 nebo novější",
         "matchIsNotExhaustive": "Případy v rámci příkazu match nezpracovávají kompletně všechny hodnoty",
         "maxParseDepthExceeded": "Byla překročena maximální hloubka analýzy; rozdělte výraz na dílčí výrazy",
@@ -304,20 +304,21 @@
         "methodOverridden": "„{name}“ přepisuje metodu se stejným názvem ve třídě „{className}“ s nekompatibilním typem {type}",
         "methodReturnsNonObject": "Metoda {name} nevrací objekt",
         "missingSuperCall": "Metoda {methodName} nevolá metodu se stejným názvem v nadřazené třídě",
+        "mixingBytesAndStr": "Hodnoty bytes a str nelze zřetězit.",
         "moduleAsType": "Modul nejde použít jako typ",
         "moduleNotCallable": "Modul není volatelný",
         "moduleUnknownMember": "{memberName} není známý atribut modulu {moduleName}.",
         "namedExceptAfterCatchAll": "Za klauzulí catch-all except se nemůže objevit pojmenovaná klauzule except",
-        "namedParamAfterParamSpecArgs": "Parametr klíčového slova {name} se nemůže objevit v signatuře za parametrem argumentů ParamSpec",
-        "namedTupleEmptyName": "Názvy v pojmenované řazené kolekci členů nemůžou být prázdné.",
-        "namedTupleEntryRedeclared": "{name} nejde přepsat, protože nadřazená třída {className} je pojmenovaná řazená kolekce členů.",
-        "namedTupleFirstArg": "Jako první argument byl očekáván název pojmenované třídy řazené kolekce členů",
+        "namedParamAfterParamSpecArgs": "Parametr klíčového slova {name} se nemůže objevit v signatuře za parametrem ParamSpec args.",
+        "namedTupleEmptyName": "Názvy v pojmenované řazené kolekci členů (tuple) nemůžou být prázdné.",
+        "namedTupleEntryRedeclared": "{name} nejde přepsat, protože nadřazená třída {className} je pojmenovaná řazená kolekce členů (tuple).",
+        "namedTupleFirstArg": "Jako první argument byl očekáván název pojmenované třídy řazené kolekce členů (tuple).",
         "namedTupleMultipleInheritance": "Vícenásobná dědičnost s NamedTuple se nepodporuje",
         "namedTupleNameKeyword": "Názvy polí nemůžou být klíčové slovo.",
-        "namedTupleNameType": "Očekávala se řazená kolekce členů se dvěma položkami určující název a typ položky",
-        "namedTupleNameUnique": "Názvy v pojmenované řazené kolekci členů musí být jedinečné",
+        "namedTupleNameType": "Očekávala se řazená kolekce členů (tuple) se dvěma položkami určující název a typ položky.",
+        "namedTupleNameUnique": "Názvy v pojmenované řazené kolekci členů (tuple) musí být jedinečné.",
         "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ů",
+        "namedTupleSecondArg": "Jako druhý argument byl očekáván pojmenovaný seznam (list) řazené kolekce členů (tuple).",
         "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",
@@ -325,20 +326,20 @@
         "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 nelze použít se strukturálním typem (protokol nebo třída TypedDict).",
+        "newTypeProtocolClass": "NewType nelze použít se strukturálním typem (třída Protocol nebo 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",
+        "noReturnContainsReturn": "Funkce s deklarovaným návratovým typem return type NoReturn nemůže obsahovat příkaz return.",
         "noReturnContainsYield": "Funkce s deklarovaným návratovým typem NoReturn nemůže obsahovat příkaz yield",
         "noReturnReturnsNone": "Funkce s deklarovaným návratovým typem „NoReturn“ nemůže vrátit „None“.",
         "nonDefaultAfterDefault": "Nevýchozí argument následuje za výchozím argumentem",
-        "nonLocalInModule": "Nemístní deklarace není povolená na úrovni modulu",
-        "nonLocalNoBinding": "Nenašla se žádná vazba pro nemístní {name}",
-        "nonLocalReassignment": "{name} je přiřazeno před nemístní deklarací",
-        "nonLocalRedefinition": "{name} již bylo deklarováno jako nemístní",
+        "nonLocalInModule": "Deklarace Nonlocal není povolená na úrovni modulu.",
+        "nonLocalNoBinding": "Nenašla se žádná vazba pro nonlocal {name}.",
+        "nonLocalReassignment": "{name} je přiřazeno před deklarací nonlocal.",
+        "nonLocalRedefinition": "{name} již bylo deklarováno jako nonlocal.",
         "noneNotCallable": "Objekt typu „None“ nelze volat.",
         "noneNotIterable": "Objekt typu None není možné použít jako iterovatelnou hodnotu",
         "noneNotSubscriptable": "Objekt typu “None“ nelze zadat jako dolní index",
-        "noneNotUsableWith": "Objekt typu None není možné použít s with",
+        "noneNotUsableWith": "Object of type \"None\" cannot be used with \"with\"",
         "noneOperator": "Operátor {operator} se pro None nepodporuje",
         "noneUnknownMember": "{name} není známý atribut None.",
         "notRequiredArgCount": "Za NotRequired byl očekáván jeden argument typu",
@@ -351,7 +352,7 @@
         "obscuredTypeAliasDeclaration": "Deklarace aliasu typu {name} je zakrytá deklarací stejného názvu",
         "obscuredVariableDeclaration": "Deklarace {name} je zakrytá deklarací stejného názvu",
         "operatorLessOrGreaterDeprecated": "Operátor <> se v Pythonu 3 nepodporuje; místo toho použijte !=",
-        "optionalExtraArgs": "Za nepovinnou hodnotou se očekával jeden argument typu",
+        "optionalExtraArgs": "Za nepovinnou hodnotou (Optional) se očekával jeden argument typu.",
         "orPatternIrrefutable": "Nevratný vzor je povolený jenom jako poslední dílčí vzorec ve vzorci „or“",
         "orPatternMissingName": "Všechny dílčí vzory v rámci vzoru or musí cílit na stejné názvy",
         "overlappingKeywordArgs": "Slovník silného typu se překrývá s parametrem klíčového slova: {names}",
@@ -364,9 +365,9 @@
         "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}“",
+        "overloadWithoutImplementation": "„{name}“ je označené jako přetížení (overload), ale není zadaná žádná implementace.",
+        "overriddenMethodNotFound": "Metoda „{name}“ je označená jako přepsání (override), ale neexistuje žádná základní metoda se stejným názvem.",
+        "overrideDecoratorMissing": "Metoda „{name}“ není označená jako přepsání (override), ale přepisuje metodu ve třídě „{className}“.",
         "paramAfterKwargsParam": "Parametr nemůže následovat za parametrem „**“",
         "paramAlreadyAssigned": "Parametr {name} je už přiřazený",
         "paramAnnotationMissing": "Chybí poznámka typu pro parametr „{name}“",
@@ -377,7 +378,7 @@
         "paramSpecArgsUsage": "Atribut args ParamSpec je platný jenom v případě, že se používá s parametrem *args.",
         "paramSpecAssignedName": "Parametr ParamSpec musí být přiřazen proměnné s názvem {name}",
         "paramSpecContext": "ParamSpec se v tomto kontextu nepovoluje",
-        "paramSpecDefaultNotTuple": "Očekávaly se tři tečky, výraz řazené kolekce členů nebo Parametr ParamSpec pro výchozí hodnotu ParamSpec",
+        "paramSpecDefaultNotTuple": "Očekávaly se tři tečky, výraz řazené kolekce členů (tuple) nebo ParamSpec pro výchozí hodnotu ParamSpec.",
         "paramSpecFirstArg": "Očekával se název parametru ParamSpec jako první argument",
         "paramSpecKwargsUsage": "Atribut kwargs ParamSpec je platný jenom v případě, že se používá s parametrem **kwargs.",
         "paramSpecNotUsedByOuterScope": "Parametr ParamSpec {name} nemá v tomto kontextu žádný význam",
@@ -387,7 +388,7 @@
         "paramTypeCovariant": "Proměnnou kovariantní typu není možné použít v typu parametru",
         "paramTypePartiallyUnknown": "Typ parametru {paramName} je částečně neznámý",
         "paramTypeUnknown": "Typ parametru {paramName} je neznámý",
-        "parenthesizedContextManagerIllegal": "Závorky v příkazu with vyžadují Python 3.9 nebo novější",
+        "parenthesizedContextManagerIllegal": "Parentheses within \"with\" statement requires Python 3.9 or newer",
         "patternNeverMatches": "Vzor se nikdy nebude shodovat s typem předmětu {type}",
         "positionArgAfterNamedArg": "Poziční argument se nemůže objevit za argumenty klíčového slova",
         "positionOnlyAfterArgs": "Oddělovač parametrů jen pro pozici není povolený za parametrem *.",
@@ -398,21 +399,21 @@
         "privateImportFromPyTypedModule": "{name} se neexportuje z modulu {module}",
         "privateUsedOutsideOfClass": "{name} je privátní a používá se mimo třídu, ve které je deklarovaná",
         "privateUsedOutsideOfModule": "{name} je privátní a používá se mimo modul, ve kterém je deklarován",
-        "propertyOverridden": "„{name}“ nesprávně přepíše vlastnost se stejným názvem ve třídě {className}",
-        "propertyStaticMethod": "Statické metody nejsou povoleny pro metodu getter, setter nebo deleter vlastnosti",
+        "propertyOverridden": "„{name}“ nesprávně přepíše vlastnost (property) se stejným názvem ve třídě „{className}“.",
+        "propertyStaticMethod": "Statické metody nejsou povoleny pro metodu getter, setter nebo deleter vlastnosti (property).",
         "protectedUsedOutsideOfClass": "„{name}“ je chráněn(ý/o/é) a používá se mimo třídu, ve které je deklarovaná",
-        "protocolBaseClass": "Třída protokolu „{classType}“ se nemůže odvozovat od třídy,která není protokolem „{baseType}“",
+        "protocolBaseClass": "Třída Protocol {classType} se nemůže odvozovat od třídy, která není třídou Protocol {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ší",
+        "protocolIllegal": "Použití třídy Protocol vyžaduje Python 3.7 nebo novější.",
         "protocolNotAllowed": "„Protocol“ nejde v tomto kontextu použít.",
-        "protocolTypeArgMustBeTypeParam": "Argument typu pro „protokol“ musí být parametr typu",
+        "protocolTypeArgMustBeTypeParam": "Argument typu pro „Protocol“ musí být parametr typu.",
         "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í",
+        "protocolVarianceContravariant": "Proměnná typu {variable} použitá v obecné třídě Protocol {class} by měla být kontravariantní.",
+        "protocolVarianceCovariant": "Proměnná typu {variable} použitá v obecné třídě Protocol {class} by měla být kovariantní.",
+        "protocolVarianceInvariant": "Proměnná typu {variable} použitá v obecné třídě Protocol {class} by měla být invariantní.",
         "pyrightCommentInvalidDiagnosticBoolValue": "Za direktivou komentářů Pyright musí následovat znak =a hodnota true nebo false",
         "pyrightCommentInvalidDiagnosticSeverityValue": "Za direktivou komentářů Pyright musí následovat = a hodnota true, false, error, warning, information nebo none",
-        "pyrightCommentMissingDirective": "Za komentářem Pyright musí následovat direktiva (základní nebo striktní) nebo diagnostické pravidlo",
+        "pyrightCommentMissingDirective": "Za komentářem Pyright musí následovat direktiva (basic nebo strict) nebo diagnostické pravidlo.",
         "pyrightCommentNotOnOwnLine": "Komentáře Pyright používané k řízení nastavení na úrovni souborů se musí zobrazovat na vlastním řádku",
         "pyrightCommentUnknownDiagnosticRule": "{rule} je neznámé diagnostické pravidlo pro komentář pyright",
         "pyrightCommentUnknownDiagnosticSeverityValue": "{value} je neplatná hodnota pro komentář pyright; očekávalo se true, false, error, warning, information nebo none",
@@ -420,18 +421,18 @@
         "readOnlyArgCount": "Za „ReadOnly“ se očekával jeden argument typu",
         "readOnlyNotInTypedDict": "ReadOnly není v tomto kontextu povolené",
         "recursiveDefinition": "Typ „{name}“ nelze určit, protože odkazuje sám na sebe",
-        "relativeImportNotAllowed": "Relativní importy se nedají použít s formulářem importu .a; místo toho použijte from . import a",
-        "requiredArgCount": "Za povinným argumentem se očekával jeden argument typu",
+        "relativeImportNotAllowed": "Relativní importy se nedají použít s formulářem „import .a“; místo toho použijte „from . import a“.",
+        "requiredArgCount": "Za povinným argumentem (Required) se očekával jeden argument typu.",
         "requiredNotInTypedDict": "Required není v tomto kontextu povoleno",
         "returnInAsyncGenerator": "Příkaz Return s hodnotou není v asynchronním generátoru povolený",
         "returnMissing": "Funkce s deklarovaným návratovým typem „{returnType}“ musí vracet hodnotu na všech cestách kódu",
         "returnOutsideFunction": "„return“ se dá použít jenom v rámci funkce",
         "returnTypeContravariant": "Kontravariantní proměnnou typu nejde použít v návratovém typu",
-        "returnTypeMismatch": "Výraz typu {exprType} není kompatibilní s návratovým typem {returnType}.",
+        "returnTypeMismatch": "Typ {exprType} se nedá přiřadit k návratovému typu {returnType}.",
         "returnTypePartiallyUnknown": "Návratový typ {returnType} je částečně neznámý",
         "returnTypeUnknown": "Návratový typ je neznámý",
         "revealLocalsArgs": "Pro volání reveal_locals se neočekávaly žádné argumenty",
-        "revealLocalsNone": "V tomto oboru nejsou žádné místní hodnoty",
+        "revealLocalsNone": "V tomto oboru nejsou žádné místní hodnoty (locals).",
         "revealTypeArgs": "Pro volání reveal_type byl očekáván jeden poziční argument",
         "revealTypeExpectedTextArg": "Argument „expected_text“ pro funkci „reveal_type“ musí být hodnota literálu str",
         "revealTypeExpectedTextMismatch": "Neshoda typu textu; očekávaný počet: {expected}, počet, který byl přijat: {received}",
@@ -439,7 +440,7 @@
         "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",
+        "setterGetterTypeMismatch": "Typ hodnoty metody setter vlastnosti (property) není možné přiřadit návratovému typu getter.",
         "singleOverload": "{name} je označené jako přetížení, ale chybí další přetížení",
         "slotsAttributeError": "„{name}“ není zadaný v __slots__",
         "slotsClassVarConflict": "{name} je v konfliktu s proměnnou instance deklarovanou v __slots__",
@@ -449,12 +450,12 @@
         "staticClsSelfParam": "Statické metody by neměly přijímat parametr self nebo cls",
         "stdlibModuleOverridden": "„{path}“ přepisuje modul stdlib „{name}“",
         "stringNonAsciiBytes": "Znak jiný než ASCII není povolený v bajtech řetězcového literálu",
-        "stringNotSubscriptable": "Řetězcový výraz není možné v poznámce typu zadat jako dolní index uzavření celé poznámky do uvozovek",
+        "stringNotSubscriptable": "Řetězcový výraz není možné ve výrazu typu zadat jako dolní index. Uzavřete celý výraz do uvozovek.",
         "stringUnsupportedEscape": "Nepodporovaná řídicí sekvence v řetězcovém literálu",
         "stringUnterminated": "Řetězcový literál je neukončený",
-        "stubFileMissing": "Soubor zástupné procedury pro {importName} se nenašel",
-        "stubUsesGetAttr": "Soubor zástupné procedury typu je neúplný; __getattr__ zakrývá typové chyby pro modul",
-        "sublistParamsIncompatible": "Parametry podsestavy nejsou v Python 3.x podporované",
+        "stubFileMissing": "Soubor zástupné procedury (stub) pro „{importName}“ se nenašel.",
+        "stubUsesGetAttr": "Soubor zástupné procedury (stub) typu je neúplný; __getattr__ zakrývá typové chyby pro modul.",
+        "sublistParamsIncompatible": "Parametry sublist nejsou v Pythonu 3.x podporované.",
         "superCallArgCount": "Pro volání „super“ se očekávaly maximálně dva argumenty",
         "superCallFirstArg": "Jako první argument pro volání super se očekával typ třídy, ale přijal se {type}",
         "superCallSecondArg": "Druhý argument volání super musí být objekt nebo třída odvozená z typu {type}",
@@ -464,45 +465,46 @@
         "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ý.",
+        "ternaryNotAllowed": "Výraz ternary není ve výrazu 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",
-        "tupleAssignmentMismatch": "Výraz s typem „{type}“ se nedá přiřadit cílové řazené kolekci členů",
-        "tupleInAnnotation": "Výraz řazené kolekce členů není v poznámce typu povolený",
+        "tupleAssignmentMismatch": "Výraz s typem „{type}“ se nedá přiřadit cílové řazené kolekci členů (tuple).",
+        "tupleInAnnotation": "Výraz řazené kolekce členů (tuple) není ve výrazu typu povolený.",
         "tupleIndexOutOfRange": "Index {index} je pro typ {type} mimo rozsah",
         "typeAliasIllegalExpressionForm": "Neplatný formulář výrazu pro definici aliasu typu",
         "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",
+        "typeAliasRedeclared": "„{name}“ se deklaruje jako TypeAlias 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": "Alias typu definovaný v příkazu „typ“ nejde použít jako základní třídu",
+        "typeAliasTypeBaseClass": "Alias typu definovaný v příkazu \"type\" nejde použít jako základní třídu.",
         "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",
+        "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á",
-        "typeAliasTypeParamInvalid": "Seznam parametrů typu musí být řazená kolekce členů obsahující pouze typeVar, TypeVarTuple nebo ParamSpec",
+        "typeAliasTypeParamInvalid": "Seznam parametrů typu musí být řazená kolekce členů (tuple) obsahující pouze TypeVar, TypeVarTuple nebo ParamSpec.",
         "typeAnnotationCall": "Výraz volání není ve výrazu typu povolený",
         "typeAnnotationVariable": "Proměnná není ve výrazu typu povolená",
         "typeAnnotationWithCallable": "Argument typu pro „type“ musí být třída; volatelné objekty se nepodporují.",
-        "typeArgListExpected": "Očekával se parametr ParamSpec, tři tečky nebo seznam typů",
-        "typeArgListNotAllowed": "Výraz seznamu není pro tento argument typu povolený",
+        "typeArgListExpected": "Očekával se parametr ParamSpec, tři tečky nebo seznam (list) typů.",
+        "typeArgListNotAllowed": "Výraz seznamu (list) není pro tento argument typu povolený.",
         "typeArgsExpectingNone": "Pro třídu {name} se neočekávaly žádné argumenty typu",
         "typeArgsMismatchOne": "Očekával se jeden argument typu, ale bylo přijato {received}",
         "typeArgsMissingForAlias": "Pro alias obecného typu {name} se očekávaly argumenty typu",
         "typeArgsMissingForClass": "Očekávané argumenty typu pro obecnou třídu „{name}“",
         "typeArgsTooFew": "Pro {name} se zadalo příliš málo argumentů typu. Očekávalo se {expected}, ale přijalo se {received}",
         "typeArgsTooMany": "Pro „{name}“ se zadalo příliš mnoho argumentů typu. Očekával(o/y) se {expected}, ale přijal(o/y) se {received}",
-        "typeAssignmentMismatch": "Výraz typu {sourceType} není kompatibilní s deklarovaným typem {destType}.",
-        "typeAssignmentMismatchWildcard": "Symbol importu {name} má typ {sourceType}, který není kompatibilní s deklarovaným typem {destType}.",
-        "typeCallNotAllowed": "Volání type() by se nemělo používat v poznámce typu",
+        "typeAssignmentMismatch": "Typ {sourceType} se nedá přiřadit k deklarovanému typu {destType}.",
+        "typeAssignmentMismatchWildcard": "Symbol importu {name} má typ {sourceType}, který se nedá přiřadit k deklarovanému typu {destType}.",
+        "typeCallNotAllowed": "Volání type() by se nemělo používat ve výrazu typu.",
         "typeCheckOnly": "Název {name} je označený jako @type_check_only a dá se použít jenom v poznámkách typu",
-        "typeCommentDeprecated": "Použití komentářů typu je zastaralé místo toho použít anotaci typu",
+        "typeCommentDeprecated": "Použití komentářů type je zastaralé místo toho použít anotaci type.",
         "typeExpectedClass": "Očekávala se třída, ale byl přijat typ {type}.",
+        "typeFormArgs": "TypeForm přijímá jeden poziční argument.",
         "typeGuardArgCount": "Za TypeGuard nebo TypeIs byl očekáván jeden argument typu.",
         "typeGuardParamCount": "Funkce a metody ochrany typů definované uživatelem musí mít alespoň jeden vstupní parametr",
         "typeIsReturnType": "Návratový typ TypeIs ({returnType}) není konzistentní s typem parametru hodnoty ({type}).",
-        "typeNotAwaitable": "„{type}“ se nedá očekávat.",
+        "typeNotAwaitable": "„{type}“ není awaitable.",
         "typeNotIntantiable": "Není možné vytvořit instanci {type}",
         "typeNotIterable": "{type} není možné iterovat",
         "typeNotSpecializable": "Nepovedlo se specializovat typ „{type}“",
@@ -537,14 +539,14 @@
         "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",
+        "typeVarTupleDefaultNotUnpacked": "Výchozí typ TypeVarTuple musí být rozbalená řazená kolekce členů (tuple) nebo TypeVarTuple.",
         "typeVarTupleMustBeUnpacked": "Pro hodnotu TypeVarTuple se vyžaduje operátor rozbalení",
         "typeVarTupleUnknownParam": "{name} je neznámý parametr pro TypeVarTuple",
         "typeVarUnknownParam": "„{name}“ je neznámý parametr pro TypeVar",
         "typeVarUsedByOuterScope": "TypeVar „{name}“ se už používá ve vnějším oboru",
         "typeVarUsedOnlyOnce": "TypeVar {name} se v signatuře obecné funkce zobrazuje jenom jednou",
         "typeVarVariance": "TypeVar nemůže být kovariantní i kontravariantní",
-        "typeVarWithDefaultFollowsVariadic": "TypeVar {typeVarName} má výchozí hodnotu a nemůže následovat po typeVarTuple {variadicName}.",
+        "typeVarWithDefaultFollowsVariadic": "TypeVar {typeVarName} má výchozí hodnotu a nemůže následovat po TypeVarTuple {variadicName}.",
         "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",
@@ -552,8 +554,8 @@
         "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",
-        "typedDictClosedExtras": "Základní třída {name} je uzavřená třída TypedDict; Další položky musí být typu {type}.",
-        "typedDictClosedNoExtras": "Základní třída {name} je uzavřená hodnota TypedDict; Položky navíc nejsou povolené.",
+        "typedDictClosedExtras": "Základní třída {name} je closed TypedDict; další položky musí být typu {type}.",
+        "typedDictClosedNoExtras": "Základní třída {name} je closed TypedDict; položky navíc nejsou povolené.",
         "typedDictDelete": "Nepovedlo se odstranit položku v TypedDict",
         "typedDictEmptyName": "Názvy v rámci TypedDict nemůžou být prázdné",
         "typedDictEntryName": "Očekával se řetězcový literál pro název položky slovníku",
@@ -565,7 +567,7 @@
         "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",
+        "typedDictSecondArgDict": "Jako druhý parametr se očekával parametr dict nebo keyword.",
         "typedDictSecondArgDictEntry": "Očekávaná jednoduchá položka slovníku",
         "typedDictSet": "Nelze přiřadit položku v TypedDict",
         "unaccessedClass": "Třída „{name}“ není přístupná",
@@ -574,34 +576,36 @@
         "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ý.",
+        "unaryOperationNotAllowed": "Ve výrazu typu není povolený unární operátor.",
         "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í",
         "unexpectedUnindent": "Neočekává se unindent",
         "unhashableDictKey": "Klíč slovníku musí být hashovatelný",
-        "unhashableSetEntry": "Položka sady musí být hashovatelná",
-        "uninitializedAbstractVariables": "Proměnné definované v abstraktní základní třídě nejsou inicializovány v konečné třídě {classType}",
+        "unhashableSetEntry": "Položka set musí být hashovatelná.",
+        "uninitializedAbstractVariables": "Proměnné definované v abstraktní základní třídě nejsou inicializovány ve třídě final {classType}.",
         "uninitializedInstanceVariable": "Proměnná instance {name} není inicializována v těle třídy nebo v metodě __init__",
-        "unionForwardReferenceNotAllowed": "Syntaxi sjednocení není možné použít s operandem řetězce; použijte uvozovky kolem celého výrazu",
+        "unionForwardReferenceNotAllowed": "Syntaxi Union 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.",
-        "unnecessaryCast": "Nepotřebné volání„přetypování“; Typ už je „{type}“.",
+        "unionTypeArgCount": "Union vyžaduje dva nebo více argumentů typu.",
+        "unionUnpackedTuple": "Union nemůže obsahovat rozbalenou řazenou kolekci členů (tuple).",
+        "unionUnpackedTypeVarTuple": "Union nemůže obsahovat rozbalený typ TypeVarTuple.",
+        "unnecessaryCast": "Nepotřebné volání „cast“; typ už je „{type}“.",
         "unnecessaryIsInstanceAlways": "Zbytečné volání isinstance; {testType} je vždy instancí třídy {classType}",
+        "unnecessaryIsInstanceNever": "Unnecessary isinstance call; \"{testType}\" is never an instance of \"{classType}\"",
         "unnecessaryIsSubclassAlways": "Nepotřebné volání issubclass; „{testType}“ je vždy podtřídou třídy „{classType}“",
+        "unnecessaryIsSubclassNever": "Unnecessary issubclass call; \"{testType}\" is never a subclass of \"{classType}\"",
         "unnecessaryPyrightIgnore": "Nepotřebný komentář „# pyright: ignore“",
         "unnecessaryPyrightIgnoreRule": "Nepotřebné pravidlo # pyright: ignore: {name}",
         "unnecessaryTypeIgnore": "Nepotřebný komentář „# type: ignore“",
         "unpackArgCount": "Po rozbalení „Unpack“ se očekával jeden argument typu",
-        "unpackExpectedTypeVarTuple": "Jako argument typu pro rozbalení byl očekáván typ TypeVarTuple nebo řazená kolekce členů",
+        "unpackExpectedTypeVarTuple": "Jako argument typu pro Unpack byl očekáván typ TypeVarTuple nebo tuple.",
         "unpackExpectedTypedDict": "Byl očekáván argument typu TypedDict pro rozbalení Unpack",
         "unpackIllegalInComprehension": "Operace rozbalení není v porozumění povolená",
-        "unpackInAnnotation": "V poznámce typu není povolený operátor rozbalení",
+        "unpackInAnnotation": "Ve výrazu typu není povolený operátor rozbalení.",
         "unpackInDict": "Operace rozbalení není ve slovnících povolena",
-        "unpackInSet": "Operátor rozbalení není v sadě povolený",
-        "unpackNotAllowed": "Rozbalení se v tomto kontextu nepovoluje",
+        "unpackInSet": "Operátor rozbalení není v sadě (set) povolený.",
+        "unpackNotAllowed": "Unpack se v tomto kontextu nepovoluje.",
         "unpackOperatorNotAllowed": "Operace rozbalení není v tomto kontextu povolená",
         "unpackTuplesIllegal": "Operace rozbalení není povolená v řazených kolekcích členů před Pythonem 3.8",
         "unpackedArgInTypeArgument": "V tomto kontextu nelze použít rozbalené argumenty.",
@@ -618,34 +622,34 @@
         "unusedCallResult": "Výsledek výrazu volání je typu „{type}“ a nepoužívá se. přiřadit proměnné „_“, pokud je to záměrné",
         "unusedCoroutine": "Výsledek volání asynchronní funkce se nepoužívá; použijte operátor await nebo přiřaďte výsledek proměnné",
         "unusedExpression": "Hodnota výrazu se nepoužívá",
-        "varAnnotationIllegal": "Poznámky typu pro proměnné vyžadují Python 3.6 nebo novější; pro kompatibilitu s předchozími verzemi použijte komentáře typu",
-        "variableFinalOverride": "Proměnná {name} je označená jako final a přepíše proměnnou non-Final se stejným názvem ve třídě {className}",
-        "variadicTypeArgsTooMany": "Seznam argumentů typů může mít maximálně jeden rozbalený typ TypeVarTuple nebo řazenou kolekci členů",
+        "varAnnotationIllegal": "Poznámky type pro proměnné vyžadují Python 3.6 nebo novější; pro kompatibilitu s předchozími verzemi použijte komentáře type.",
+        "variableFinalOverride": "Proměnná {name} je označená jako Final a přepíše proměnnou non-Final se stejným názvem ve třídě {className}.",
+        "variadicTypeArgsTooMany": "Seznam argumentů typů může mít maximálně jeden rozbalený typ TypeVarTuple nebo tuple.",
         "variadicTypeParamTooManyAlias": "Alias typu může mít maximálně jeden parametr typu TypeVarTuple, ale přijal několik ({names})",
         "variadicTypeParamTooManyClass": "Obecná třída může mít maximálně jeden parametr typu TypeVarTuple, ale přijala více ({names})",
         "walrusIllegal": "Operátor := vyžaduje Python 3.8 nebo novější",
         "walrusNotAllowed": "Operátor := není v tomto kontextu povolen bez okolních závorek",
-        "wildcardInFunction": "Import se zástupnými znaky není v rámci třídy nebo funkce povolen",
-        "wildcardLibraryImport": "Import se zástupnými znaky z knihovny není povolený",
+        "wildcardInFunction": "V rámci třídy nebo funkce není povolen import se zástupnými znaky.",
+        "wildcardLibraryImport": "Není povolený import se zástupnými znaky z knihovny.",
         "wildcardPatternTypePartiallyUnknown": "Typ zachycený vzorem se zástupnými znaky je částečně neznámý",
         "wildcardPatternTypeUnknown": "Typ zachycený vzorem se zástupnými znaky je neznámý",
         "yieldFromIllegal": "Použití příkazu yield from vyžaduje Python 3.3 nebo novější",
         "yieldFromOutsideAsync": "yield from není v asynchronní funkci povoleno",
         "yieldOutsideFunction": "„yield“ není povoleno mimo funkci nebo lambdu",
         "yieldWithinComprehension": "„yield“ není povolené uvnitř porozumění",
-        "zeroCaseStatementsFound": "Výraz shody obsahovat alespoň jeden výraz velikosti písmen",
-        "zeroLengthTupleNotAllowed": "Řazená kolekce členů s nulovou délkou není v tomto kontextu povolená"
+        "zeroCaseStatementsFound": "Výraz shody (match) obsahovat alespoň jeden výraz velikosti písmen (case).",
+        "zeroLengthTupleNotAllowed": "Řazená kolekce členů (tuple) s nulovou délkou není v tomto kontextu povolená."
     },
     "DiagnosticAddendum": {
-        "annotatedNotAllowed": "Speciální formulář s poznámkami nejde použít s kontrolami instancí a tříd.",
+        "annotatedNotAllowed": "Speciální formulář Annotated nejde použít s kontrolami instancí a tříd.",
         "argParam": "Argument odpovídá parametru {paramName}",
         "argParamFunction": "Argument odpovídá parametru {paramName} ve funkci {functionName}",
         "argsParamMissing": "Parametr „*{paramName}“ nemá žádný odpovídající parametr",
         "argsPositionOnly": "Neshoda parametrů pouze s pozicí; Očekával(o/y) se {expected}, ale přijal(o/y) se {received}",
         "argumentType": "Typ argumentu je {type}",
         "argumentTypes": "Typy argumentů: ({types})",
-        "assignToNone": "Typ není kompatibilní s None.",
-        "asyncHelp": "Měli jste na mysli „async s“?",
+        "assignToNone": "Typ se nedá přiřadit k None.",
+        "asyncHelp": "Měli jste na mysli „async with“?",
         "baseClassIncompatible": "Základní třída {baseClass} není kompatibilní s typem {type}",
         "baseClassIncompatibleSubclass": "Základní třída {baseClass} je odvozená od třídy {subclass}, která není kompatibilní s typem {type}",
         "baseClassOverriddenType": "Základní třída {baseClass} poskytuje typ {type}, který je přepsán",
@@ -657,7 +661,7 @@
         "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",
+        "finalMethod": "Metoda Final",
         "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.",
@@ -665,15 +669,15 @@
         "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í",
+        "incompatibleDeleter": "Metoda deleter vlastnosti (property) je nekompatibilní.",
+        "incompatibleGetter": "Metoda getter vlastnosti (property) je nekompatibilní.",
+        "incompatibleSetter": "Metoda setter vlastnosti (property) 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í",
+        "invariantSuggestionDict": "Zvažte přepnutí z možnosti „dict“ na možnost „Mapping“, která je v typu hodnoty kovariantní.",
+        "invariantSuggestionList": "Zvažte přepnutí z možnosti „list“ na možnost „Sequence“, která je kovariantní.",
+        "invariantSuggestionSet": "Zvažte přepnutí z možnosti „set“ na možnost „Container“, která je kovariantní.",
         "isinstanceClassNotSupported": "{type} se pro kontroly instancí a tříd nepodporuje.",
         "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}",
@@ -681,14 +685,14 @@
         "keyUndefined": "{name} není definovaný klíč v typu {type}",
         "kwargsParamMissing": "Parametr „**{paramName}“ nemá žádný odpovídající parametr",
         "listAssignmentMismatch": "Typ {type} není kompatibilní s cílovým seznamem",
-        "literalAssignmentMismatch": "{sourceType} není kompatibilní s typem {destType}.",
+        "literalAssignmentMismatch": "{sourceType} se nedá přiřadit k typu {destType}.",
         "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 k atributu {name} třídy {classType}.",
         "memberIsAbstract": "„{type}.{name}“ není implementováno.",
         "memberIsAbstractMore": "a tento počet dalších: {count}...",
         "memberIsClassVarInProtocol": "„{name}“ je v protokolu definován jako ClassVar.",
-        "memberIsInitVar": "{name} je pole jen pro inicializaci.",
+        "memberIsInitVar": "{name} je pole init-only.",
         "memberIsInvariant": "{name} je invariantní, protože je proměnlivé",
         "memberIsNotClassVarInClass": "„{name}“ musí být definováno jako ClassVar, aby bylo kompatibilní s protokolem.",
         "memberIsNotClassVarInProtocol": "„{name}“ není v protokolu definován jako ClassVar.",
@@ -699,18 +703,18 @@
         "memberTypeMismatch": "{name} je nekompatibilní typ",
         "memberUnknown": "Atribut {name} je neznámý.",
         "metaclassConflict": "Metatřída {metaclass1} je v konfliktu s metatřídou {metaclass2}.",
-        "missingDeleter": "Chybí metoda odstranění vlastnosti",
-        "missingGetter": "Chybí metoda getter vlastnosti",
-        "missingSetter": "Chybí metoda nastavovacího kódu vlastnosti",
+        "missingDeleter": "Chybí metoda deleter vlastnosti (property).",
+        "missingGetter": "Chybí metoda getter vlastnosti (property).",
+        "missingSetter": "Chybí metoda setter vlastnosti (property).",
         "namedParamMissingInDest": "Další parametr „{name}“",
         "namedParamMissingInSource": "Chybí parametr klíčového slova „{name}“.",
         "namedParamTypeMismatch": "Parametr klíčového slova {name} typu {sourceType} není kompatibilní s typem {destType}.",
         "namedTupleNotAllowed": "NamedTuple se nedá použít pro kontroly instancí nebo tříd.",
         "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.",
+        "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.",
+        "noneNotAllowed": "Možnost None se nedá 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",
@@ -741,13 +745,13 @@
         "paramType": "Typ parametru je {paramType}",
         "privateImportFromPyTypedSource": "Místo toho importovat z modulu {module}",
         "propertyAccessFromProtocolClass": "Vlastnost definovaná v rámci třídy protokolu není přístupná jako proměnná třídy",
-        "propertyMethodIncompatible": "Metoda vlastnosti {name} není kompatibilní",
-        "propertyMethodMissing": "V přepsání chybí metoda vlastnosti „{name}“",
-        "propertyMissingDeleter": "Vlastnost {name} nemá definovaný odstraňovač",
-        "propertyMissingSetter": "Vlastnost {name} nemá definovanou metodu setter",
+        "propertyMethodIncompatible": "Metoda vlastnosti (property) {name} není kompatibilní.",
+        "propertyMethodMissing": "V přepsání (override) chybí metoda vlastnosti (property) „{name}“.",
+        "propertyMissingDeleter": "Vlastnost (property) {name} nemá definovanou metodu deleter.",
+        "propertyMissingSetter": "Vlastnost (property) {name} nemá definovanou metodu setter.",
         "protocolIncompatible": "{sourceType} není kompatibilní s protokolem {destType}",
         "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.",
+        "protocolRequiresRuntimeCheckable": "Třída Protocol 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>]",
@@ -759,17 +763,17 @@
         "seeParameterDeclaration": "Viz deklarace parametru",
         "seeTypeAliasDeclaration": "Zobrazit deklaraci aliasu typu",
         "seeVariableDeclaration": "Zobrazit deklaraci proměnné",
-        "tupleAssignmentMismatch": "Typ „{type}“ není kompatibilní s cílovou řazenou kolekcí členů",
-        "tupleEntryTypeMismatch": "Položka řazené kolekce členů {entry} je nesprávného typu",
-        "tupleSizeIndeterminateSrc": "Neshoda velikosti řazené kolekce členů; Očekávalo se {expected}, ale přijalo se neurčité.",
-        "tupleSizeIndeterminateSrcDest": "Neshoda velikosti řazené kolekce členů; Očekávalo se min. {expected}, ale přijalo se neurčité.",
-        "tupleSizeMismatch": "Neshoda velikosti řazené kolekce členů; Očekávalo se {expected}, ale přijalo se {received}.",
-        "tupleSizeMismatchIndeterminateDest": "Neshoda velikosti řazené kolekce členů; Očekávalo se min. {expected}, ale přijalo se {received}.",
-        "typeAliasInstanceCheck": "Alias typu vytvořený pomocí příkazu „typ“ se nedá použít s kontrolami instancí a tříd",
-        "typeAssignmentMismatch": "Typ {sourceType} není kompatibilní s typem {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}",
-        "typeIncompatible": "{sourceType} není kompatibilní s typem {destType}",
+        "tupleAssignmentMismatch": "Typ „{type}“ není kompatibilní s cílovou řazenou kolekcí členů (tuple).",
+        "tupleEntryTypeMismatch": "Položka řazené kolekce členů (tuple) {entry} je nesprávného typu.",
+        "tupleSizeIndeterminateSrc": "Neshoda velikosti řazené kolekce členů (tuple); očekávalo se {expected}, ale přijalo se neurčité.",
+        "tupleSizeIndeterminateSrcDest": "Neshoda velikosti řazené kolekce členů (tuple); očekávalo se min. {expected}, ale přijalo se neurčité.",
+        "tupleSizeMismatch": "Neshoda velikosti řazené kolekce členů (tuple); očekávalo se {expected}, ale přijalo se {received}.",
+        "tupleSizeMismatchIndeterminateDest": "Neshoda velikosti řazené kolekce členů (tuple); Očekávalo se {expected}, ale přijalo se {received}.",
+        "typeAliasInstanceCheck": "Alias typu vytvořený pomocí příkazu „type“ se nedá použít s kontrolami instancí a tříd.",
+        "typeAssignmentMismatch": "Typ {sourceType} se nedá přiřadit k typu {destType}.",
+        "typeBound": "Typ {sourceType} se nedá přiřadit k horní hranici {destType} pro proměnnou typu {name}.",
+        "typeConstrainedTypeVar": "Typ {type} se nedá přiřadit k proměnné omezeného typu {name}.",
+        "typeIncompatible": "{sourceType} se nedá přiřadit k {destType}.",
         "typeNotClass": "{type} není třída",
         "typeNotStringLiteral": "„{type}“ není řetězcový literál",
         "typeOfSymbol": "Typ „{name}“ je „{type}“",
@@ -780,7 +784,7 @@
         "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 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",
+        "typeVarTupleRequiresKnownLength": "Typ TypeVarTuple nemůže být vázaný na řazenou kolekci členů (tuple) 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}",
@@ -804,8 +808,8 @@
         "uninitializedAbstractVariable": "Proměnná instance {name} je definovaná v abstraktní základní třídě {classType}, ale neinicializovala se",
         "unreachableExcept": "{exceptionType} je podtřídou {parentType}",
         "useDictInstead": "Označte typ slovníku pomocí Dict[T1, T2]",
-        "useListInstead": "Použijte List[T] k označení typu seznamu nebo Union[T1, T2] k označení typu sjednocení",
-        "useTupleInstead": "Použijte tuple[T1, ..., Tn] k označení typu řazené kolekce členů nebo Union[T1, T2] k označení typu sjednocení",
+        "useListInstead": "Použijte List[T] k označení typu seznamu (list) nebo Union[T1, T2] k označení typu sjednocení (union).",
+        "useTupleInstead": "Použijte tuple[T1, ..., Tn] k označení typu řazené kolekce členů (tuple) nebo Union[T1, T2] k označení typu sjednocení (union).",
         "useTypeInstead": "Místo toho použít Type[T]",
         "varianceMismatchForClass": "Odchylka argumentu typu „{typeVarName}“ není kompatibilní se základní třídou „{className}“",
         "varianceMismatchForTypeAlias": "Rozptyl argumentu typu „{typeVarName}“ není kompatibilní s typem „{typeAliasParam}“"