export declare type ArgumentValue = any;
export declare type OptionValue = ArgumentValue | {
    [name: string]: ArgumentValue;
};
export declare type ParsedArguments = {
    [name: string]: ArgumentValue;
};
export declare type ParsedOptions = {
    [name: string]: OptionValue;
};
export declare type Validator = (value: ArgumentValue, input: ParsedInput) => Promise<string | boolean> | string | boolean;
export declare type OnParseHook = (value: ArgumentValue, input: ParsedInput) => void;
export declare type OnProcessHook = (value: ArgumentValue, input: ParsedInput, assign: (value: any) => Promise<void>) => Promise<void> | void;
export declare type CommandHandler = (args: ParsedArguments, opts: ParsedOptions, extra?: string[]) => Promise<any> | any;
export declare type Argument = {
    name: string;
    required?: boolean;
    variadic?: boolean;
    description?: string;
    defaultValue?: ArgumentValue;
    onParse?: OnParseHook;
    onProcess?: OnProcessHook;
    validator?: Validator;
};
export declare type Option = {
    name: [string, string];
    required?: boolean;
    negatable?: boolean;
    args?: Argument[];
    defaultValue?: OptionValue;
    description?: string;
    inherited?: boolean;
    onParse?: OnParseHook;
    onProcess?: OnProcessHook;
    validator?: Validator;
};
export declare type ParsedInput = {
    args: ParsedArguments;
    opts: ParsedOptions;
    extra?: string[];
};
export declare type CliCommandOptions = {
    inheritOpts?: boolean | {
        except: string[];
    };
    except?: string[];
    consumeUnknownArgs?: boolean;
    consumeUnknownOpts?: boolean;
};
export declare type OptionDefinition = {
    name: [string, string];
    args: ArgumentDefinition[];
    description?: string;
    required?: boolean;
    negatable?: boolean;
    defaultValue?: any;
};
export declare type ArgumentDefinition = {
    name: string;
    description?: string;
    required?: boolean;
    defaultValue?: any;
    variadic?: boolean;
};
export declare type CommandDefinition = {
    name: string;
    version?: string;
    description?: string;
    opts: OptionDefinition[];
    args: ArgumentDefinition[];
    subCommands: CommandDefinition[];
    extra?: any;
};
export declare class CliCommand {
    name: string;
    version: string;
    description: string;
    private handler?;
    private handlerContext?;
    private helpHandler;
    private inheritOpts?;
    private consumeUnknownArgs?;
    private consumeUnknownOpts?;
    private args;
    private opts;
    private subCommands;
    private shortNameMap;
    private argsMap;
    private negatableOptsMap;
    private extra;
    private onProcessQueue;
    private parsed;
    constructor(name: string, opts?: CliCommandOptions);
    withDescription(description: string): CliCommand;
    withArguments(...args: Argument[]): CliCommand;
    withOptions(...options: Option[]): CliCommand;
    inheritOptions(...options: Option[]): void;
    private shouldInheritOption;
    withSubCommands(...commands: CliCommand[]): CliCommand;
    /**
     * Registers the handler that will be called when command.process() finishes.
     * The arguments provided to the handler will be the result of command.parse().
     * By default, the calling context of the handler is the CliCommand object.
     * If needed, a calling context can be provided which will be bound to the handler
     * before invoking it.
     * @param handler The handler to invoke when .process() finishes
     * @param context (Optional) the calling context to bind to the handler before invoking
    */
    withHandler(handler: CommandHandler, context?: any): CliCommand;
    help(): void;
    withHelpHandler(handler: (command: CommandDefinition) => void): CliCommand;
    withVersion(version: string, handler?: (command: CommandDefinition) => void): CliCommand;
    withExtra(extra: any): CliCommand;
    dump(dumped?: CliCommand[]): CommandDefinition;
    /**
     * Parses the process arguments and generates args, opts, and extra objects.
     * Invokes onParse() hooks on all arguments and options. Does not invoke
     * onProcess() hooks, validators, or command handlers.
     * @param processArgs The process arguments (typically process.argv)
     * @param opts parse() automatically strips the first two arguments from its input.
     * To prevent this, set opts.stripExecScript to false.
     */
    parse(processArgs: string[], opts?: {
        raw?: boolean;
    }): ParsedInput;
    process(processArgs: string[], opts?: {
        raw?: boolean;
    }): Promise<any>;
    private dumpOption;
    private dumpArgument;
    private checkForMissingCommandHandlers;
    private runOnProcessHooks;
    private runValidators;
    private validate;
    private getCommand;
    private consumeOption;
    private consumeArgument;
    private consumeVariadicArguments;
    private consumeSingleArgument;
    /**
     * To be called at the end of parsing, checks that all required options have been
     * assigned and assigns default values to all unassigned, optional options
     */
    private handleUnassignedOptions;
    /**
     * To be called at the end of parsing, checks that all required arguments
     * have been assigned and assigns default values to all unassigned, optional args
     */
    private handleUnassignedArguments;
    private checkOption;
    private checkArgument;
    private checkSubCommand;
    /**
     * Returns the camelCased version of the short flag of an option.
     * @param opt An option with a short flag definition.
     */
    private getShortName;
    /**
     * Returns the camelCased name of an option, arguemnt, or flag definition (string).
     * If the passed string is a short-flag definition (e.g. "-v" for the "--verbose" flag)
     * the long name (in this case "verbose") will be returned.
     * @param arg The option, argument, or flag definition to get the name for.
     */
    private getName;
    /**
     * Utility method for testing empty objects or arrays
     * @param obj Object or array to test
     */
    private isEmpty;
    /**
     * Splits all --option=value strings into ['--option', 'value'] so they
     * can be parsed consistently
     * @param processArgs process.argv
     */
    private splitOptionAssignments;
    private checkInheritOpts;
}