/// <reference types="node" />
import { AsyncLocalStorage } from 'node:async_hooks';
export declare class CliContext {
    readonly exec: string;
    readonly script: string;
    readonly command: CommandCompose;
    readonly state: Record<any, any>;
    constructor(exec: string, script: string, command: CommandCompose);
    set<T = any>(key: any, value: T): T;
    value<T = any>(key: any): T | undefined;
    /**
     * get command flag/arg value, return default value if not exists
     * @param name
     * @returns
     */
    read(name: string): any;
    /**
     * get command flag value, return default value if not exists
     * @param name
     * @returns
     */
    flag(name: string): any;
    /**
     * get command arg value, return default value if not exists
     * @param name
     * @returns
     */
    arg(name: string): any;
    log(message: string, ...arg: any): void;
    info(message: string): void;
    error(message: string): void;
    infof(message: string, ...arg: any): void;
    json(data: any): void;
    prompt(question: string): Promise<unknown>;
    confirm(question: string): Promise<unknown>;
    throw(error: Error): never;
}
export interface ICliParsedFlag {
    name: string;
    value: true | string;
}
export declare class CliApplication {
    readonly opts: {
        asyncLocalStorage?: boolean | AsyncLocalStorage<any>;
    };
    protected asyncLocalStorage?: AsyncLocalStorage<any>;
    protected commands: ICommand[];
    protected _fallback: ICommand | null;
    readonly middlewares: CliAppMiddleware[];
    constructor(opts?: {
        asyncLocalStorage?: boolean | AsyncLocalStorage<any>;
    });
    command(command: ICommand): void;
    fallback(command: ICommand): void;
    find(name: string): ICommand | null;
    use(fn: CliAppMiddleware): void;
    handle(): Promise<void>;
}
export interface ICommand {
    signature: string;
    description: string;
    compose(): CommandCompose;
    handle(ctx: CliContext): Promise<any> | any;
}
export declare class CommandCompose {
    readonly name: string;
    readonly flags: ICommandFlag[];
    readonly args: ICommandArg[];
    readonly map: Record<string, {
        flag: ICommandFlag;
    } | {
        arg: ICommandArg;
    }>;
    constructor(name: string);
    /**
     * only for composing command
     * @param flags
     * @returns
     */
    flag(...flags: ICommandFlag[]): this;
    /**
     * only for composing command
     * @param args
     * @returns
     */
    arg(...args: ICommandArg[]): this;
    /**
     * get command param, can be flag or arg
     * @param name
     * @returns
     */
    get(name: string): any;
    /**
     * get command flag/arg value
     * @param name
     * @returns
     */
    value(name: string): any;
    /**
     * get command flag/arg value, if not exists return default value
     * @param name
     * @returns
     */
    read(name: string): any;
}
export interface ICommandArg<T = any> {
    name: string;
    default?: T;
    value?: T;
    type?: Boolean | Number | String;
}
export interface ICommandFlag<T = any> extends ICommandArg<T> {
    alias?: string;
    multiple?: boolean;
}
export interface ICliMiddleware {
    handle(ctx: any, next: any): Promise<any>;
}
export type CliMiddlewareCallback = (ctx: any, next: any) => Promise<any>;
export type CliAppMiddleware = CliMiddlewareCallback | ICliMiddleware;