import { ParseNode } from '../parser/parseNodes';
import { Type } from './types';
interface SpeculativeEntry {
    cache: Map<number, any>;
    id: number;
}
interface SpeculativeContext {
    speculativeRootNode: ParseNode;
    entriesToUndo: SpeculativeEntry[];
    dependentType: Type | undefined;
    allowDiagnostics?: boolean;
}
interface DependentType {
    speculativeRootNode: ParseNode;
    dependentType: Type;
}
export interface TypeResult {
    type: Type;
    isIncomplete?: boolean;
}
export interface SpeculativeTypeEntry {
    typeResult: TypeResult;
    expectedType: Type | undefined;
    incompleteGenerationCount: number;
    dependentTypes?: DependentType[];
}
export interface SpeculativeModeOptions {
    dependentType?: Type;
    allowDiagnostics?: boolean;
}
export declare class SpeculativeTypeTracker {
    private _speculativeContextStack;
    private _speculativeTypeCache;
    private _activeDependentTypes;
    enterSpeculativeContext(speculativeRootNode: ParseNode, options?: SpeculativeModeOptions): void;
    leaveSpeculativeContext(): void;
    isSpeculative(node: ParseNode | undefined, ignoreIfDiagnosticsAllowed?: boolean): boolean;
    trackEntry(cache: Map<number, any>, id: number): void;
    disableSpeculativeMode(): SpeculativeContext[];
    enableSpeculativeMode(stack: SpeculativeContext[]): void;
    addSpeculativeType(node: ParseNode, typeResult: TypeResult, incompleteGenerationCount: number, expectedType: Type | undefined): void;
    getSpeculativeType(node: ParseNode, expectedType: Type | undefined): SpeculativeTypeEntry | undefined;
    private _dependentTypesMatch;
}
export {};