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

package/dist/localization/package.nls.ru.json

@@ -14,7 +14,7 @@
         "indexValueDetail": "Значение индекса"
     },
     "Diagnostic": {
-        "abstractMethodInvocation": "Метод \"{method}\" не может быть вызван, так как является абстрактным",
+        "abstractMethodInvocation": "Невозможно вызвать метод \"{method}\", так как он является абстрактным и нереализованным",
         "annotatedParamCountMismatch": "Несоответствие числа аннотаций параметра: ожидается {expected}, но получено {received}",
         "annotatedTypeArgMissing": "Для \"Annotated\" ожидается один аргумент типа и одна или несколько заметок типа",
         "annotationFormatString": "В заметках типа не могут использоваться строковые литералы формата (f-строки)",
@@ -44,6 +44,7 @@
         "assignmentTargetExpr": "Выражение не может быть целевым объектом присваивания",
         "asyncNotInAsyncFunction": "Использование \"async\" не разрешено вне асинхронной функции",
         "awaitIllegal": "Инструкцию \"await\" можно использовать в Python версии не ранее 3.5",
+        "awaitNotAllowed": "Заметки типов не могут использовать \"await\"",
         "awaitNotInAsync": "Ключевое слово \"await\" допускается только в асинхронной функции",
         "backticksIllegal": "Выражения, окруженные одиночными обратными кавычками, не поддерживаются в Python 3.x; используйте вместо этого функцию repr",
         "baseClassCircular": "Класс не может быть производным от себя",
@@ -53,6 +54,7 @@
         "baseClassMethodTypeIncompatible": "Базовые классы класса \"{classType}\" определяют метод \"{name}\" несовместимым способом",
         "baseClassUnknown": "Неизвестный тип базового класса скрывает тип производного класса",
         "baseClassVariableTypeIncompatible": "Базовые классы класса \"{classType}\" определяют переменную \"{name}\" несовместимым способом",
+        "binaryOperationNotAllowed": "Бинарный оператор нельзя использовать в заметке типа",
         "bindTypeMismatch": "Не удалось привязать метод \"{methodName}\", \"{type}\" не может быть назначен параметру \"{paramName}\"",
         "breakOutsideLoop": "\"break\" можно использовать только внутри цикла",
         "callableExtraArgs": "В \"Callable\" ожидается только два аргумента типа",
@@ -69,6 +71,7 @@
         "classPatternBuiltInArgPositional": "Шаблон класса принимает только позиционный вложенный шаблон",
         "classPatternPositionalArgCount": "Слишком много позиционных шаблонов для класса \"{type}\"; ожидается {expected}, но получено {received}",
         "classPatternTypeAlias": "\"{type}\" нельзя использовать в шаблоне класса, поскольку это псевдоним специализированного типа",
+        "classPropertyDeprecated": "Свойства класса упразднены в Python 3.11 и не будут поддерживаться в Python 3.13",
         "classTypeParametersIllegal": "Синтаксис параметра типа класса может использоваться в Python версии не ниже 3.12.",
         "classVarFirstArgMissing": "Ожидается аргумент типа после \"ClassVar\"",
         "classVarNotAllowed": "Использование \"ClassVar\" в этом контексте не допускается",
@@ -82,6 +85,7 @@
         "comparisonAlwaysTrue": "Выражение всегда будет возвращать значение True, поскольку типы \"{leftType}\" и \"{rightType}\" не перекрываются",
         "comprehensionInDict": "Понимание не может использоваться с другими записями словаря",
         "comprehensionInSet": "Понимание не может использоваться с другими записями набора",
+        "concatenateContext": "\"Concatenate\" не допускается в этом контексте",
         "concatenateParamSpecMissing": "Последний аргумент типа для \"Concatenate\" должен быть ParamSpec или \"...\"",
         "concatenateTypeArgsMissing": "Для \"Concatenate\" требуется по крайней мере два аргумента типа",
         "conditionalOperandInvalid": "Недопустимый условный операнд типа \"{type}\"",
@@ -107,6 +111,7 @@
         "dataClassTransformFieldSpecifier": "Ожидается кортеж классов или функций, но получен тип \"{type}\"",
         "dataClassTransformPositionalParam": "Все аргументы \"dataclass_transform\" должны быть аргументами типа \"ключевое слово\"",
         "dataClassTransformUnknownArgument": "Аргумент \"{name}\" не поддерживается в dataclass_transform",
+        "dataProtocolInSubclassCheck": "Протоколы данных (включающие атрибуты, не связанные с методами) запрещены в вызовах issubclass",
         "declaredReturnTypePartiallyUnknown": "Объявленный тип возвращаемого значения \"{returnType}\" частично неизвестен",
         "declaredReturnTypeUnknown": "Объявленный тип возвращаемого значения неизвестен",
         "defaultValueContainsCall": "Вызовы функций и изменяемые объекты не разрешены в выражении значения параметра по умолчанию",
@@ -196,9 +201,10 @@
         "expectedTypeNotString": "Ожидался тип, но получен строковый литерал",
         "expectedTypeParameterName": "Ожидаемое имя параметра типа",
         "expectedYieldExpr": "Ожидаемое выражение в операторе yield",
-        "finalClassIsAbstract": "Класс \"{type}\" помечен как final (окончательный) и должен реализовать все абстрактные методы",
+        "finalClassIsAbstract": "Class \"{type}\" is marked final and must implement all abstract symbols",
         "finalContext": "\"Final\" не допускается в данном контексте",
         "finalMethodOverride": "Метод \"{name}\" не может переопределять окончательный метод, определенный в классе \"{className}\"",
+        "finalNonMethod": "Функцию \"{name}\" нельзя пометить как @окончательную, так как она не является методом",
         "finalReassigned": "\"{name}\" объявляется окончательным и не может быть переназначено",
         "finalRedeclaration": "\"{name}\" ранее объявлено как Final",
         "finalRedeclarationBySubclass": "\"{name}\" невозможно повторно объявить, поскольку в родительском классе \"{className}\" он объявлен как final",
@@ -242,6 +248,7 @@
         "inconsistentIndent": "Сумма отступа не соответствует предыдущему отступу",
         "inconsistentTabs": "Непоследовательное использование вкладок и пробелов в отступах",
         "initMustReturnNone": "Метод \"__init__\" должен возвращать тип None",
+        "initSubclassCallFailed": "Неверные аргументы ключевых слов для метода __init_subclass__",
         "initSubclassClsParam": "Переопределение метода __init_subclass__ должно принимать параметр \"cls\"",
         "instanceMethodSelfParam": "Методы экземпляра должны принимать параметр \"self\"",
         "instanceVarOverridesClassVar": "Переменная экземпляра \"{name}\" переопределяет переменную класса с тем же именем в классе \"{className}\"",
@@ -265,6 +272,7 @@
         "listAssignmentMismatch": "Выражение с типом \"{type}\" нельзя присвоить целевому списку",
         "listInAnnotation": "Списочное выражение не разрешено в заметке типа",
         "literalEmptyArgs": "Ожидается один или несколько аргументов типа после \"Literal\"",
+        "literalNotAllowed": "Невозможно использовать \"Literal\" в этом контексте без аргумента типа",
         "literalNotCallable": "Не удается создать экземпляр типа литерала",
         "literalUnsupportedType": "Аргументы типа для \"Literal\" должны иметь значение None, литеральное значение (int, bool, str или bytes) или значение перечислимого типа",
         "matchIncompatible": "Операторы соответствия могут использоваться в Python версии не ниже 3.10",
@@ -281,7 +289,6 @@
         "methodOrdering": "Не удается создать согласованный порядок методов",
         "methodOverridden": "\"{name}\" переопределяет метод с тем же именем в классе \"{className}\" с несовместимым типом \"{type}\"",
         "methodReturnsNonObject": "Метод \"{name}\" не возвращает объект",
-        "missingProtocolMembers": "Класс является производным от одного или нескольких классов протокола, но не реализует все необходимые элементы",
         "missingSuperCall": "Метод \"{methodName}\" не вызывает метод с тем же именем в родительском классе",
         "moduleAsType": "Модуль не может использоваться в качестве типа",
         "moduleNotCallable": "Модуль не является вызываемым",
@@ -297,11 +304,13 @@
         "namedTupleNoTypes": "\"namedtuple\" не предоставляет типов для записей кортежа; используйте вместо него \"NamedTuple\"",
         "namedTupleSecondArg": "В качестве второго аргумента ожидается список записей именованного кортежа",
         "newClsParam": "Переопределение метода __new__ должно принимать параметр \"cls\"",
+        "newTypeAnyOrUnknown": "Второй аргумент для NewType должен быть известным классом, а не вариантом \"Любой\" или \"Неизвестный\"",
         "newTypeBadName": "Первый аргумент NewType должен быть строковым литералом",
         "newTypeLiteral": "NewType нельзя использовать с типом литерала",
+        "newTypeNameMismatch": "NewType должен быть назначен переменной с тем же именем",
         "newTypeNotAClass": "В NewType в качестве второго аргумента ожидается класс",
         "newTypeParamCount": "Для NewType требуются два позиционных аргумента",
-        "newTypeProtocolClass": "NewType нельзя использовать с классом протокола",
+        "newTypeProtocolClass": "NewType нельзя использовать со структурным типом (протокол или класс TypedDict)",
         "noOverload": "Не существует перегрузок для \"{name}\", соответствующих указанным аргументам",
         "noReturnContainsReturn": "Функция с объявленным типом возвращаемого значения \"NoReturn\" не может содержать оператор return",
         "noReturnContainsYield": "Функция с объявленным типом возвращаемого значения \"NoReturn\" не может содержать инструкцию yield",
@@ -333,8 +342,12 @@
         "overlappingKeywordArgs": "Типизированный словарь перекрывается с параметром ключевого слова: {names}",
         "overlappingOverload": "Перегрузка {obscured} для \"{name}\" никогда не будет использоваться, так как ее параметры перекрывают перегрузку {obscuredBy}",
         "overloadAbstractMismatch": "Все перегруженные методы должны быть абстрактными или не абстрактными",
+        "overloadClassMethodInconsistent": "Перегрузки для \"{name}\" используют @classmethod несогласованно",
+        "overloadFinalInconsistencyImpl": "Перегрузка для \"{name}\" помечена как @окончательная, но реализация — нет",
+        "overloadFinalInconsistencyNoImpl": "Перегрузка {index} для \"{name}\" помечена как @окончательная, но перегрузка 1 — нет",
         "overloadImplementationMismatch": "Перегруженная реализация не согласована с сигнатурой перегрузки {index}",
         "overloadReturnTypeMismatch": "Перегрузка {prevIndex} для \"{name}\" перекрывает перегрузку {newIndex} и возвращает несовместимый тип",
+        "overloadStaticMethodInconsistent": "Перегрузки для \"{name}\" используют @staticmethod несогласованно",
         "overloadWithoutImplementation": "\"{name}\" помечен как перегруженный, но реализация не предоставлена",
         "overriddenMethodNotFound": "Метод \"{name}\" помечен как переопределение, но базового метода с таким же именем нет.",
         "overrideDecoratorMissing": "Метод \"{name}\" не помечен в качестве переопределения, но переопределяет метод в классе \"{className}\"",
@@ -375,6 +388,8 @@
         "protocolBaseClass": "Класс протокола \"{classType}\" не может быть производным от непротокольного класса \"{baseType}\"",
         "protocolBaseClassWithTypeArgs": "Аргументы типа не допускаются с классом протокола при использовании синтаксиса параметра типа",
         "protocolIllegal": "Ключевое слово \"Protocol\" можно использовать в Python версии не ниже 3.7",
+        "protocolNotAllowed": "Невозможно использовать \"Protocol\" в этом контексте",
+        "protocolUnsafeOverlap": "Класс небезопасно перекрывает \"{name}\" и может вызвать совпадение во время выполнения",
         "protocolVarianceContravariant": "Переменная типа \"{variable}\", используемая в универсальном протоколе \"{class}\", должна быть контравариантной.",
         "protocolVarianceCovariant": "Переменная типа \"{variable}\", используемая в универсальном протоколе \"{class}\", должна быть ковариантной",
         "protocolVarianceInvariant": "Переменная типа \"{variable}\", используемая в универсальном протоколе \"{class}\", должна быть инвариантной",
@@ -405,6 +420,7 @@
         "revealTypeExpectedTextMismatch": "Несоответствие текста в типе; ожидалось \"{expected}\", но получено \"{received}\"",
         "revealTypeExpectedTypeMismatch": "Несоответствие типов; ожидается \"{expected}\", но получено \"{received}\"",
         "selfTypeContext": "'В этом контексте ключевое слово \"Self\" недопустимо",
+        "selfTypeMetaclass": "\"Self\" нельзя использовать в метаклассе (подкласс \"type\")",
         "selfTypeWithTypedSelfOrCls": "Ключевое слово \"Self\" нельзя использовать в функции с параметром \"self\" или \"cls\" с заметкой типа, отличной от \"Self\".",
         "setterGetterTypeMismatch": "Тип значения метода задания свойства нельзя присвоить типу возвращаемого значения метода получения",
         "singleOverload": "Элемент \"{name}\" помечен как перегруженный, но дополнительные перегрузки отсутствуют",
@@ -431,6 +447,7 @@
         "symbolIsUnbound": "Элемент \"{name}\" не привязан",
         "symbolIsUndefined": "\"{name}\" не определено",
         "symbolOverridden": "\"{name}\" переопределяет символ с тем же именем в классе \"{className}\"",
+        "ternaryNotAllowed": "Тернарное выражение не разрешено в заметке типа",
         "totalOrderingMissingMethod": "Чтобы можно было использовать total_ordering, в классе должен быть определен один из операторов: \"__lt__\", \"__le__\", \"__gt__\" или \"__ge__\"",
         "trailingCommaInFromImport": "Конечные запятые можно использовать только при заключении в скобки",
         "tryWithoutExcept": "В операторе try должно быть хотя бы одно предложение exclude или finally.",
@@ -441,7 +458,9 @@
         "typeAliasIsRecursiveDirect": "Псевдоним типа \"{name}\" не может использовать себя в своем определении",
         "typeAliasNotInModuleOrClass": "TypeAlias можно определить только внутри области модуля или класса",
         "typeAliasRedeclared": "\"{name}\" объявлен как TypeAlias и может быть присвоен только один раз",
+        "typeAliasStatementBadScope": "Утверждение типа можно использовать только внутри области модуля или класса",
         "typeAliasStatementIllegal": "Оператор псевдонима типа можно использовать в Python версии не ниже 3.12",
+        "typeAliasTypeBaseClass": "A type alias defined in a \"type\" statement cannot be used as a base class",
         "typeAliasTypeMustBeAssigned": "TypeAliasType должен быть назначен переменной с тем же именем, что и псевдоним типа",
         "typeAliasTypeNameArg": "Первый аргумент TypeAliasType должен быть строковым литералом, представляющим имя псевдонима типа",
         "typeAliasTypeNameMismatch": "Имя псевдонима типа должно соответствовать имени переменной, которой оно назначено",
@@ -498,6 +517,7 @@
         "typeVarPossiblyUnsolvable": "Переменная типа \"{name}\" может остаться нерешенной, если вызывающая сторона не указывает аргумент для параметра \"{param}\"",
         "typeVarScopedToReturnType": "Переменная типа \"{name}\" относится к вызываемому объекту в возвращаемом типе, и на нее нельзя ссылаться в тексте функции.",
         "typeVarSingleConstraint": "TypeVar должен иметь не менее двух ограниченных типов",
+        "typeVarTupleConstraints": "TypeVarTuple не может использовать ограничения значений",
         "typeVarTupleContext": "TypeVarTuple не допускается в этом контексте",
         "typeVarTupleDefaultNotUnpacked": "Тип по умолчанию TypeVarTuple должен быть распакованным кортежем или TypeVarTuple.",
         "typeVarTupleMustBeUnpacked": "Для значения TypeVarTuple требуется оператор распаковки",
@@ -509,6 +529,7 @@
         "typeVarWithoutDefault": "\"{name}\" не может появиться после \"{other}\" в списке параметров типа, так как у него нет типа по умолчанию",
         "typeVarsNotInGenericOrProtocol": "Generic[] и Protocol[] должны включать все переменные типа",
         "typedDictAccess": "Не удалось получить доступ к элементу в TypedDict",
+        "typedDictAssignedName": "TypedDict необходимо присвоить переменной с именем \"{name}\"",
         "typedDictBadVar": "Классы TypedDict могут содержать только заметки с типом",
         "typedDictBaseClass": "Все базовые классы для классов TypedDict также должны быть классами TypedDict",
         "typedDictBoolParam": "От параметра \"{name}\" ожидается значение True или False",
@@ -517,8 +538,12 @@
         "typedDictEntryName": "Для имени записи словаря ожидается строковый литерал",
         "typedDictEntryUnique": "Имена в словаре должны быть уникальными",
         "typedDictExtraArgs": "Дополнительные аргументы TypedDict не поддерживаются",
+        "typedDictFieldNotRequiredRedefinition": "Поле TypedDict \"{name}\" нельзя переопределить как необязательное",
         "typedDictFieldReadOnlyRedefinition": "Поле TypedDict \"{name}\" нельзя переопределить как доступное только для чтения",
+        "typedDictFieldRequiredRedefinition": "Поле TypedDict \"{name}\" нельзя переопределить как обязательное",
         "typedDictFirstArg": "В качестве первого аргумента ожидается имя класса TypedDict",
+        "typedDictInitsubclassParameter": "TypedDict не поддерживает параметр __init_subclass__ \"{name}\"",
+        "typedDictNotAllowed": "Невозможно использовать \"TypedDict\" в этом контексте",
         "typedDictSecondArgDict": "В качестве второго параметра ожидается словарь или ключевое слово",
         "typedDictSecondArgDictEntry": "Ожидается простая запись словаря",
         "typedDictSet": "Не удалось назначить элемент в TypedDict",
@@ -528,6 +553,7 @@
         "unaccessedSymbol": "Доступ к \"{name}\" не осуществляется",
         "unaccessedVariable": "Доступ к переменной \"{name}\" не производится",
         "unannotatedFunctionSkipped": "Анализ функции \"{name}\" пропущен, так как она не аннотирована.",
+        "unaryOperationNotAllowed": "Унарный оператор нельзя использовать в заметке типа",
         "unexpectedAsyncToken": "После \"async\" ожидается \"def\", \"with\" или \"for\"",
         "unexpectedExprToken": "Непредвиденный токен в конце выражения",
         "unexpectedIndent": "Непредвиденный отступ",
@@ -539,6 +565,8 @@
         "unionForwardReferenceNotAllowed": "Синтаксис объединения не может использоваться со строковым операндом; заключите всё выражение в кавычки",
         "unionSyntaxIllegal": "Альтернативный синтаксис объединений можно использовать в версии Python не ниже 3.10",
         "unionTypeArgCount": "Для объединения требуется два или более аргумента типа",
+        "unionUnpackedTuple": "Объединение не может включать распакованный кортеж",
+        "unionUnpackedTypeVarTuple": "Объединение не может включать распакованный TypeVarTuple",
         "unmatchedEndregionComment": "Для #endregion отсутствует соответствующий #region",
         "unmatchedRegionComment": "Для #endregion отсутствует соответствующий #endregion",
         "unnecessaryCast": "Ненужный вызов \"cast\"; тип уже является \"{type}\"",
@@ -605,21 +633,26 @@
         "conditionalRequiresBool": "Метод __bool__ для типа \"{operandType}\" возвращает тип \"{boolReturnType}\", а не \"bool\"",
         "dataClassFieldLocation": "Объявление поля",
         "dataClassFrozen": "Элемент \"{name}\" зафиксирован",
+        "dataProtocolUnsupported": "\"{name}\" является протоколом данных",
         "descriptorAccessBindingFailed": "Не удалось привязать метод \"{name}\" для класса дескриптора \"{className}\"",
         "descriptorAccessCallFailed": "Не удалось вызвать метод \"{name}\" для класса дескриптора \"{className}\"",
         "finalMethod": "Окончательный метод",
         "functionParamDefaultMissing": "В параметре \"{name}\" отсутствует аргумент по умолчанию.",
         "functionParamName": "Несоответствие имени параметра: \"{destName}\" и \"{srcName}\"",
+        "functionParamPositionOnly": "Несоответствие исключительно позиционных параметров; параметр \"{name}\" не является исключительно позиционным",
         "functionReturnTypeMismatch": "Тип возвращаемого значения функции \"{sourceType}\" несовместим с типом \"{destType}\"",
         "functionTooFewParams": "Функция принимает слишком мало позиционных параметров; ожидалось {expected}, но получено {received}",
         "functionTooManyParams": "Функция принимает слишком много позиционных параметров; ожидалось {expected}, но получено {received}",
+        "genericClassNotAllowed": "Универсальный тип с аргументами типа запрещен для проверок экземпляров или классов",
         "incompatibleDeleter": "Метод удаления свойства является несовместимым",
         "incompatibleGetter": "Несовместимый метод получения свойств",
         "incompatibleSetter": "Метод задания свойства является несовместимым",
         "initMethodLocation": "Метод __init__ определен в классе \"{type}\"",
         "initMethodSignature": "Сигнатура __init__ — \"{type}\"",
+        "initSubclassLocation": "Метод __init_subclass__ определен в классе \"{name}\"",
         "invariantSuggestionDict": "Рассмотрите возможность перехода с \"dict\" на \"Mapping\", являющийся ковариантным по типу значения.",
         "invariantSuggestionList": "Рассмотрите возможность перехода с \"list\" на \"Sequence\", являющийся ковариантным.",
+        "invariantSuggestionSet": "Рассмотрите возможность переключения с \"set\" на \"Container\", который является ковариантным",
         "keyNotRequired": "\"{name}\" не является обязательным ключом в \"{type}\", поэтому доступ может вызвать исключение во время выполнения",
         "keyReadOnly": "\"{name}\" является ключом только для чтения в \"{type}\"",
         "keyRequiredDeleted": "\"{name}\" является обязательным ключом и не подлежит удалению",
@@ -630,11 +663,14 @@
         "matchIsNotExhaustiveHint": "Если не предполагается исчерпывающая обработка, добавьте \"case _: pass\"",
         "matchIsNotExhaustiveType": "Тип \"{type}\" не обрабатывается",
         "memberAssignment": "Выражение типа \"{type}\" не может быть назначено элементу \"{name}\" класса \"{classType}\"",
-        "memberIsAbstract": "\"{type}.{name}\" является абстрактным",
+        "memberIsAbstract": "\"{type}.{name}\" is not implemented",
         "memberIsAbstractMore": "и еще {{count}}",
+        "memberIsClassVarInProtocol": "\"{name}\" определено как класс ClassVar в протоколе",
         "memberIsFinalInProtocol": "\"{name}\" помечено в протоколе как Final",
         "memberIsInitVar": "Элемент \"{name}\" является полем только для инициализации",
         "memberIsInvariant": "Элемент \"{name}\" инвариантен, поскольку помечен как mutable",
+        "memberIsNotClassVarInClass": "\"{name}\" must be defined as a ClassVar to be compatible with protocol",
+        "memberIsNotClassVarInProtocol": "\"{name}\" не определено как класс ClassVar в протоколе",
         "memberIsNotFinalInProtocol": "\"{name}\" не помечен как окончательный в протоколе",
         "memberIsWritableInProtocol": "\"{name}\" доступно для записи в протоколе",
         "memberSetClassVar": "Элемент \"{name}\" не может быть назначен через экземпляр класса, так как это ClassVar",
@@ -643,14 +679,15 @@
         "metaclassConflict": "Метакласс \"{metaclass1}\" конфликтует с \"{metaclass2}\"",
         "missingDeleter": "Отсутствует метод удаления свойства",
         "missingGetter": "Отсутствует метод получения свойства",
-        "missingProtocolMember": "Элемент \"{name}\" объявлен в классе протокола \"{classType}\"",
         "missingSetter": "Отсутствует метод установки свойств",
         "namedParamMissingInDest": "В целевом объекте отсутствует параметр ключевого слова \"{name}\"",
         "namedParamMissingInSource": "В источнике нет параметра ключевого слова \"{name}\"",
         "namedParamTypeMismatch": "Параметр ключевого слова {index} типа \"{sourceType}\" нельзя присвоить типу \"{destType}\"",
         "newMethodLocation": "Метод __new__ определен в классе \"{type}\"",
         "newMethodSignature": "Сигнатура метода __new__ требует \"{type}\"",
+        "newTypeClassNotAllowed": "Класс, созданный с NewType, нельзя использовать с проверками экземпляров и классов",
         "noOverloadAssignable": "Нет перегруженной функции, соответствующей типу \"{type}\"",
+        "noneNotAllowed": "Их невозможно использовать для проверок экземпляров или классов",
         "orPatternMissingName": "Отсутствуют имена: {name}",
         "overloadIndex": "Наилучшее совпадение: {index} перегрузки",
         "overloadNotAssignable": "Одна или несколько перегрузок \"{name}\" не подлежат присвоению",
@@ -670,7 +707,7 @@
         "overrideParamName": "Несоответствие имени параметра {index}: базовый параметр называется \"{baseName}\", параметр переопределения называется \"{overrideName}\"",
         "overrideParamNameExtra": "Параметр \"{name}\" отсутствует в базовом классе",
         "overrideParamNameMissing": "Параметр \"{name}\" отсутствует в переопределении",
-        "overrideParamNamePositionOnly": "Несоответствие параметра {index}: базовый параметр \"{baseName}\" является параметром ключевого слова, параметр переопределения предназначен только для позиции\"",
+        "overrideParamNamePositionOnly": "Несоответствие параметра {index}: базовый параметр \"{baseName}\" является параметром ключевого слова, параметр переопределения предназначен только для позиции",
         "overrideParamNoDefault": "Несоответствие параметра {index}: базовый параметр содержит значение аргумента по умолчанию, параметр переопределения — нет",
         "overrideParamType": "Несоответствие типа параметра {index}: базовый параметр имеет тип \"{baseType}\", параметр переопределения имеет тип \"{overrideType}\"",
         "overridePositionalParamCount": "Несоответствие позиционного подсчета параметров. Базовый метод содержит {baseCount}, но переопределение содержит {overrideCount}",
@@ -686,9 +723,10 @@
         "propertyMissingDeleter": "Для свойства \"{name}\" не определен метод удаления",
         "propertyMissingSetter": "Для свойства \"{name}\" не определен метод задания",
         "protocolIncompatible": "\"{sourceType}\" несовместим с протоколом \"{destType}\"",
-        "protocolMemberClassVar": "\"{name}\" не является переменной класса",
         "protocolMemberMissing": "\"{name}\" отсутствует.",
+        "protocolRequiresRuntimeCheckable": "Класс протокола должен быть @runtime_checkable, чтобы его можно было использовать при проверках экземпляров и классов",
         "protocolSourceIsNotConcrete": "\"{sourceType}\" не является конкретным типом класса и не может быть присвоен типу \"{destType}\"",
+        "protocolUnsafeOverlap": "Атрибуты \"{name}\" используют те же имена, что и протокол",
         "pyrightCommentIgnoreTip": "Для подавления диагностики в одной строке используйте конструкцию \"# pyright: ignore[<правила диагностики>]",
         "readOnlyAttribute": "Атрибут \"{name}\" доступен только для чтения",
         "seeClassDeclaration": "См. объявление класса",
@@ -702,6 +740,7 @@
         "tupleEntryTypeMismatch": "Запись кортежа {entry} имеет неверный тип",
         "tupleSizeIndeterminate": "Несоответствие размеров кортежа: ожидается \"{expected}\", но получено неопределенное значение",
         "tupleSizeMismatch": "Несоответствие размеров кортежа: ожидается \"{expected}\", но получено \"{received}\"",
+        "typeAliasInstanceCheck": "Type alias created with \"type\" statement cannot be used with instance and class checks",
         "typeAssignmentMismatch": "Тип \"{sourceType}\" нельзя присвоить типу \"{destType}\"",
         "typeBound": "Тип \"{sourceType}\" несовместим с привязанным типом \"{destType}\" для переменной типа \"{name}\"",
         "typeConstrainedTypeVar": "Тип \"{type}\" несовместим с переменной ограниченного типа \"{name}\"",
@@ -715,11 +754,13 @@
         "typeVarIsContravariant": "Параметр типа \"{name}\" является контравариантным, но \"{sourceType}\" не является супертипом \"{destType}\"",
         "typeVarIsCovariant": "Параметр типа \"{name}\" является ковариантным, но \"{sourceType}\" не является подтипом \"{destType}\"",
         "typeVarIsInvariant": "Параметр типа \"{name}\" является инвариантным, но \"{sourceType}\" не совпадает с \"{destType}\"",
-        "typeVarNotAllowed": "TypeVar или универсальный тип с аргументами типа не разрешены",
+        "typeVarNotAllowed": "TypeVar не допускается для проверок экземпляров или классов",
         "typeVarTupleRequiresKnownLength": "TypeVarTuple не может граничить с кортежем неизвестной длины",
+        "typeVarUnnecessarySuggestion": "Вместо этого используйте {type}",
         "typeVarUnsolvableRemedy": "Укажите перегрузку, которая указывает тип возвращаемого значения, если аргумент не передается",
         "typeVarsMissing": "Отсутствуют переменные типа: {names}",
         "typedDictBaseClass": "Класс \"{type}\" не является TypedDict",
+        "typedDictClassNotAllowed": "Класс TypedDict не допускается для проверок экземпляров или классов",
         "typedDictFieldMissing": "\"{name}\" отсутствует в \"{type}\"",
         "typedDictFieldNotReadOnly": "\"{name}\" не является элементом \"{type}\" только для чтения",
         "typedDictFieldNotRequired": "\"{name}\" не является обязательным в \"{type}\"",