import { CancellationToken } from 'vscode-languageserver';
import { Declaration } from '../analyzer/declaration';
import { ParseTreeWalker } from '../analyzer/parseTreeWalker';
import { TypeEvaluator } from '../analyzer/typeEvaluatorTypes';
import { ProgramView, ReferenceUseCase, SymbolUsageProvider } from '../common/extensibility';
import { TextRange } from '../common/textRange';
import { NameNode, ParseNode, StringListNode, StringNode } from '../parser/parseNodes';
export type CollectionResult = {
    node: NameNode | StringNode;
    range: TextRange;
};
export interface DocumentSymbolCollectorOptions {
    readonly treatModuleInImportAndFromImportSame?: boolean;
    readonly skipUnreachableCode?: boolean;
    readonly useCase?: ReferenceUseCase;
    /**
     * If `providers` are set, `collector` will assume
     * `appendSymbolNamesTo` and `appendDeclarationsTo` have already
     * been handled and will not call them again.
     *
     * If `collector` will result in the same `providers`, `symbolNames`, and `decls` for
     * all files, set `providers` so that `collector` doesn't need to perform the same work
     * repeatedly for all files.
     */
    readonly providers?: readonly SymbolUsageProvider[];
}
export declare class AliasResolver {
    private readonly _evaluator;
    private readonly _caches;
    constructor(_evaluator: TypeEvaluator);
    resolve(declaration: Declaration, resolveLocalNames: boolean): Declaration | undefined;
}
export declare class DocumentSymbolCollector extends ParseTreeWalker {
    private readonly _program;
    private readonly _startingNode;
    private readonly _cancellationToken;
    private readonly _results;
    private readonly _dunderAllNameNodes;
    private readonly _symbolNames;
    private readonly _declarations;
    private readonly _usageProviders;
    private readonly _treatModuleInImportAndFromImportSame;
    private readonly _skipUnreachableCode;
    private readonly _useCase;
    private _aliasResolver;
    constructor(_program: ProgramView, symbolNames: string[], declarations: Declaration[], _startingNode: ParseNode, _cancellationToken: CancellationToken, options?: DocumentSymbolCollectorOptions);
    static collectFromNode(program: ProgramView, node: NameNode, cancellationToken: CancellationToken, startingNode?: ParseNode, options?: DocumentSymbolCollectorOptions): CollectionResult[];
    static getDeclarationsForNode(program: ProgramView, node: NameNode, token: CancellationToken, options?: {
        resolveLocalNames?: boolean;
        findImplementations?: boolean;
    }): Declaration[];
    collect(): CollectionResult[];
    walk(node: ParseNode): void;
    visitName(node: NameNode): boolean;
    visitStringList(node: StringListNode): boolean;
    visitString(node: StringNode): boolean;
    private get _evaluator();
    private _addResult;
    private _isDeclarationAllowed;
    private _resultsContainsDeclaration;
    private _getResolveAliasDeclaration;
    private _setDunderAllNodes;
}
export declare function getDeclarationsForNameNode(evaluator: TypeEvaluator, node: NameNode, skipUnreachableCode?: boolean): Declaration[];
export declare function addDeclarationIfUnique(declarations: Declaration[], itemToAdd: Declaration): void;