import { CommandOption } from './decractors';
export declare const SymbolExecuteParams: unique symbol;
export declare const SymbolMeta: unique symbol;
export declare class DefinationError extends Error {
    CODE: string;
}
export declare class ExecuteError extends Error {
    CODE: string;
    exitCode: number;
    constructor(message: string, exitCode?: number);
}
export interface ArgumentDefinition {
    name: string;
    default?: any;
    description?: string;
    isOptional?: boolean;
    isArray?: boolean;
    transform?: (v: any) => any;
}
export interface OptionDefinition extends ArgumentDefinition {
    flag?: string;
    isBoolean?: boolean;
    callback?: (v: any, options: Object) => void;
}
export declare const defaultArgDef: {
    description: string;
    isOptional: boolean;
    isArray: boolean;
};
export declare const defaultOptionDef: {
    description: string;
    isOptional: boolean;
    isArray: boolean;
    isBoolean: boolean;
};
/**
 * argument sinature should be:
 * compatible with laravel signature:
 *      name*  : description
 *      name?  : description
 *      name?* : description
 * version?=  : description
 * version=  : description
 * array=*
 * has-defaut=value
 */
export declare function parseArgumentSinagure(signature: string): ArgumentDefinition;
/**
 * option sinature should be:
 * --version=  : description
 * --V|version
 * --array=*
 * --has-defaut=value
 *
 * @export
 * @param {string} signature
 * @returns
 */
export declare function parseOptionSignature(signature: string): OptionDefinition;
export interface ExecuteParams {
    args: any;
    options: any;
}
export declare type Action = (args: ExecuteParams) => any;
export declare abstract class BaseCommand {
    name: string;
    description: string;
    version: string;
    options: {
        [k: string]: OptionDefinition;
    };
    args: {
        [k: string]: ArgumentDefinition;
    };
    abstract run(argv: string[]): any;
    abstract getHelpText(): string;
    setName(name: string): void;
    /**
     * add version option
     *
     * @param {string} version
     * @param {string} [signature='--V|version']
     * @returns
     * @memberof Command
     */
    setVersion(version: string, signature?: string): this;
    /**
     * print help text with process.stdout
     *
     * @returns
     * @memberof GroupCommand
     */
    printHelp(): void;
    /**
     *  add an option definition with signature
     *
     * @param {string} signature
     * @param {Partial<OptionDefinition>} [part]
     * @returns
     * @memberof GroupCommand
     */
    addOption(signature: string, part?: Partial<OptionDefinition>): this;
    /**
     * add option definition without signature
     *
     * @param {OptionDefinition} def
     * @returns {this}
     * @memberof BaseCommand
     */
    addOption(def: OptionDefinition): this;
    /**
     * merge option meta
     *
     * @param {string} name
     * @param {Partial<OptionDefinition>} [part]
     * @returns
     * @memberof Command
     */
    mergeOption(name: string, part?: Partial<OptionDefinition>): this;
    /**
     * execute command
     *
     * @param {*} [argv=process.argv.slice(2)]
     * @returns
     * @memberof Command
     */
    execute(argv?: string[]): Promise<void>;
    protected processArgs(argsRaw: string[]): any;
    protected processOptions(optionsRaw: any): any;
}
export declare class Command extends BaseCommand {
    protected _action: Action;
    constructor(signature?: string | Action);
    constructor(signature?: string, action?: Action);
    /**
     * set the commond action
     *
     * @param {Action} func
     * @memberof Command
     */
    setAction(func: Action): this;
    run(argv: string[]): any;
    /**
     * add an argument definition
     *
     * @param {string} signature
     * @param {Partial<ArgumentDefinition>} [part]
     * @returns
     * @memberof Command
     */
    addArg(signature: string, part?: Partial<ArgumentDefinition>): this;
    addArg(def: ArgumentDefinition): this;
    /**
     * get help text but not print
     *
     * @returns
     * @memberof GroupCommand
     */
    getHelpText(): string;
    /**
     * remove default --help option
     *
     * @memberof Command
     */
    removeHelpOption(): this;
    /**
     * custom help text
     *
     * @param {(string | ((origin: string) => string))} s
     * @param {string} [option='--help']
     * @memberof Command
     */
    customHelp(s: string | ((origin: string) => string), option?: string): this;
    protected parseSignature(signature: string): this;
    protected parseArgv(argv: string[]): {
        options: any;
        args: string[];
    };
}
export declare class GroupCommand extends BaseCommand {
    name: string;
    protected commands: {
        [k: string]: BaseCommand;
    };
    constructor();
    addCommands(arr: Command[]): this;
    /**
     * add a sub commond with Command instance or creator
     *
     * @param {(BaseCommand | (() => BaseCommand))} v
     * @returns {this}
     * @memberof GroupCommand
     */
    addCommand(v: BaseCommand | ((g: GroupCommand) => BaseCommand)): this;
    /**
     * add a commond with signature
     *
     * @param {string} v
     * @param {Action} action
     * @returns {this}
     * @memberof GroupCommand
     */
    addCommand(v: string, action: Action): this;
    /**
     * get help text but not print
     *
     * @returns
     * @memberof GroupCommand
     */
    getHelpText(): string;
    /**
     * execute command
     *
     * @param {string[]} argv
     * @returns
     * @memberof GroupCommand
     */
    run(argv: string[]): any;
    scanCommands(patthern: string): this;
    /**
     * return commond description for group commond
     *
     * @returns
     * @memberof Command
     */
    protected getSubCommondDescription(c: BaseCommand): string;
    protected meta2Command(t: Function, meta: CommandOption): Command;
    protected parseArgvUntilCommand(argv: string[]): {
        options: any;
        args: string[];
        restArgv: string[];
    };
}