@zzzen/pyright-internal 1.1.254

package/dist/localization/localize.d.ts

@@ -0,0 +1,1324 @@
+export declare class ParameterizedString<T extends {}> {
+    private _formatString;
+    constructor(_formatString: string);
+    format(params: T): string;
+    getFormatString(): string;
+}
+export declare function setLocaleOverride(locale: string): void;
+export declare namespace Localizer {
+    namespace Diagnostic {
+        const annotatedParamCountMismatch: () => ParameterizedString<{
+            expected: number;
+            received: number;
+        }>;
+        const annotatedTypeArgMissing: () => string;
+        const annotationFormatString: () => string;
+        const annotationNotSupported: () => string;
+        const annotationSpansStrings: () => string;
+        const annotationStringEscape: () => string;
+        const argAssignment: () => ParameterizedString<{
+            argType: string;
+            paramType: string;
+        }>;
+        const argAssignmentFunction: () => ParameterizedString<{
+            argType: string;
+            paramType: string;
+            functionName: string;
+        }>;
+        const argAssignmentParam: () => ParameterizedString<{
+            argType: string;
+            paramType: string;
+            paramName: string;
+        }>;
+        const argAssignmentParamFunction: () => ParameterizedString<{
+            argType: string;
+            paramType: string;
+            paramName: string;
+            functionName: string;
+        }>;
+        const argMissingForParam: () => ParameterizedString<{
+            name: string;
+        }>;
+        const argMissingForParams: () => ParameterizedString<{
+            names: string;
+        }>;
+        const argMorePositionalExpectedCount: () => ParameterizedString<{
+            expected: number;
+        }>;
+        const argMorePositionalExpectedOne: () => string;
+        const argPositional: () => string;
+        const argPositionalExpectedCount: () => ParameterizedString<{
+            expected: number;
+        }>;
+        const argPositionalExpectedOne: () => string;
+        const argTypePartiallyUnknown: () => string;
+        const argTypeUnknown: () => string;
+        const assertAlwaysTrue: () => string;
+        const assertTypeArgs: () => string;
+        const assertTypeTypeMismatch: () => ParameterizedString<{
+            expected: string;
+            received: string;
+        }>;
+        const assignmentExprContext: () => string;
+        const assignmentExprComprehension: () => ParameterizedString<{
+            name: string;
+        }>;
+        const assignmentExprInSubscript: () => string;
+        const assignmentInProtocol: () => string;
+        const assignmentTargetExpr: () => string;
+        const asyncNotInAsyncFunction: () => string;
+        const awaitIllegal: () => string;
+        const awaitNotInAsync: () => string;
+        const backticksIllegal: () => string;
+        const baseClassCircular: () => string;
+        const baseClassInvalid: () => string;
+        const baseClassFinal: () => ParameterizedString<{
+            type: string;
+        }>;
+        const baseClassMethodTypeIncompatible: () => ParameterizedString<{
+            classType: string;
+            name: string;
+        }>;
+        const baseClassVariableTypeIncompatible: () => ParameterizedString<{
+            classType: string;
+            name: string;
+        }>;
+        const baseClassUnknown: () => string;
+        const bindTypeMismatch: () => ParameterizedString<{
+            type: string;
+            methodName: string;
+            paramName: string;
+        }>;
+        const breakOutsideLoop: () => string;
+        const callableExtraArgs: () => string;
+        const callableFirstArg: () => string;
+        const callableSecondArg: () => string;
+        const casePatternIsIrrefutable: () => string;
+        const classAlreadySpecialized: () => ParameterizedString<{
+            type: string;
+        }>;
+        const classDecoratorTypeUnknown: () => string;
+        const classDefinitionCycle: () => ParameterizedString<{
+            name: string;
+        }>;
+        const classGetItemClsParam: () => string;
+        const classMethodClsParam: () => string;
+        const classNotRuntimeSubscriptable: () => ParameterizedString<{
+            name: string;
+        }>;
+        const classPatternBuiltInArgCount: () => string;
+        const classPatternBuiltInArgPositional: () => string;
+        const classPatternTypeAlias: () => ParameterizedString<{
+            type: string;
+        }>;
+        const classVarNotAllowed: () => string;
+        const classVarFirstArgMissing: () => string;
+        const classVarOverridesInstanceVar: () => ParameterizedString<{
+            name: string;
+            className: string;
+        }>;
+        const classVarTooManyArgs: () => string;
+        const classVarWithTypeVar: () => string;
+        const clsSelfParamTypeMismatch: () => ParameterizedString<{
+            name: string;
+            classType: string;
+        }>;
+        const codeTooComplexToAnalyze: () => string;
+        const comparisonAlwaysFalse: () => ParameterizedString<{
+            leftType: string;
+            rightType: string;
+        }>;
+        const comparisonAlwaysTrue: () => ParameterizedString<{
+            leftType: string;
+            rightType: string;
+        }>;
+        const comprehensionInDict: () => string;
+        const comprehensionInSet: () => string;
+        const concatenateParamSpecMissing: () => string;
+        const concatenateTypeArgsMissing: () => string;
+        const constantRedefinition: () => ParameterizedString<{
+            name: string;
+        }>;
+        const constructorNoArgs: () => ParameterizedString<{
+            type: string;
+        }>;
+        const constructorParametersMismatch: () => ParameterizedString<{
+            classType: string;
+        }>;
+        const continueInFinally: () => string;
+        const continueOutsideLoop: () => string;
+        const dataClassBaseClassNotFrozen: () => string;
+        const dataClassFieldWithDefault: () => string;
+        const dataClassFieldWithoutAnnotation: () => string;
+        const dataClassPostInitParamCount: () => ParameterizedString<{
+            expected: number;
+        }>;
+        const dataClassPostInitType: () => ParameterizedString<{
+            fieldName: string;
+        }>;
+        const dataClassSlotsOverwrite: () => string;
+        const dataClassTransformExpectedBoolLiteral: () => string;
+        const dataClassTransformFieldSpecifier: () => ParameterizedString<{
+            type: string;
+        }>;
+        const dataClassTransformPositionalParam: () => string;
+        const dataClassTransformUnknownArgument: () => ParameterizedString<{
+            name: string;
+        }>;
+        const declaredReturnTypePartiallyUnknown: () => ParameterizedString<{
+            returnType: string;
+        }>;
+        const declaredReturnTypeUnknown: () => string;
+        const defaultValueContainsCall: () => string;
+        const defaultValueNotAllowed: () => string;
+        const defaultValueNotEllipsis: () => string;
+        const deprecatedType: () => ParameterizedString<{
+            version: string;
+            replacement: string;
+        }>;
+        const dictExpandIllegalInComprehension: () => string;
+        const dictInAnnotation: () => string;
+        const dictKeyValuePairs: () => string;
+        const dictUnpackIsNotMapping: () => string;
+        const delTargetExpr: () => string;
+        const dunderAllSymbolNotPresent: () => ParameterizedString<{
+            name: string;
+        }>;
+        const duplicateArgsParam: () => string;
+        const duplicateBaseClass: () => string;
+        const duplicateCatchAll: () => string;
+        const duplicateEnumMember: () => ParameterizedString<{
+            name: string;
+        }>;
+        const duplicateGenericAndProtocolBase: () => string;
+        const duplicateImport: () => ParameterizedString<{
+            importName: string;
+        }>;
+        const duplicateKwargsParam: () => string;
+        const duplicateKeywordOnly: () => string;
+        const duplicateParam: () => ParameterizedString<{
+            name: string;
+        }>;
+        const duplicateCapturePatternTarget: () => ParameterizedString<{
+            name: string;
+        }>;
+        const duplicateStarPattern: () => string;
+        const duplicateStarStarPattern: () => string;
+        const duplicatePositionOnly: () => string;
+        const duplicateUnpack: () => string;
+        const ellipsisContext: () => string;
+        const ellipsisSecondArg: () => string;
+        const enumClassOverride: () => ParameterizedString<{
+            name: string;
+        }>;
+        const exceptionGroupIncompatible: () => string;
+        const exceptionTypeIncorrect: () => ParameterizedString<{
+            type: string;
+        }>;
+        const exceptionTypeNotClass: () => ParameterizedString<{
+            type: string;
+        }>;
+        const exceptionTypeNotInstantiable: () => ParameterizedString<{
+            type: string;
+        }>;
+        const expectedAfterDecorator: () => string;
+        const expectedArrow: () => string;
+        const expectedAsAfterException: () => string;
+        const expectedAssignRightHandExpr: () => string;
+        const expectedBinaryRightHandExpr: () => string;
+        const expectedBoolLiteral: () => string;
+        const expectedCase: () => string;
+        const expectedClassName: () => string;
+        const expectedCloseBrace: () => string;
+        const expectedCloseBracket: () => string;
+        const expectedCloseParen: () => string;
+        const expectedColon: () => string;
+        const expectedComplexNumberLiteral: () => string;
+        const expectedDecoratorExpr: () => string;
+        const expectedDecoratorName: () => string;
+        const expectedDecoratorNewline: () => string;
+        const expectedDelExpr: () => string;
+        const expectedElse: () => string;
+        const expectedExceptionClass: () => string;
+        const expectedExceptionObj: () => string;
+        const expectedExpr: () => string;
+        const expectedImport: () => string;
+        const expectedImportAlias: () => string;
+        const expectedImportSymbols: () => string;
+        const expectedIdentifier: () => string;
+        const expectedIndentedBlock: () => string;
+        const expectedIn: () => string;
+        const expectedInExpr: () => string;
+        const expectedFunctionAfterAsync: () => string;
+        const expectedFunctionName: () => string;
+        const expectedMemberName: () => string;
+        const expectedModuleName: () => string;
+        const expectedNameAfterAs: () => string;
+        const expectedNamedParameter: () => string;
+        const expectedNewline: () => string;
+        const expectedNewlineOrSemicolon: () => string;
+        const expectedOpenParen: () => string;
+        const expectedParamName: () => string;
+        const expectedPatternExpr: () => string;
+        const expectedPatternSubjectExpr: () => string;
+        const expectedPatternValue: () => string;
+        const expectedReturnExpr: () => string;
+        const expectedSliceIndex: () => string;
+        const expectedTypeNotString: () => string;
+        const expectedYieldExpr: () => string;
+        const finalClassIsAbstract: () => ParameterizedString<{
+            type: string;
+        }>;
+        const finalContext: () => string;
+        const finalMethodOverride: () => ParameterizedString<{
+            name: string;
+            className: string;
+        }>;
+        const finalReassigned: () => ParameterizedString<{
+            name: string;
+        }>;
+        const finalRedeclaration: () => ParameterizedString<{
+            name: string;
+        }>;
+        const finalRedeclarationBySubclass: () => ParameterizedString<{
+            name: string;
+            className: string;
+        }>;
+        const finalTooManyArgs: () => string;
+        const finalUnassigned: () => ParameterizedString<{
+            name: string;
+        }>;
+        const formatStringBrace: () => string;
+        const formatStringBytes: () => string;
+        const formatStringEscape: () => string;
+        const formatStringInPattern: () => string;
+        const formatStringIllegal: () => string;
+        const formatStringUnicode: () => string;
+        const formatStringUnterminated: () => string;
+        const functionDecoratorTypeUnknown: () => string;
+        const functionInConditionalExpression: () => string;
+        const generatorAsyncReturnType: () => string;
+        const generatorNotParenthesized: () => string;
+        const generatorSyncReturnType: () => string;
+        const genericClassAssigned: () => string;
+        const genericClassDeleted: () => string;
+        const genericNotAllowed: () => string;
+        const genericTypeAliasBoundTypeVar: () => ParameterizedString<{
+            names: string;
+        }>;
+        const genericTypeArgMissing: () => string;
+        const genericTypeArgTypeVar: () => string;
+        const genericTypeArgUnique: () => string;
+        const globalReassignment: () => ParameterizedString<{
+            name: string;
+        }>;
+        const globalRedefinition: () => ParameterizedString<{
+            name: string;
+        }>;
+        const implicitStringConcat: () => string;
+        const importCycleDetected: () => string;
+        const importDepthExceeded: () => ParameterizedString<{
+            depth: number;
+        }>;
+        const importResolveFailure: () => ParameterizedString<{
+            importName: string;
+        }>;
+        const importSourceResolveFailure: () => ParameterizedString<{
+            importName: string;
+        }>;
+        const importSymbolUnknown: () => ParameterizedString<{
+            name: string;
+        }>;
+        const incompatibleMethodOverride: () => ParameterizedString<{
+            name: string;
+            className: string;
+        }>;
+        const inconsistentIndent: () => string;
+        const inconsistentTabs: () => string;
+        const initMustReturnNone: () => string;
+        const initSubclassClsParam: () => string;
+        const instanceMethodSelfParam: () => string;
+        const instanceVarOverridesClassVar: () => ParameterizedString<{
+            name: string;
+            className: string;
+        }>;
+        const instantiateAbstract: () => ParameterizedString<{
+            type: string;
+        }>;
+        const instantiateProtocol: () => ParameterizedString<{
+            type: string;
+        }>;
+        const internalBindError: () => ParameterizedString<{
+            file: string;
+            message: string;
+        }>;
+        const internalParseError: () => ParameterizedString<{
+            file: string;
+            message: string;
+        }>;
+        const internalTypeCheckingError: () => ParameterizedString<{
+            file: string;
+            message: string;
+        }>;
+        const invalidIdentifierChar: () => string;
+        const invalidStubStatement: () => string;
+        const invalidTokenChars: () => ParameterizedString<{
+            text: string;
+        }>;
+        const isInstanceInvalidType: () => ParameterizedString<{
+            type: string;
+        }>;
+        const isSubclassInvalidType: () => ParameterizedString<{
+            type: string;
+        }>;
+        const keyValueInSet: () => string;
+        const keywordArgInTypeArgument: () => string;
+        const keywordOnlyAfterArgs: () => string;
+        const keywordSubscriptIllegal: () => string;
+        const lambdaReturnTypeUnknown: () => string;
+        const lambdaReturnTypePartiallyUnknown: () => ParameterizedString<{
+            returnType: string;
+        }>;
+        const listAssignmentMismatch: () => ParameterizedString<{
+            type: string;
+        }>;
+        const listInAnnotation: () => string;
+        const literalUnsupportedType: () => string;
+        const literalEmptyArgs: () => string;
+        const literalNotCallable: () => string;
+        const matchIncompatible: () => string;
+        const matchIsNotExhaustive: () => string;
+        const maxParseDepthExceeded: () => string;
+        const memberAccess: () => ParameterizedString<{
+            name: string;
+            type: string;
+        }>;
+        const memberDelete: () => ParameterizedString<{
+            name: string;
+            type: string;
+        }>;
+        const memberSet: () => ParameterizedString<{
+            name: string;
+            type: string;
+        }>;
+        const metaclassConflict: () => string;
+        const metaclassDuplicate: () => string;
+        const metaclassIsGeneric: () => string;
+        const methodNotDefined: () => ParameterizedString<{
+            name: string;
+        }>;
+        const methodNotDefinedOnType: () => ParameterizedString<{
+            name: string;
+            type: string;
+        }>;
+        const methodOrdering: () => string;
+        const methodOverridden: () => ParameterizedString<{
+            name: string;
+            className: string;
+            type: string;
+        }>;
+        const methodReturnsNonObject: () => ParameterizedString<{
+            name: string;
+        }>;
+        const missingProtocolMembers: () => string;
+        const missingSuperCall: () => ParameterizedString<{
+            methodName: string;
+        }>;
+        const moduleAsType: () => string;
+        const moduleNotCallable: () => string;
+        const moduleUnknownMember: () => ParameterizedString<{
+            name: string;
+        }>;
+        const namedExceptAfterCatchAll: () => string;
+        const namedParamAfterParamSpecArgs: () => ParameterizedString<{
+            name: string;
+        }>;
+        const namedTupleEmptyName: () => string;
+        const namedTupleFirstArg: () => string;
+        const namedTupleMultipleInheritance: () => string;
+        const namedTupleNameType: () => string;
+        const namedTupleNameUnique: () => string;
+        const namedTupleNoTypes: () => string;
+        const namedTupleSecondArg: () => string;
+        const newClsParam: () => string;
+        const newTypeLiteral: () => string;
+        const newTypeNotAClass: () => string;
+        const newTypeProtocolClass: () => string;
+        const nonDefaultAfterDefault: () => string;
+        const noneNotCallable: () => string;
+        const noneNotIterable: () => string;
+        const noneNotSubscriptable: () => string;
+        const noneNotUsableWith: () => string;
+        const noneOperator: () => ParameterizedString<{
+            operator: string;
+        }>;
+        const noneUnknownMember: () => ParameterizedString<{
+            name: string;
+        }>;
+        const nonLocalNoBinding: () => ParameterizedString<{
+            name: string;
+        }>;
+        const nonLocalReassignment: () => ParameterizedString<{
+            name: string;
+        }>;
+        const nonLocalRedefinition: () => ParameterizedString<{
+            name: string;
+        }>;
+        const nonLocalInModule: () => string;
+        const noOverload: () => ParameterizedString<{
+            name: string;
+        }>;
+        const noReturnContainsReturn: () => string;
+        const noReturnContainsYield: () => string;
+        const noReturnReturnsNone: () => string;
+        const notRequiredArgCount: () => string;
+        const notRequiredNotInTypedDict: () => string;
+        const objectNotCallable: () => ParameterizedString<{
+            type: string;
+        }>;
+        const obscuredClassDeclaration: () => ParameterizedString<{
+            name: string;
+        }>;
+        const obscuredFunctionDeclaration: () => ParameterizedString<{
+            name: string;
+        }>;
+        const obscuredMethodDeclaration: () => ParameterizedString<{
+            name: string;
+        }>;
+        const obscuredParameterDeclaration: () => ParameterizedString<{
+            name: string;
+        }>;
+        const obscuredVariableDeclaration: () => ParameterizedString<{
+            name: string;
+        }>;
+        const operatorLessOrGreaterDeprecated: () => string;
+        const optionalExtraArgs: () => string;
+        const orPatternIrrefutable: () => string;
+        const orPatternMissingName: () => string;
+        const overlappingOverload: () => ParameterizedString<{
+            name: string;
+            obscured: number;
+            obscuredBy: number;
+        }>;
+        const overloadAbstractMismatch: () => ParameterizedString<{
+            name: string;
+        }>;
+        const overloadImplementationMismatch: () => ParameterizedString<{
+            name: string;
+            index: number;
+        }>;
+        const overloadReturnTypeMismatch: () => ParameterizedString<{
+            name: string;
+            newIndex: number;
+            prevIndex: number;
+        }>;
+        const overloadWithImplementation: () => ParameterizedString<{
+            name: string;
+        }>;
+        const overloadWithoutImplementation: () => ParameterizedString<{
+            name: string;
+        }>;
+        const paramAfterKwargsParam: () => string;
+        const paramAlreadyAssigned: () => ParameterizedString<{
+            name: string;
+        }>;
+        const paramAnnotationMissing: () => ParameterizedString<{
+            name: string;
+        }>;
+        const paramNameMissing: () => ParameterizedString<{
+            name: string;
+        }>;
+        const paramSpecArgsKwargsUsage: () => string;
+        const paramSpecArgsMissing: () => ParameterizedString<{
+            type: string;
+        }>;
+        const paramSpecArgsUsage: () => string;
+        const paramSpecAssignedName: () => ParameterizedString<{
+            name: string;
+        }>;
+        const paramSpecContext: () => string;
+        const paramSpecFirstArg: () => string;
+        const paramSpecKwargsUsage: () => string;
+        const paramSpecNotBound: () => ParameterizedString<{
+            type: string;
+        }>;
+        const paramSpecNotUsedByOuterScope: () => ParameterizedString<{
+            name: string;
+        }>;
+        const paramSpecUnknownArg: () => string;
+        const paramSpecUnknownMember: () => ParameterizedString<{
+            name: string;
+        }>;
+        const paramSpecUnknownParam: () => ParameterizedString<{
+            name: string;
+        }>;
+        const paramTypeCovariant: () => string;
+        const paramTypeUnknown: () => ParameterizedString<{
+            paramName: string;
+        }>;
+        const paramAssignmentMismatch: () => ParameterizedString<{
+            sourceType: string;
+            paramType: string;
+        }>;
+        const paramTypePartiallyUnknown: () => ParameterizedString<{
+            paramName: string;
+        }>;
+        const parenthesizedContextManagerIllegal: () => string;
+        const positionArgAfterNamedArg: () => string;
+        const privateImportFromPyTypedModule: () => ParameterizedString<{
+            name: string;
+            module: string;
+        }>;
+        const positionOnlyAfterArgs: () => string;
+        const positionOnlyAfterKeywordOnly: () => string;
+        const positionOnlyIncompatible: () => string;
+        const positionOnlyFirstParam: () => string;
+        const privateUsedOutsideOfClass: () => ParameterizedString<{
+            name: string;
+        }>;
+        const privateUsedOutsideOfModule: () => ParameterizedString<{
+            name: string;
+        }>;
+        const propertyOverridden: () => ParameterizedString<{
+            name: string;
+            className: string;
+        }>;
+        const propertyStaticMethod: () => string;
+        const protectedUsedOutsideOfClass: () => ParameterizedString<{
+            name: string;
+        }>;
+        const protocolBaseClass: () => ParameterizedString<{
+            classType: string;
+            baseType: string;
+        }>;
+        const protocolIllegal: () => string;
+        const protocolMemberNotClassVar: () => ParameterizedString<{
+            className: string;
+            memberName: string;
+        }>;
+        const protocolNotAllowedInTypeArgument: () => string;
+        const protocolUsedInCall: () => ParameterizedString<{
+            name: string;
+        }>;
+        const protocolVarianceContravariant: () => ParameterizedString<{
+            variable: string;
+            class: string;
+        }>;
+        const protocolVarianceCovariant: () => ParameterizedString<{
+            variable: string;
+            class: string;
+        }>;
+        const protocolVarianceInvariant: () => ParameterizedString<{
+            variable: string;
+            class: string;
+        }>;
+        const recursiveDefinition: () => ParameterizedString<{
+            name: string;
+        }>;
+        const relativeImportNotAllowed: () => string;
+        const requiredArgCount: () => string;
+        const requiredNotInTypedDict: () => string;
+        const returnMissing: () => ParameterizedString<{
+            returnType: string;
+        }>;
+        const returnOutsideFunction: () => string;
+        const returnTypeContravariant: () => string;
+        const returnTypeMismatch: () => ParameterizedString<{
+            exprType: string;
+            returnType: string;
+        }>;
+        const returnTypeUnknown: () => string;
+        const returnTypePartiallyUnknown: () => ParameterizedString<{
+            returnType: string;
+        }>;
+        const revealLocalsArgs: () => string;
+        const revealLocalsNone: () => string;
+        const revealTypeArgs: () => string;
+        const revealTypeExpectedTextArg: () => string;
+        const revealTypeExpectedTextMismatch: () => ParameterizedString<{
+            expected: string;
+            received: string;
+        }>;
+        const revealTypeExpectedTypeMismatch: () => ParameterizedString<{
+            expected: string;
+            received: string;
+        }>;
+        const selfTypeContext: () => string;
+        const selfTypeWithTypedSelfOrCls: () => string;
+        const setterGetterTypeMismatch: () => string;
+        const starPatternInAsPattern: () => string;
+        const starPatternInOrPattern: () => string;
+        const singleOverload: () => ParameterizedString<{
+            name: string;
+        }>;
+        const slotsAttributeError: () => ParameterizedString<{
+            name: string;
+        }>;
+        const slotsClassVarConflict: () => ParameterizedString<{
+            name: string;
+        }>;
+        const starStarWildcardNotAllowed: () => string;
+        const staticClsSelfParam: () => string;
+        const strictTypeGuardReturnType: () => ParameterizedString<{
+            type: string;
+            returnType: string;
+        }>;
+        const stringNonAsciiBytes: () => string;
+        const stringNotSubscriptable: () => string;
+        const stringUnsupportedEscape: () => string;
+        const stringUnterminated: () => string;
+        const stubFileMissing: () => ParameterizedString<{
+            importName: string;
+        }>;
+        const stubUsesGetAttr: () => string;
+        const sublistParamsIncompatible: () => string;
+        const superCallArgCount: () => string;
+        const superCallFirstArg: () => ParameterizedString<{
+            type: string;
+        }>;
+        const superCallSecondArg: () => ParameterizedString<{
+            type: string;
+        }>;
+        const superCallZeroArgForm: () => string;
+        const symbolIsUnbound: () => ParameterizedString<{
+            name: string;
+        }>;
+        const symbolIsUndefined: () => ParameterizedString<{
+            name: string;
+        }>;
+        const symbolIsPossiblyUnbound: () => ParameterizedString<{
+            name: string;
+        }>;
+        const symbolOverridden: () => ParameterizedString<{
+            name: string;
+            className: string;
+        }>;
+        const totalOrderingMissingMethod: () => string;
+        const trailingCommaInFromImport: () => string;
+        const tryWithoutExcept: () => string;
+        const tupleAssignmentMismatch: () => ParameterizedString<{
+            type: string;
+        }>;
+        const tupleInAnnotation: () => string;
+        const tupleIndexOutOfRange: () => ParameterizedString<{
+            type: string;
+            index: number;
+        }>;
+        const typeAliasIsRecursiveDirect: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeAliasIsRecursiveIndirect: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeAliasNotInModuleOrClass: () => string;
+        const typeAliasRedeclared: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeAnnotationCall: () => string;
+        const typeAnnotationVariable: () => string;
+        const typeArgListExpected: () => string;
+        const typeArgListNotAllowed: () => string;
+        const typeArgsExpectingNone: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeArgsMismatchOne: () => ParameterizedString<{
+            received: number;
+        }>;
+        const typeArgsMissingForAlias: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeArgsMissingForClass: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeArgsTooFew: () => ParameterizedString<{
+            name: string;
+            expected: number;
+            received: number;
+        }>;
+        const typeArgsTooMany: () => ParameterizedString<{
+            name: string;
+            expected: number;
+            received: number;
+        }>;
+        const typeAssignmentMismatch: () => ParameterizedString<{
+            sourceType: string;
+            destType: string;
+        }>;
+        const typeCallNotAllowed: () => string;
+        const typeCommentDeprecated: () => string;
+        const typedDictAccess: () => string;
+        const typedDictBadVar: () => string;
+        const typedDictBaseClass: () => string;
+        const typedDictDelete: () => string;
+        const typedDictEmptyName: () => string;
+        const typedDictEntryName: () => string;
+        const typedDictEntryUnique: () => string;
+        const typedDictExtraArgs: () => string;
+        const typedDictFieldRedefinition: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typedDictFirstArg: () => string;
+        const typedDictSecondArgDict: () => string;
+        const typedDictSecondArgDictEntry: () => string;
+        const typedDictSet: () => string;
+        const typedDictTotalParam: () => string;
+        const typeExpectedClass: () => ParameterizedString<{
+            type: string;
+        }>;
+        const typeGuardArgCount: () => string;
+        const typeNotAwaitable: () => ParameterizedString<{
+            type: string;
+        }>;
+        const typeNotCallable: () => ParameterizedString<{
+            expression: string;
+            type: string;
+        }>;
+        const typeNotIntantiable: () => ParameterizedString<{
+            type: string;
+        }>;
+        const typeNotIterable: () => ParameterizedString<{
+            type: string;
+        }>;
+        const typeNotSpecializable: () => ParameterizedString<{
+            type: string;
+        }>;
+        const typeNotSubscriptable: () => ParameterizedString<{
+            type: string;
+        }>;
+        const typeNotUsableWith: () => ParameterizedString<{
+            type: string;
+            method: string;
+        }>;
+        const typeNotSupportBinaryOperator: () => ParameterizedString<{
+            leftType: string;
+            rightType: string;
+            operator: string;
+        }>;
+        const typeNotSupportBinaryOperatorBidirectional: () => ParameterizedString<{
+            leftType: string;
+            rightType: string;
+            expectedType: string;
+            operator: string;
+        }>;
+        const typeNotSupportUnaryOperator: () => ParameterizedString<{
+            type: string;
+            operator: string;
+        }>;
+        const typeNotSupportUnaryOperatorBidirectional: () => ParameterizedString<{
+            type: string;
+            expectedType: string;
+            operator: string;
+        }>;
+        const typePartiallyUnknown: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeUnknown: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeVarAssignedName: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeVarAssignmentMismatch: () => ParameterizedString<{
+            type: string;
+            name: string;
+        }>;
+        const typeVarBoundAndConstrained: () => string;
+        const typeVarFirstArg: () => string;
+        const typeVarGeneric: () => string;
+        const typeVarNoMember: () => ParameterizedString<{
+            type: string;
+            name: string;
+        }>;
+        const typeVarNotSubscriptable: () => ParameterizedString<{
+            type: string;
+        }>;
+        const typeVarNotUsedByOuterScope: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeVarPossiblyUnsolvable: () => ParameterizedString<{
+            name: string;
+            param: string;
+        }>;
+        const typeVarSingleConstraint: () => string;
+        const typeVarsNotInGenericOrProtocol: () => string;
+        const typeVarTupleMustBeUnpacked: () => string;
+        const typeVarTupleContext: () => string;
+        const typeVarUnknownParam: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeVarUsedByOuterScope: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeVarUsedOnlyOnce: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeVarVariance: () => string;
+        const unaccessedClass: () => ParameterizedString<{
+            name: string;
+        }>;
+        const unaccessedFunction: () => ParameterizedString<{
+            name: string;
+        }>;
+        const unaccessedImport: () => ParameterizedString<{
+            name: string;
+        }>;
+        const unaccessedSymbol: () => ParameterizedString<{
+            name: string;
+        }>;
+        const unaccessedVariable: () => ParameterizedString<{
+            name: string;
+        }>;
+        const unexpectedAsyncToken: () => string;
+        const unexpectedExprToken: () => string;
+        const unexpectedIndent: () => string;
+        const unexpectedUnindent: () => string;
+        const unionSyntaxIllegal: () => string;
+        const unionTypeArgCount: () => string;
+        const uninitializedInstanceVariable: () => ParameterizedString<{
+            name: string;
+        }>;
+        const unnecessaryCast: () => ParameterizedString<{
+            type: string;
+        }>;
+        const unnecessaryIsInstanceAlways: () => ParameterizedString<{
+            testType: string;
+            classType: string;
+        }>;
+        const unnecessaryIsSubclassAlways: () => ParameterizedString<{
+            testType: string;
+            classType: string;
+        }>;
+        const unnecessaryPyrightIgnore: () => string;
+        const unnecessaryPyrightIgnoreRule: () => ParameterizedString<{
+            name: string;
+        }>;
+        const unnecessaryTypeIgnore: () => string;
+        const unpackArgCount: () => string;
+        const unpackedArgInTypeArgument: () => string;
+        const unpackedArgWithVariadicParam: () => string;
+        const unpackedDictArgumentNotMapping: () => string;
+        const unpackedSubscriptIllegal: () => string;
+        const unpackedTypedDictArgument: () => string;
+        const unpackedTypeVarTupleExpected: () => ParameterizedString<{
+            name1: string;
+            name2: string;
+        }>;
+        const unpackExpectedTypedDict: () => string;
+        const unpackExpectedTypeVarTuple: () => string;
+        const unpackIllegalInComprehension: () => string;
+        const unpackInAnnotation: () => string;
+        const unpackInDict: () => string;
+        const unpackInSet: () => string;
+        const unpackNotAllowed: () => string;
+        const unpackOperatorNotAllowed: () => string;
+        const unpackTuplesIllegal: () => string;
+        const unreachableCode: () => string;
+        const unreachableExcept: () => string;
+        const unsupportedDunderAllOperation: () => string;
+        const unusedCallResult: () => ParameterizedString<{
+            type: string;
+        }>;
+        const unusedCoroutine: () => string;
+        const unusedExpression: () => string;
+        const varAnnotationIllegal: () => string;
+        const variadicTypeArgsTooMany: () => string;
+        const variadicTypeParamTooManyAlias: () => ParameterizedString<{
+            names: string;
+        }>;
+        const variadicTypeParamTooManyClass: () => ParameterizedString<{
+            names: string;
+        }>;
+        const walrusIllegal: () => string;
+        const walrusNotAllowed: () => string;
+        const wildcardInFunction: () => string;
+        const wildcardLibraryImport: () => string;
+        const yieldFromIllegal: () => string;
+        const yieldFromOutsideAsync: () => string;
+        const yieldOutsideFunction: () => string;
+        const yieldTypeMismatch: () => ParameterizedString<{
+            exprType: string;
+            yieldType: string;
+        }>;
+        const yieldWithinListCompr: () => string;
+        const zeroCaseStatementsFound: () => string;
+        const zeroLengthTupleNotAllowed: () => string;
+    }
+    namespace DiagnosticAddendum {
+        const argParam: () => ParameterizedString<{
+            paramName: string;
+        }>;
+        const argParamFunction: () => ParameterizedString<{
+            paramName: string;
+            functionName: string;
+        }>;
+        const argsParamMissing: () => ParameterizedString<{
+            paramName: string;
+        }>;
+        const argsPositionOnly: () => ParameterizedString<{
+            expected: number;
+            received: number;
+        }>;
+        const argumentType: () => ParameterizedString<{
+            type: string;
+        }>;
+        const argumentTypes: () => ParameterizedString<{
+            types: string;
+        }>;
+        const assignToNone: () => string;
+        const asyncHelp: () => string;
+        const baseClassProvidesType: () => ParameterizedString<{
+            baseClass: string;
+            type: string;
+        }>;
+        const dataClassFrozen: () => ParameterizedString<{
+            name: string;
+        }>;
+        const dataClassFieldLocation: () => string;
+        const finalMethod: () => string;
+        const functionParamDefaultMissing: () => ParameterizedString<{
+            name: string;
+        }>;
+        const functionParamName: () => ParameterizedString<{
+            destName: string;
+            srcName: string;
+        }>;
+        const functionReturnTypeMismatch: () => ParameterizedString<{
+            sourceType: string;
+            destType: string;
+        }>;
+        const functionTooFewParams: () => ParameterizedString<{
+            expected: number;
+            received: number;
+        }>;
+        const incompatibleGetter: () => string;
+        const incompatibleSetter: () => string;
+        const incompatibleDeleter: () => string;
+        const initMethodLocation: () => ParameterizedString<{
+            type: string;
+        }>;
+        const initMethodSignature: () => ParameterizedString<{
+            type: string;
+        }>;
+        const functionTooManyParams: () => ParameterizedString<{
+            expected: number;
+            received: number;
+        }>;
+        const keyNotRequired: () => ParameterizedString<{
+            name: string;
+            type: string;
+        }>;
+        const keyRequiredDeleted: () => ParameterizedString<{
+            name: string;
+        }>;
+        const keyUndefined: () => ParameterizedString<{
+            name: string;
+            type: string;
+        }>;
+        const kwargsParamMissing: () => ParameterizedString<{
+            paramName: string;
+        }>;
+        const listAssignmentMismatch: () => ParameterizedString<{
+            type: string;
+        }>;
+        const literalAssignmentMismatch: () => ParameterizedString<{
+            sourceType: string;
+            destType: string;
+        }>;
+        const matchIsNotExhaustiveType: () => ParameterizedString<{
+            type: string;
+        }>;
+        const matchIsNotExhaustiveHint: () => string;
+        const memberAssignment: () => ParameterizedString<{
+            type: string;
+            name: string;
+            classType: string;
+        }>;
+        const memberIsAbstract: () => ParameterizedString<{
+            type: string;
+            name: string;
+        }>;
+        const memberIsAbstractMore: () => ParameterizedString<{
+            count: number;
+        }>;
+        const memberIsFinalInProtocol: () => ParameterizedString<{
+            name: string;
+        }>;
+        const memberIsInitVar: () => ParameterizedString<{
+            name: string;
+        }>;
+        const memberIsInvariant: () => ParameterizedString<{
+            name: string;
+        }>;
+        const memberIsNotFinalInProtocol: () => ParameterizedString<{
+            name: string;
+        }>;
+        const memberSetClassVar: () => ParameterizedString<{
+            name: string;
+        }>;
+        const memberTypeMismatch: () => ParameterizedString<{
+            name: string;
+        }>;
+        const memberUnknown: () => ParameterizedString<{
+            name: string;
+        }>;
+        const missingProtocolMember: () => ParameterizedString<{
+            name: string;
+            classType: string;
+        }>;
+        const missingGetter: () => string;
+        const missingSetter: () => string;
+        const missingDeleter: () => string;
+        const namedParamMissingInDest: () => ParameterizedString<{
+            name: string;
+        }>;
+        const namedParamMissingInSource: () => ParameterizedString<{
+            name: string;
+        }>;
+        const namedParamTypeMismatch: () => ParameterizedString<{
+            name: string;
+            sourceType: string;
+            destType: string;
+        }>;
+        const newMethodLocation: () => ParameterizedString<{
+            type: string;
+        }>;
+        const newMethodSignature: () => ParameterizedString<{
+            type: string;
+        }>;
+        const noOverloadAssignable: () => ParameterizedString<{
+            type: string;
+        }>;
+        const orPatternMissingName: () => ParameterizedString<{
+            name: string;
+        }>;
+        const overloadSignature: () => string;
+        const overloadNotAssignable: () => ParameterizedString<{
+            name: string;
+        }>;
+        const overloadWithImplementation: () => string;
+        const overriddenMethod: () => string;
+        const overriddenSymbol: () => string;
+        const overrideNotClassMethod: () => string;
+        const overrideNotInstanceMethod: () => string;
+        const overrideNotStaticMethod: () => string;
+        const overrideParamKeywordNoDefault: () => ParameterizedString<{
+            name: string;
+        }>;
+        const overrideParamKeywordType: () => ParameterizedString<{
+            name: string;
+            baseType: string;
+            overrideType: string;
+        }>;
+        const overrideParamName: () => ParameterizedString<{
+            index: number;
+            baseName: string;
+            overrideName: string;
+        }>;
+        const overrideParamNameExtra: () => ParameterizedString<{
+            name: string;
+        }>;
+        const overrideParamNameMissing: () => ParameterizedString<{
+            name: string;
+        }>;
+        const overrideParamNamePositionOnly: () => ParameterizedString<{
+            index: number;
+            baseName: string;
+        }>;
+        const overrideParamNoDefault: () => ParameterizedString<{
+            index: number;
+        }>;
+        const overrideParamType: () => ParameterizedString<{
+            index: number;
+            baseType: string;
+            overrideType: string;
+        }>;
+        const overridePositionalParamCount: () => ParameterizedString<{
+            baseCount: number;
+            overrideCount: number;
+        }>;
+        const overrideReturnType: () => ParameterizedString<{
+            baseType: string;
+            overrideType: string;
+        }>;
+        const overrideType: () => ParameterizedString<{
+            type: string;
+        }>;
+        const paramAssignment: () => ParameterizedString<{
+            index: number;
+            sourceType: string;
+            destType: string;
+        }>;
+        const paramSpecOverload: () => string;
+        const paramType: () => ParameterizedString<{
+            paramType: string;
+        }>;
+        const privateImportFromPyTypedSource: () => ParameterizedString<{
+            module: string;
+        }>;
+        const propertyAccessFromProtocolClass: () => string;
+        const propertyMethodIncompatible: () => ParameterizedString<{
+            name: string;
+        }>;
+        const propertyMethodMissing: () => ParameterizedString<{
+            name: string;
+        }>;
+        const propertyMissingDeleter: () => ParameterizedString<{
+            name: string;
+        }>;
+        const propertyMissingSetter: () => ParameterizedString<{
+            name: string;
+        }>;
+        const protocolMemberClassVar: () => ParameterizedString<{
+            name: string;
+        }>;
+        const protocolIncompatible: () => ParameterizedString<{
+            sourceType: string;
+            destType: string;
+        }>;
+        const protocolMemberMissing: () => ParameterizedString<{
+            name: string;
+        }>;
+        const protocolSourceIsNotConcrete: () => ParameterizedString<{
+            sourceType: string;
+            destType: string;
+        }>;
+        const readOnlyAttribute: () => ParameterizedString<{
+            name: string;
+        }>;
+        const seeDeclaration: () => string;
+        const seeClassDeclaration: () => string;
+        const seeFunctionDeclaration: () => string;
+        const seeMethodDeclaration: () => string;
+        const seeParameterDeclaration: () => string;
+        const seeVariableDeclaration: () => string;
+        const tupleEntryTypeMismatch: () => ParameterizedString<{
+            entry: number;
+        }>;
+        const tupleAssignmentMismatch: () => ParameterizedString<{
+            type: string;
+        }>;
+        const tupleSizeMismatch: () => ParameterizedString<{
+            expected: number;
+            received: number;
+        }>;
+        const tupleSizeMismatchIndeterminate: () => ParameterizedString<{
+            expected: number;
+        }>;
+        const typeAssignmentMismatch: () => ParameterizedString<{
+            sourceType: string;
+            destType: string;
+        }>;
+        const typeBound: () => ParameterizedString<{
+            sourceType: string;
+            destType: string;
+            name: string;
+        }>;
+        const typeConstrainedTypeVar: () => ParameterizedString<{
+            type: string;
+            name: string;
+        }>;
+        const typedDictFieldMissing: () => ParameterizedString<{
+            name: string;
+            type: string;
+        }>;
+        const typedDictFieldNotRequired: () => ParameterizedString<{
+            name: string;
+            type: string;
+        }>;
+        const typedDictFieldRedefinition: () => ParameterizedString<{
+            parentType: string;
+            childType: string;
+        }>;
+        const typedDictFieldRequired: () => ParameterizedString<{
+            name: string;
+            type: string;
+        }>;
+        const typedDictFieldTypeMismatch: () => ParameterizedString<{
+            name: string;
+            type: string;
+        }>;
+        const typedDictFieldUndefined: () => ParameterizedString<{
+            name: string;
+            type: string;
+        }>;
+        const typedDictFinalMismatch: () => ParameterizedString<{
+            sourceType: string;
+            destType: string;
+        }>;
+        const typeIncompatible: () => ParameterizedString<{
+            sourceType: string;
+            destType: string;
+        }>;
+        const typeNotCallable: () => ParameterizedString<{
+            type: string;
+        }>;
+        const typeNotClass: () => ParameterizedString<{
+            type: string;
+        }>;
+        const typeParamSpec: () => ParameterizedString<{
+            type: string;
+            name: string;
+        }>;
+        const typeNotStringLiteral: () => ParameterizedString<{
+            type: string;
+        }>;
+        const typeOfSymbol: () => ParameterizedString<{
+            name: string;
+            type: string;
+        }>;
+        const typeUnsupported: () => ParameterizedString<{
+            type: string;
+        }>;
+        const typeVarIsContravariant: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeVarIsCovariant: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeVarIsInvariant: () => ParameterizedString<{
+            name: string;
+        }>;
+        const typeVarTupleRequiresKnownLength: () => string;
+        const typeVarNotAllowed: () => string;
+        const typeVarsMissing: () => ParameterizedString<{
+            names: string;
+        }>;
+        const typeVarUnsolvableRemedy: () => string;
+        const unreachableExcept: () => ParameterizedString<{
+            exceptionType: string;
+            parentType: string;
+        }>;
+        const useDictInstead: () => string;
+        const useListInstead: () => string;
+        const useTupleInstead: () => string;
+        const useTypeInstead: () => string;
+    }
+    namespace CodeAction {
+        const addOptionalToAnnotation: () => string;
+        const createTypeStub: () => string;
+        const createTypeStubFor: () => ParameterizedString<{
+            moduleName: string;
+        }>;
+        const executingCommand: () => string;
+        const filesToAnalyzeOne: () => string;
+        const filesToAnalyzeCount: () => ParameterizedString<{
+            count: number;
+        }>;
+        const findingReferences: () => string;
+        const organizeImports: () => string;
+    }
+    namespace Refactoring {
+        const moveFile: () => ParameterizedString<{
+            oldModuleName: string;
+            newModuleName: string;
+        }>;
+        const moveFileLabel: () => ParameterizedString<{
+            oldModuleName: string;
+            newModuleName: string;
+        }>;
+        const moveFileDescription: () => ParameterizedString<{
+            oldModuleName: string;
+            newModuleName: string;
+        }>;
+    }
+}