import type Command from '../Command';
import type Predicate from '../Predicate';
import type RedirectModifier from '../RedirectModifier';
import StringReader from '../StringReader';
import type ArgumentType from '../arguments/ArgumentType';
import ArgumentBuilder from '../builder/ArgumentBuilder';
import type SuggestionProvider from '../suggestion/SuggestionProvider';
import type CommandContext from '../context/CommandContext';
import type CommandContextBuilder from '../context/CommandContextBuilder';
import Suggestions from '../suggestion/Suggestions';
import type SuggestionsBuilder from '../suggestion/SuggestionsBuilder';
import CommandNode from './CommandNode';
export default class ArgumentCommandNode<S, T> extends CommandNode<S> {
    private name;
    private type;
    private customSuggestions;
    constructor(name: string, type: ArgumentType<T>, command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S> | null, modifier: RedirectModifier<S> | null, forks: boolean, customSuggestions: SuggestionProvider<S>);
    getNodeType(): string;
    getType(): ArgumentType<T>;
    getName(): string;
    getUsageText(): string;
    getCustomSuggestions(): SuggestionProvider<S> | null;
    parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void;
    listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
    createBuilder(): RequiredArgumentBuilder<S, T>;
    isValidInput(input: string, context: any): boolean;
    equals(o: object): boolean;
    getSortedKey(): string;
    getExamples(): Iterable<string>;
    toString(): string;
}
export declare class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<S, RequiredArgumentBuilder<S, T>> {
    private name;
    private type;
    private suggestionsProvider;
    private constructor();
    static argument<S, T>(name: string, type: ArgumentType<T>): RequiredArgumentBuilder<S, T>;
    suggests(provider: SuggestionProvider<S>): RequiredArgumentBuilder<S, T>;
    getSuggestionsProvider(): SuggestionProvider<S>;
    getThis(): RequiredArgumentBuilder<S, T>;
    getType(): ArgumentType<T>;
    getName(): string;
    build(): ArgumentCommandNode<S, T>;
}
/** Starts a required argument node builder. */
export declare function argument<S, T>(name: string, type: ArgumentType<T>): RequiredArgumentBuilder<S, T>;
//# sourceMappingURL=ArgumentCommandNode.d.ts.map