import type AmbiguityConsumer from './AmbiguityConsumer';
import ParseResults from './ParseResults';
import type ResultConsumer from './ResultConsumer';
import StringReader from './StringReader';
import type LiteralArgumentBuilder from './builder/LiteralArgumentBuilder';
import Suggestions from './suggestion/Suggestions';
import type CommandNode from './tree/CommandNode';
import type LiteralCommandNode from './tree/LiteralCommandNode';
import RootCommandNode from './tree/RootCommandNode';
export default class CommandDispatcher<S> {
    private root;
    private consumer;
    constructor(root?: RootCommandNode<S> | null);
    register(command: LiteralArgumentBuilder<S>): LiteralCommandNode<S>;
    setConsumer(consumer: ResultConsumer<S>): void;
    execute(input: string | StringReader | ParseResults<S>, source?: S | null): Promise<any> | Promise<any>[] | any;
    parse(command: string | StringReader, source: S): ParseResults<S>;
    private parseNodes;
    getAllUsage(node: CommandNode<S>, source: S, restricted: boolean): string[];
    private __getAllUsage;
    getSmartUsage(node: CommandNode<S>, source: S): Map<CommandNode<S>, string>;
    private __getSmartUsage;
    getCompletionSuggestions(parse: ParseResults<S>, cursor?: number): Promise<Suggestions>;
    getRoot(): RootCommandNode<S>;
    getPath(target: CommandNode<S>): string[];
    findNode(path: string[]): CommandNode<S> | null;
    findAmbiguities(consumer: AmbiguityConsumer<S>, context: any): void;
    private addPaths;
}
//# sourceMappingURL=CommandDispatcher.d.ts.map