import { CancellationToken, CodeAction, Command, CompletionItem, CompletionList, DocumentHighlight, DocumentHighlightKind, ExecuteCommandParams, Location, MarkupKind, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
import { BackgroundAnalysisProgramFactory } from '../../../analyzer/backgroundAnalysisProgram';
import { ImportResolver, ImportResolverFactory } from '../../../analyzer/importResolver';
import { PackageTypeReport } from '../../../analyzer/packageTypeReport';
import { Program } from '../../../analyzer/program';
import { AnalyzerService } from '../../../analyzer/service';
import { ConfigOptions } from '../../../common/configOptions';
import { ConsoleInterface } from '../../../common/console';
import { DocumentRange } from '../../../common/docRange';
import { FileEditAction } from '../../../common/editAction';
import { ReadOnlyFileSystem } from '../../../common/fileSystem';
import { Host } from '../../../common/host';
import { LanguageServerInterface } from '../../../common/languageServerInterface';
import { ServiceProvider } from '../../../common/serviceProvider';
import { Position, Range as PositionRange, TextRange } from '../../../common/textRange';
import { Uri } from '../../../common/uri/uri';
import { DefinitionFilter } from '../../../languageService/definitionProvider';
import { CollectionResult } from '../../../languageService/documentSymbolCollector';
import { ParseNode } from '../../../parser/parseNodes';
import { ParseFileResults } from '../../../parser/parser';
import { PyrightFileSystem } from '../../../pyrightFileSystem';
import { NormalWorkspace, Workspace } from '../../../workspaceFactory';
import * as vfs from '../vfs/filesystem';
import { FourSlashData, FourSlashFile, Marker, MultiMap, Range } from './fourSlashTypes';
export interface TextChange {
    span: TextRange;
    newText: string;
}
export interface HostSpecificFeatures {
    importResolverFactory: ImportResolverFactory;
    backgroundAnalysisProgramFactory: BackgroundAnalysisProgramFactory;
    getCodeActionsForPosition(workspace: Workspace, fileUri: Uri, range: PositionRange, token: CancellationToken): Promise<CodeAction[]>;
    execute(ls: LanguageServerInterface, params: ExecuteCommandParams, token: CancellationToken): Promise<any>;
}
export declare class TestState {
    testData: FourSlashData;
    private readonly _cancellationToken;
    private readonly _vfsFiles;
    protected readonly files: string[];
    private readonly _hostSpecificFeatures;
    readonly testFS: vfs.TestFileSystem;
    readonly fs: PyrightFileSystem;
    readonly workspace: NormalWorkspace;
    readonly console: ConsoleInterface;
    readonly rawConfigJson: any | undefined;
    readonly serviceProvider: ServiceProvider;
    currentCaretPosition: number;
    selectionEnd: number;
    lastKnownMarker: string;
    activeFile: FourSlashFile;
    constructor(projectRoot: string, testData: FourSlashData, mountPaths?: Map<string, string>, hostSpecificFeatures?: HostSpecificFeatures, testFS?: vfs.TestFileSystem, delayFileInitialization?: boolean);
    get importResolver(): ImportResolver;
    get configOptions(): ConfigOptions;
    get program(): Program;
    get BOF(): number;
    get EOF(): number;
    initializeFiles(): void;
    dispose(): void;
    cwd(): string;
    goToMarker(nameOrMarker?: string | Marker): void;
    goToEachMarker(markers: readonly Marker[], action: (marker: Marker, index: number) => void): void;
    getMappedFilePath(path: string): string;
    getMarkerName(m: Marker): string;
    getMarkerByName(markerName: string): Marker;
    getMarkers(): Marker[];
    getMarkerNames(): string[];
    getPositionRange(markerString: string): PositionRange;
    getPosition(markerString: string): Position;
    expandPositionRange(range: PositionRange, start: number, end: number): {
        start: {
            line: number;
            character: number;
        };
        end: {
            line: number;
            character: number;
        };
    };
    convertPositionRange(range: Range): PositionRange;
    getPathSep(): "\\" | "/";
    goToPosition(positionOrLineAndColumn: number | Position): void;
    select(startMarker: string, endMarker: string): void;
    selectAllInFile(fileName: string): void;
    selectRange(range: Range): void;
    selectLine(index: number): void;
    goToEachRange(action: (range: Range) => void): void;
    goToRangeStart({ fileName, pos }: Range): void;
    getRanges(): Range[];
    getRangesInFile(fileName?: string): Range[];
    getRangesByText(): Map<string, Range[]>;
    getFilteredRanges<T extends {}>(predicate: (m: Marker | undefined, d: T | undefined, text: string) => boolean): Range[];
    getRangeByMarkerName(markerName: string): Range | undefined;
    goToBOF(): void;
    goToEOF(): void;
    moveCaretRight(count?: number): void;
    openFile(indexOrName: number | string): FourSlashFile;
    openFiles(indexOrNames: (number | string)[]): void;
    printCurrentFileState(showWhitespace: boolean, makeCaretVisible: boolean): void;
    deleteChar(count?: number): void;
    replace(start: number, length: number, text: string): void;
    deleteLineRange(startIndex: number, endIndexInclusive: number): void;
    deleteCharBehindMarker(count?: number): void;
    type(text: string): void;
    paste(text: string): void;
    verifyDiagnostics(map?: {
        [marker: string]: {
            category: string;
            message: string;
        };
    }): void;
    verifyCodeActions(verifyMode: _.FourSlashVerificationMode, map: {
        [marker: string]: {
            codeActions: {
                title: string;
                kind: string;
                command?: Command;
                edit?: WorkspaceEdit;
            }[];
        };
    }): Promise<any>;
    verifyCommand(command: Command, files: {
        [filePath: string]: string;
    }): Promise<any>;
    verifyWorkspaceEdit(expected: WorkspaceEdit, actual: WorkspaceEdit, marker?: string): void;
    verifyInvokeCodeAction(map: {
        [marker: string]: {
            title: string;
            files?: {
                [filePath: string]: string;
            };
            edits?: TextEdit[];
        };
    }, verifyCodeActionCount?: boolean): Promise<any>;
    verifyHover(kind: MarkupKind, map: {
        [marker: string]: string | null;
    }): void;
    verifyCaretAtMarker(markerName?: string): void;
    verifyCurrentLineContent(text: string): void;
    verifyCurrentFileContent(text: string): void;
    verifyTextAtCaretIs(text: string): void;
    verifyRangeIs(expectedText: string, includeWhiteSpace?: boolean): void;
    verifyCompletion(verifyMode: _.FourSlashVerificationMode, docFormat: MarkupKind, map: {
        [marker: string]: {
            completions: _.FourSlashCompletionItem[];
        };
    }, abbrMap?: {
        [abbr: string]: {
            readonly importFrom?: string;
            readonly importName: string;
        };
    }): Promise<void>;
    verifySignature(docFormat: MarkupKind, map: {
        [marker: string]: {
            noSig?: boolean;
            signatures?: {
                label: string;
                parameters: string[];
                documentation?: string;
            }[];
            activeParameters?: (number | undefined)[];
            callHasParameters?: boolean;
        };
    }): void;
    verifyFindAllReferences(map: {
        [marker: string]: {
            references: DocumentRange[];
        };
    }, createDocumentRange?: (fileUri: Uri, result: CollectionResult, parseResults: ParseFileResults) => DocumentRange, convertToLocation?: (fs: ReadOnlyFileSystem, ranges: DocumentRange) => Location | undefined): void;
    verifyShowCallHierarchyGetIncomingCalls(map: {
        [marker: string]: {
            items: _.FourSlashCallHierarchyItem[];
        };
    }): void;
    verifyShowCallHierarchyGetOutgoingCalls(map: {
        [marker: string]: {
            items: _.FourSlashCallHierarchyItem[];
        };
    }): void;
    getDocumentHighlightKind(m?: Marker): DocumentHighlightKind | undefined;
    verifyHighlightReferences(map: {
        [marker: string]: {
            references: DocumentHighlight[];
        };
    }): void;
    fixupDefinitionsToMatchExpected(actual: DocumentRange[] | undefined): any;
    verifyFindDefinitions(map: {
        [marker: string]: {
            definitions: DocumentRange[];
        };
    }, filter?: DefinitionFilter): void;
    verifyFindTypeDefinitions(map: {
        [marker: string]: {
            definitions: DocumentRange[];
        };
    }): void;
    verifyRename(map: {
        [marker: string]: {
            newName: string;
            changes: FileEditAction[];
        };
    }, isUntitled?: boolean): void;
    verifyTypeVerifierResults(packageName: string, ignoreUnknownTypesFromImports: boolean, verboseOutput: boolean, expected: PackageTypeReport): void;
    setCancelled(numberOfCalls: number): void;
    resetCancelled(): void;
    convertPositionToOffset(fileName: string, position: Position): number;
    convertOffsetToPosition(fileName: string, offset: number): Position;
    analyze(): void;
    protected findFile(indexOrName: string | number): FourSlashFile;
    protected getCompletionResults(state: TestState, marker: Marker, docFormat: MarkupKind, abbrMap?: {
        [abbr: string]: {
            readonly importFrom?: string;
            readonly importName: string;
        };
    }): {
        getCompletions(): CompletionList | null;
        resolveCompletionItem(item: CompletionItem): void;
    };
    protected getFileContent(fileName: string): string;
    protected convertOffsetsToRange(fileName: string, startOffset: number, endOffset: number): PositionRange;
    protected raiseError(message: string): never;
    protected createMultiMap<T>(values?: T[], getKey?: (t: T) => string): MultiMap<T>;
    protected rangeText({ fileName, pos, end }: Range): string;
    protected verifyCompletionItem(expected: _.FourSlashCompletionItem, actual: CompletionItem): void;
    protected createAnalysisService(nullConsole: ConsoleInterface, importResolverFactory: ImportResolverFactory, backgroundAnalysisProgramFactory: BackgroundAnalysisProgramFactory, configOptions: ConfigOptions, host: Host): AnalyzerService;
    private _convertGlobalOptionsToConfigOptions;
    private _applyTestConfigOptions;
    private _getParserOutput;
    private _getTextRangeCollection;
    private _messageAtLastKnownMarker;
    private _checkPostEditInvariants;
    private _editScriptAndUpdateMarkers;
    private _removeWhitespace;
    private _getOnlyRange;
    private _verifyFileContent;
    private _verifyTextMatches;
    private _getSelection;
    private _getLineContent;
    private _getCurrentLineContent;
    private _tryFindFileWorker;
    private _getLineColStringAtPosition;
    private _showTextDiff;
    private _differOnlyByWhitespace;
    private _displayExpectedAndActualString;
    private _makeWhitespaceVisible;
    private _updatePosition;
    private _getDiagnosticsPerFile;
    private _deepEqual;
    private _waitForFile;
    private _getCodeActions;
    private _verifyFiles;
    private _editsAreEqual;
    private _verifyEdit;
    private _verifyEdits;
}
export declare function parseAndGetTestState(code: string, projectRoot?: string, anonymousFileName?: string, testFS?: vfs.TestFileSystem): {
    data: FourSlashData;
    state: TestState;
};
export declare function getNodeForRange(codeOrState: string | TestState, markerName?: string): ParseNode;
export declare function getNodeAtMarker(codeOrState: string | TestState, markerName?: string): ParseNode;