import { IParsedArguments, TFlagValue } from "./Arguments";
declare type TArgs = string[];
declare type TFlags = Record<string, TFlagValue>;
export declare type TCommandHandler<GFlags extends TFlags = TFlags> = (args?: TArgs, flags?: GFlags, commandName?: string) => any | Promise<any>;
export declare type TCommandStartHandler<GFlags extends TFlags = TFlags> = (commandName: string, error: CommandError, args: TArgs, flags?: GFlags, results?: any[]) => any | Promise<any>;
interface IRegisteredCommand<GFlags extends TFlags = TFlags> {
    name: string;
    handlers: TCommandHandler<GFlags>[];
}
declare class CommandError extends Error {
}
export declare class CLICommands<GFlags extends TFlags = TFlags> {
    protected _registeredCommands: Record<string, IRegisteredCommand>;
    protected _parsedArgs: IParsedArguments;
    get parsedArgs(): IParsedArguments;
    protected _beforeHandlers: TCommandHandler[];
    /**
     * Create a new CLI command entity.
     * Will parse arguments when instantiated.
     * Do not forget to call start() to run the commands !
     * @param defaultFlags Default flag values ( @see parseArguments )
     * @param flagAliases Flag aliases ( @see parseArguments )
     * @param argv CLI arguments to parse, default to process.argv
     */
    constructor(defaultFlags?: GFlags, flagAliases?: Record<string, string>, argv?: string[]);
    /**
     * Register a command.
     * Will replace if command name already exists.
     * Use CLICommands.exists( commandName ) to avoid override.
     * @param name Name of the command or list of commands.
     * @param handler Handler called with options as first argument.
     */
    add(name: string | string[], handler: TCommandHandler<GFlags>): void;
    /**
     * Add an handler which will be executed before all commands when calling start.
     * Handlers will be executed in added order.
     * Return false to halt command executions.
     * @param handler A command handler
     */
    before<G extends object>(handler: TCommandHandler<GFlags>): void;
    /**
     * Get registered commands list
     */
    list(): string[];
    /**
     * Check if a command exists
     */
    exists(commandName: string): boolean;
    /**
     * Run any registered command.
     * Will make a loose check if command is not found
     * ( will accept command starting with commandName )
     * @param commandName Lowercase command name.
     * @param args Arguments passed to command
     * @param flags Flags passed to command
     */
    run(commandName: string, args: TArgs, flags: GFlags): Promise<any[]>;
    /**
     * Start parsing arguments and run command with flags
     * @param defaultHandler Called when command has not been found.
     * @returns {Promise<void>}
     */
    start(defaultHandler?: TCommandStartHandler): Promise<void>;
}
export {};