import { CancellationToken } from 'vscode-languageserver-protocol';
import { ConsoleInterface } from '../common/console';
import { Diagnostic, DiagnosticAddendum } from '../common/diagnostic';
import { DiagnosticRule } from '../common/diagnosticRules';
import { TextRange } from '../common/textRange';
import { ArgCategory, ArgumentNode, CallNode, CaseNode, ClassNode, DecoratorNode, ExpressionNode, FunctionNode, MatchNode, NameNode, ParamCategory, ParameterNode, ParseNode, StringNode } from '../parser/parseNodes';
import { AnalyzerFileInfo } from './analyzerFileInfo';
import { CodeFlowReferenceExpressionNode, FlowNode } from './codeFlowTypes';
import { ConstraintTracker } from './constraintTracker';
import { Declaration } from './declaration';
import { ResolvedAliasInfo } from './declarationUtils';
import { SymbolWithScope } from './scope';
import { Symbol, SynthesizedTypeInfo } from './symbol';
import { SpeculativeModeOptions } from './typeCacheUtils';
import { PrintTypeFlags } from './typePrinter';
import { AnyType, ClassType, FunctionParam, FunctionType, OverloadedType, TupleTypeArg, Type, TypeCondition, TypeVarType, UnknownType, Variance } from './types';
import { ApplyTypeVarOptions, ClassMember, InferenceContext, MemberAccessFlags } from './typeUtils';
export declare const maxSubtypesForInferredType = 64;
export declare const maxInferredContainerDepth = 8;
export declare const enum EvalFlags {
    None = 0,
    ConvertEllipsisToAny = 1,
    NoSpecialize = 2,
    ForwardRefs = 4,
    StrLiteralAsType = 8,
    NoFinal = 16,
    NoParamSpec = 32,
    NoTypeVarTuple = 64,
    InstantiableType = 128,
    TypeExpression = 256,
    AllowMissingTypeArgs = 512,
    AllowGeneric = 1024,
    NoTypeVarWithScopeId = 2048,
    AllowTypeVarWithoutScopeId = 4096,
    TypeVarGetsCurScope = 8192,
    EnforceVarianceConsistency = 16384,
    VarTypeAnnotation = 32768,
    AllowEllipsis = 65536,
    NoClassVar = 131072,
    NoNakedGeneric = 262144,
    NotParsed = 524288,
    AllowRequired = 1048576,
    AllowReadOnly = 2097152,
    AllowUnpackedTuple = 4194304,
    AllowUnpackedTypedDict = 8388608,
    ParsesStringLiteral = 16777216,
    NoConvertSpecialForm = 33554432,
    NoNonTypeSpecialForms = 67108864,
    AllowConcatenate = 134217728,
    StripTupleLiterals = 268435456,
    IsinstanceArg = 536870912,
    TypeFormArg = 1073741824,
    EnforceClassTypeVarScope = -2147483648,
    CallBaseDefaults = 2,
    IndexBaseDefaults = 2,
    MemberAccessBaseDefaults = 2,
    IsInstanceArgDefaults = 536871546
}
export interface PrefetchedTypes {
    noneTypeClass: Type;
    objectClass: Type;
    typeClass: Type;
    unionTypeClass: Type;
    awaitableClass: Type;
    functionClass: Type;
    methodClass: Type;
    tupleClass: Type;
    boolClass: Type;
    intClass: Type;
    strClass: Type;
    dictClass: Type;
    moduleTypeClass: Type;
    typedDictClass: Type;
    typedDictPrivateClass: Type;
    supportsKeysAndGetItemClass: Type;
    mappingClass: Type;
    templateClass: Type;
}
export interface TypeResult<T extends Type = Type> {
    type: T;
    isIncomplete?: boolean | undefined;
    bindToSelfType?: ClassType | TypeVarType | undefined;
    unpackedType?: Type | undefined;
    typeList?: TypeResultWithNode[] | undefined;
    typeErrors?: boolean | undefined;
    inlinedTypeDict?: ClassType;
    classType?: ClassType | UnknownType | AnyType;
    isEmptyTupleShorthand?: boolean | undefined;
    expectedTypeDiagAddendum?: DiagnosticAddendum | undefined;
    isAsymmetricAccessor?: boolean;
    narrowedTypeForSet?: Type | undefined;
    isRequired?: boolean;
    isNotRequired?: boolean;
    isReadOnly?: boolean;
    overloadsUsedForCall?: FunctionType[];
    memberAccessDeprecationInfo?: MemberAccessDeprecationInfo;
    magicMethodDeprecationInfo?: MagicMethodDeprecationInfo;
}
export interface TypeResultWithNode extends TypeResult {
    node: ParseNode;
}
export interface MemberAccessDeprecationInfo {
    accessType: 'property' | 'descriptor';
    accessMethod: 'get' | 'set' | 'del';
    deprecatedMessage: string;
}
export interface MagicMethodDeprecationInfo {
    className: string;
    methodName: string;
    deprecatedMessage: string;
}
export interface EvaluatorUsage {
    method: 'get' | 'set' | 'del';
    setType?: TypeResult | undefined;
    setErrorNode?: ExpressionNode | undefined;
    setExpectedTypeDiag?: DiagnosticAddendum | undefined;
}
export interface ClassTypeResult {
    classType: ClassType;
    decoratedType: Type;
}
export interface FunctionTypeResult {
    functionType: FunctionType;
    decoratedType: Type;
}
export interface CallSignature {
    type: FunctionType;
    activeParam?: FunctionParam | undefined;
}
export interface CallSignatureInfo {
    signatures: CallSignature[];
    callNode: CallNode;
}
export interface AbstractSymbol {
    symbol: Symbol;
    symbolName: string;
    classType: Type;
    hasImplementation: boolean;
}
export interface ArgBase {
    argCategory: ArgCategory;
    node?: ArgumentNode | undefined;
    name?: NameNode | undefined;
    typeResult?: TypeResult | undefined;
    valueExpression?: ExpressionNode | undefined;
    active?: boolean | undefined;
    enforceIterable?: boolean | undefined;
}
export interface ArgWithType extends ArgBase {
    typeResult: TypeResult;
}
export interface ArgWithExpression extends ArgBase {
    valueExpression: ExpressionNode;
}
export type Arg = ArgWithType | ArgWithExpression;
export interface EffectiveTypeResult {
    type: Type;
    isIncomplete: boolean;
    includesVariableDecl?: boolean;
    includesIllegalTypeAliasDecl?: boolean;
    includesSpeculativeResult?: boolean;
    isRecursiveDefinition?: boolean;
    evaluationAttempts?: number;
}
export interface ValidateArgTypeParams {
    paramCategory: ParamCategory;
    paramType: Type;
    requiresTypeVarMatching: boolean;
    argument: Arg;
    isDefaultArg?: boolean;
    argType?: Type | undefined;
    errorNode: ExpressionNode;
    paramName?: string | undefined;
    isParamNameSynthesized?: boolean;
    mapsToVarArgList?: boolean | undefined;
    isinstanceParam?: boolean;
}
export interface ExpectedTypeOptions {
    allowFinal?: boolean;
    allowRequired?: boolean;
    allowReadOnly?: boolean;
    allowUnpackedTuple?: boolean;
    allowUnpackedTypedDict?: boolean;
    allowParamSpec?: boolean;
    allowClassVar?: boolean;
    varTypeAnnotation?: boolean;
    typeVarGetsCurScope?: boolean;
    allowTypeVarsWithoutScopeId?: boolean;
    enforceClassTypeVarScope?: boolean;
    parsesStringLiteral?: boolean;
    notParsed?: boolean;
    noNonTypeSpecialForms?: boolean;
    typeFormArg?: boolean;
    forwardRefs?: boolean;
    typeExpression?: boolean;
    runtimeTypeExpression?: boolean;
    convertEllipsisToAny?: boolean;
    allowEllipsis?: boolean;
}
export interface ExpectedTypeResult {
    type: Type;
    node: ParseNode;
}
export interface FunctionResult {
    returnType: Type;
    argumentErrors: boolean;
    isTypeIncomplete: boolean;
}
export interface ArgResult {
    isCompatible: boolean;
    argType: Type;
    isTypeIncomplete?: boolean | undefined;
    condition?: TypeCondition[];
    skippedBareTypeVarExpectedType?: boolean;
}
export interface CallResult {
    returnType?: Type | undefined;
    isTypeIncomplete?: boolean | undefined;
    argumentErrors?: boolean;
    anyOrUnknownArg?: UnknownType | AnyType;
    unpackedArgOfUnknownLength?: boolean;
    activeParam?: FunctionParam | undefined;
    specializedInitSelfType?: Type | undefined;
    overloadsUsedForCall?: FunctionType[];
    argResults?: ArgResult[];
}
export interface ClassMemberLookup {
    symbol: Symbol | undefined;
    type: Type;
    isTypeIncomplete: boolean;
    isDescriptorError: boolean;
    isClassMember: boolean;
    classType?: ClassType | UnknownType | AnyType;
    isClassVar: boolean;
    isAsymmetricAccessor: boolean;
    narrowedTypeForSet?: Type;
    memberAccessDeprecationInfo?: MemberAccessDeprecationInfo;
}
export interface SolveConstraintsOptions {
    useLowerBoundOnly?: boolean;
}
export declare enum Reachability {
    Reachable = 0,
    UnreachableStructural = 1,
    UnreachableStaticCondition = 2,
    UnreachableByAnalysis = 3
}
export interface PrintTypeOptions {
    expandTypeAlias?: boolean;
    enforcePythonSyntax?: boolean;
    useFullyQualifiedNames?: boolean;
    useTypingUnpack?: boolean;
    printUnknownWithAny?: boolean;
    printTypeVarVariance?: boolean;
    omitTypeArgsIfUnknown?: boolean;
}
export interface DeclaredSymbolTypeInfo {
    type: Type | undefined;
    isTypeAlias?: boolean;
    exceedsMaxDecls?: boolean;
}
export interface ResolveAliasOptions {
    allowExternallyHiddenAccess?: boolean;
    skipFileNeededCheck?: boolean;
}
export interface ValidateTypeArgsOptions {
    allowEmptyTuple?: boolean;
    allowTypeVarTuple?: boolean;
    allowParamSpec?: boolean;
    allowTypeArgList?: boolean;
    allowUnpackedTuples?: boolean;
}
export interface MapSubtypesOptions {
    conditionFilter?: TypeCondition[] | undefined;
    sortSubtypes?: boolean;
    expandCallback?: (type: Type) => Type;
}
export interface CallSiteEvaluationInfo {
    errorNode: ExpressionNode;
    args: ValidateArgTypeParams[];
}
export interface SymbolDeclInfo {
    decls: Declaration[];
    synthesizedTypes: SynthesizedTypeInfo[];
}
export declare const enum AssignTypeFlags {
    Default = 0,
    Invariant = 1,
    Contravariant = 2,
    SkipRecursiveTypeCheck = 4,
    ArgAssignmentFirstPass = 8,
    OverloadOverlap = 16,
    PartialOverloadOverlap = 32,
    SkipReturnTypeCheck = 64,
    RetainLiteralsForTypeVar = 256,
    SkipSelfClsTypeCheck = 512,
    PopulateExpectedType = 2048,
    SkipPopulateUnknownExpectedType = 4096,
    AllowUnspecifiedTypeArgs = 8192,
    AllowIsinstanceSpecialForms = 16384,
    SkipSelfClsParamCheck = 32768,
    AllowProtocolClassSource = 65536,
    DisallowExtraKwargsForTd = 131072
}
export interface TypeEvaluator {
    runWithCancellationToken<T>(token: CancellationToken, callback: () => T): T;
    runWithCancellationToken<T>(token: CancellationToken, callback: () => Promise<T>): Promise<T>;
    getType: (node: ExpressionNode) => Type | undefined;
    getTypeResult: (node: ExpressionNode) => TypeResult | undefined;
    getTypeResultForDecorator: (node: DecoratorNode) => TypeResult | undefined;
    getCachedType: (node: ExpressionNode) => Type | undefined;
    getTypeOfExpression: (node: ExpressionNode, flags?: EvalFlags, context?: InferenceContext) => TypeResult;
    getTypeOfAnnotation: (node: ExpressionNode, options?: ExpectedTypeOptions) => Type;
    getTypeOfClass: (node: ClassNode) => ClassTypeResult | undefined;
    createSubclass: (errorNode: ExpressionNode, type1: ClassType, type2: ClassType) => ClassType;
    getTypeOfFunction: (node: FunctionNode) => FunctionTypeResult | undefined;
    getTypeOfExpressionExpectingType: (node: ExpressionNode, options?: ExpectedTypeOptions) => TypeResult;
    evaluateTypeForSubnode: (subnode: ParseNode, callback: () => void) => TypeResult | undefined;
    evaluateTypesForStatement: (node: ParseNode) => void;
    evaluateTypesForMatchStatement: (node: MatchNode) => void;
    evaluateTypesForCaseStatement: (node: CaseNode) => void;
    evaluateTypeOfParam: (node: ParameterNode) => void;
    canBeTruthy: (type: Type) => boolean;
    canBeFalsy: (type: Type) => boolean;
    stripLiteralValue: (type: Type) => Type;
    removeTruthinessFromType: (type: Type) => Type;
    removeFalsinessFromType: (type: Type) => Type;
    stripTypeGuard: (type: Type) => Type;
    solveAndApplyConstraints: (type: Type, constraints: ConstraintTracker, applyOptions?: ApplyTypeVarOptions, solveOptions?: SolveConstraintsOptions) => Type;
    getExpectedType: (node: ExpressionNode) => ExpectedTypeResult | undefined;
    verifyRaiseExceptionType: (node: ExpressionNode, allowNone: boolean) => void;
    verifyDeleteExpression: (node: ExpressionNode) => void;
    validateOverloadedArgTypes: (errorNode: ExpressionNode, argList: Arg[], typeResult: TypeResult<OverloadedType>, constraints: ConstraintTracker | undefined, skipUnknownArgCheck: boolean, inferenceContext: InferenceContext | undefined) => CallResult;
    validateInitSubclassArgs: (node: ClassNode, classType: ClassType) => void;
    isNodeReachable: (node: ParseNode, sourceNode?: ParseNode | undefined) => boolean;
    isAfterNodeReachable: (node: ParseNode) => boolean;
    getNodeReachability: (node: ParseNode, sourceNode?: ParseNode | undefined) => Reachability;
    getAfterNodeReachability: (node: ParseNode) => Reachability;
    isAsymmetricAccessorAssignment: (node: ParseNode) => boolean;
    suppressDiagnostics: (node: ParseNode, callback: () => void) => void;
    isSpecialFormClass: (classType: ClassType, flags: AssignTypeFlags) => boolean;
    getDeclInfoForStringNode: (node: StringNode) => SymbolDeclInfo | undefined;
    getDeclInfoForNameNode: (node: NameNode, skipUnreachableCode?: boolean) => SymbolDeclInfo | undefined;
    getTypeForDeclaration: (declaration: Declaration) => DeclaredSymbolTypeInfo;
    resolveAliasDeclaration: (declaration: Declaration, resolveLocalNames: boolean, options?: ResolveAliasOptions) => Declaration | undefined;
    resolveAliasDeclarationWithInfo: (declaration: Declaration, resolveLocalNames: boolean, options?: ResolveAliasOptions) => ResolvedAliasInfo | undefined;
    getTypeOfIterable: (typeResult: TypeResult, isAsync: boolean, errorNode: ExpressionNode, emitNotIterableError?: boolean) => TypeResult | undefined;
    getTypeOfIterator: (typeResult: TypeResult, isAsync: boolean, errorNode: ExpressionNode, emitNotIterableError?: boolean) => TypeResult | undefined;
    getGetterTypeFromProperty: (propertyClass: ClassType) => Type | undefined;
    getTypeOfArg: (arg: Arg, inferenceContext: InferenceContext | undefined) => TypeResult;
    convertNodeToArg: (node: ArgumentNode) => ArgWithExpression;
    buildTupleTypesList: (entryTypeResults: TypeResult[], stripLiterals: boolean, convertModules: boolean) => TupleTypeArg[];
    markNamesAccessed: (node: ParseNode, names: string[]) => void;
    expandPromotionTypes: (node: ParseNode, type: Type) => Type;
    makeTopLevelTypeVarsConcrete: (type: Type, makeParamSpecsConcrete?: boolean) => Type;
    mapSubtypesExpandTypeVars: (type: Type, options: MapSubtypesOptions | undefined, callback: (expandedSubtype: Type, unexpandedSubtype: Type) => Type | undefined) => Type;
    isTypeSubsumedByOtherType: (type: Type, otherType: Type, allowAnyToSubsume: boolean) => boolean;
    lookUpSymbolRecursive: (node: ParseNode, name: string, honorCodeFlow: boolean) => SymbolWithScope | undefined;
    getDeclaredTypeOfSymbol: (symbol: Symbol) => DeclaredSymbolTypeInfo;
    getEffectiveTypeOfSymbol: (symbol: Symbol) => Type;
    getEffectiveTypeOfSymbolForUsage: (symbol: Symbol, usageNode?: NameNode, useLastDecl?: boolean) => EffectiveTypeResult;
    getInferredTypeOfDeclaration: (symbol: Symbol, decl: Declaration) => Type | undefined;
    getDeclaredTypeForExpression: (expression: ExpressionNode, usage?: EvaluatorUsage) => Type | undefined;
    getDeclaredReturnType: (node: FunctionNode) => Type | undefined;
    getInferredReturnType: (type: FunctionType, callSiteInfo?: CallSiteEvaluationInfo) => Type;
    getBestOverloadForArgs: (errorNode: ExpressionNode, typeResult: TypeResult<OverloadedType>, argList: Arg[]) => FunctionType | undefined;
    getBuiltInType: (node: ParseNode, name: string) => Type;
    getTypeOfMember: (member: ClassMember) => Type;
    getTypeOfBoundMember(errorNode: ExpressionNode, objectType: ClassType, memberName: string, usage?: EvaluatorUsage, diag?: DiagnosticAddendum | undefined, flags?: MemberAccessFlags, selfType?: ClassType | TypeVarType): TypeResult | undefined;
    getBoundMagicMethod: (classType: ClassType, memberName: string, selfType?: ClassType | TypeVarType | undefined, errorNode?: ExpressionNode | undefined, diag?: DiagnosticAddendum, recursionCount?: number) => FunctionType | OverloadedType | undefined;
    getTypeOfMagicMethodCall: (objType: Type, methodName: string, argList: TypeResult[], errorNode: ExpressionNode, inferenceContext: InferenceContext | undefined) => TypeResult | undefined;
    bindFunctionToClassOrObject: (baseType: ClassType | undefined, memberType: FunctionType | OverloadedType, memberClass?: ClassType, treatConstructorAsClassMethod?: boolean, selfType?: ClassType | TypeVarType, diag?: DiagnosticAddendum, recursionCount?: number) => FunctionType | OverloadedType | undefined;
    getCallbackProtocolType: (objType: ClassType, recursionCount?: number) => FunctionType | OverloadedType | undefined;
    getCallSignatureInfo: (node: CallNode, activeIndex: number, activeOrFake: boolean) => CallSignatureInfo | undefined;
    getAbstractSymbols: (classType: ClassType) => AbstractSymbol[];
    narrowConstrainedTypeVar: (node: ParseNode, typeVar: TypeVarType) => Type | undefined;
    isTypeComparable: (leftType: Type, rightType: Type, assumeIsOperator?: boolean) => boolean;
    assignType: (destType: Type, srcType: Type, diag?: DiagnosticAddendum, constraints?: ConstraintTracker, flags?: AssignTypeFlags, recursionCount?: number) => boolean;
    validateOverrideMethod: (baseMethod: Type, overrideMethod: FunctionType | OverloadedType, baseClass: ClassType | undefined, diag: DiagnosticAddendum, enforceParamNames?: boolean) => boolean;
    validateCallArgs: (errorNode: ExpressionNode, argList: Arg[], callTypeResult: TypeResult, constraints: ConstraintTracker | undefined, skipUnknownArgCheck: boolean | undefined, inferenceContext: InferenceContext | undefined) => CallResult;
    validateTypeArg: (argResult: TypeResultWithNode, options?: ValidateTypeArgsOptions) => boolean;
    assignTypeToExpression: (target: ExpressionNode, typeResult: TypeResult, srcExpr: ExpressionNode) => void;
    assignClassToSelf: (destType: ClassType, srcType: ClassType, assumedVariance: Variance) => boolean;
    getBuiltInObject: (node: ParseNode, name: string, typeArgs?: Type[]) => Type;
    getTypedDictClassType: () => ClassType | undefined;
    getTupleClassType: () => ClassType | undefined;
    getDictClassType: () => ClassType | undefined;
    getStrClassType: () => ClassType | undefined;
    getObjectType: () => Type;
    getNoneType: () => Type;
    getUnionClassType(): Type;
    getTypeClassType(): ClassType | undefined;
    getTypingType: (node: ParseNode, symbolName: string) => Type | undefined;
    getTypeCheckerInternalsType: (node: ParseNode, symbolName: string) => Type | undefined;
    inferReturnTypeIfNecessary: (type: Type) => void;
    inferVarianceForClass: (type: ClassType) => void;
    assignTypeArgs: (destType: ClassType, srcType: ClassType, diag: DiagnosticAddendum | undefined, constraints: ConstraintTracker | undefined, flags: AssignTypeFlags, recursionCount: number) => boolean;
    reportMissingTypeArgs: (node: ExpressionNode, type: Type, flags: EvalFlags) => Type;
    isFinalVariable: (symbol: Symbol) => boolean;
    isFinalVariableDeclaration: (decl: Declaration) => boolean;
    isExplicitTypeAliasDeclaration: (decl: Declaration) => boolean;
    addInformation: (message: string, node: ParseNode, range?: TextRange) => Diagnostic | undefined;
    addUnreachableCode: (node: ParseNode, reachability: Reachability, textRange: TextRange) => void;
    addDeprecated: (message: string, node: ParseNode) => void;
    addDiagnostic: (rule: DiagnosticRule, message: string, node: ParseNode, range?: TextRange) => Diagnostic | undefined;
    addDiagnosticForTextRange: (fileInfo: AnalyzerFileInfo, rule: DiagnosticRule, message: string, range: TextRange) => Diagnostic | undefined;
    printType: (type: Type, options?: PrintTypeOptions) => string;
    printSrcDestTypes: (srcType: Type, destType: Type) => {
        sourceType: string;
        destType: string;
    };
    printFunctionParts: (type: FunctionType, extraFlags?: PrintTypeFlags) => [string[], string];
    getTypeCacheEntryCount: () => number;
    disposeEvaluator: () => void;
    useSpeculativeMode: <T>(speculativeNode: ParseNode | undefined, callback: () => T, options?: SpeculativeModeOptions) => T;
    isSpeculativeModeInUse: (node: ParseNode | undefined) => boolean;
    setTypeResultForNode: (node: ParseNode, typeResult: TypeResult, flags?: EvalFlags) => void;
    checkForCancellation: () => void;
    printControlFlowGraph: (flowNode: FlowNode, reference: CodeFlowReferenceExpressionNode | undefined, callName: string, logger: ConsoleInterface) => void;
}