import { CancellationToken, Location, ResultProgressReporter } from 'vscode-languageserver';
import { Declaration } from '../analyzer/declaration';
import { DocumentRange } from '../common/docRange';
import { ProgramView, ReferenceUseCase, SymbolUsageProvider } from '../common/extensibility';
import { ReadOnlyFileSystem } from '../common/fileSystem';
import { Position, Range } from '../common/textRange';
import { Uri } from '../common/uri/uri';
import { NameNode, ParseNode } from '../parser/parseNodes';
import { ParseFileResults } from '../parser/parser';
import { CollectionResult } from './documentSymbolCollector';
export type ReferenceCallback = (locations: DocumentRange[]) => void;
export interface LocationWithNode {
    location: DocumentRange;
    parentRange?: Range;
    node: ParseNode;
}
export declare class ReferencesResult {
    readonly requiresGlobalSearch: boolean;
    readonly nodeAtOffset: ParseNode;
    readonly symbolNames: string[];
    readonly declarations: Declaration[];
    readonly useCase: ReferenceUseCase;
    readonly providers: readonly SymbolUsageProvider[];
    private readonly _reporter?;
    private readonly _results;
    readonly nonImportDeclarations: Declaration[];
    constructor(requiresGlobalSearch: boolean, nodeAtOffset: ParseNode, symbolNames: string[], declarations: Declaration[], useCase: ReferenceUseCase, providers: readonly SymbolUsageProvider[], _reporter?: ReferenceCallback | undefined);
    get containsOnlyImportDecls(): boolean;
    get locations(): readonly DocumentRange[];
    get results(): readonly LocationWithNode[];
    addResults(...locs: LocationWithNode[]): void;
}
export declare class FindReferencesTreeWalker {
    private _program;
    private _fileUri;
    private _referencesResult;
    private _includeDeclaration;
    private _cancellationToken;
    private readonly _createDocumentRange;
    private _parseResults;
    constructor(_program: ProgramView, _fileUri: Uri, _referencesResult: ReferencesResult, _includeDeclaration: boolean, _cancellationToken: CancellationToken, _createDocumentRange?: (fileUri: Uri, result: CollectionResult, parseResults: ParseFileResults) => DocumentRange);
    findReferences(rootNode?: import("../parser/parseNodes").ModuleNode | undefined): LocationWithNode[];
    static createDocumentRange(fileUri: Uri, result: CollectionResult, parseResults: ParseFileResults): DocumentRange;
}
export declare class ReferencesProvider {
    private _program;
    private _token;
    private readonly _createDocumentRange?;
    private readonly _convertToLocation?;
    constructor(_program: ProgramView, _token: CancellationToken, _createDocumentRange?: ((fileUri: Uri, result: CollectionResult, parseResults: ParseFileResults) => DocumentRange) | undefined, _convertToLocation?: ((fs: ReadOnlyFileSystem, ranges: DocumentRange) => Location | undefined) | undefined);
    reportReferences(fileUri: Uri, position: Position, includeDeclaration: boolean, resultReporter?: ResultProgressReporter<Location[]>): Location[] | undefined;
    addReferencesToResult(fileUri: Uri, includeDeclaration: boolean, referencesResult: ReferencesResult): void;
    static getDeclarationForNode(program: ProgramView, fileUri: Uri, node: NameNode, reporter: ReferenceCallback | undefined, useCase: ReferenceUseCase, token: CancellationToken): ReferencesResult | undefined;
    static getDeclarationForPosition(program: ProgramView, fileUri: Uri, position: Position, reporter: ReferenceCallback | undefined, useCase: ReferenceUseCase, token: CancellationToken): ReferencesResult | undefined;
}