import { Config } from './config';
import { PrettyPrintableError } from './errors';
import { LoadOptions } from './interfaces/config';
import { CommandError } from './interfaces/errors';
import { ArgInput, ArgOutput, ArgProps, BooleanFlagProps, Deprecation, FlagInput, FlagOutput, Arg as IArg, Flag as IFlag, Input, OptionFlagProps, ParserOutput } from './interfaces/parser';
import { Plugin } from './interfaces/plugin';
/**
 * An abstract class which acts as the base for each command
 * in your project.
 */
export declare abstract class Command {
    argv: string[];
    config: Config;
    /** An array of aliases for this command. */
    static aliases: string[];
    /** An order-dependent object of arguments for the command */
    static args: ArgInput;
    static baseFlags: FlagInput;
    /**
     * Emit deprecation warning when a command alias is used
     */
    static deprecateAliases?: boolean;
    static deprecationOptions?: Deprecation;
    /**
     * A full description of how to use the command.
     *
     * If no summary, the first line of the description will be used as the summary.
     */
    static description: string | undefined;
    static enableJsonFlag: boolean;
    /**
     * An array of examples to show at the end of the command's help.
     *
     * IF only a string is provided, it will try to look for a line that starts
     * with the cmd.bin as the example command and the rest as the description.
     * If found, the command will be formatted appropriately.
     *
     * ```
     * EXAMPLES:
     *   A description of a particular use case.
     *
     *     $ <%= config.bin => command flags
     * ```
     */
    static examples: Command.Example[];
    /** A hash of flags for the command */
    static flags: FlagInput;
    static hasDynamicHelp: boolean;
    static help: string | undefined;
    /** Hide the command from help */
    static hidden: boolean;
    /** An array of aliases for this command that are hidden from help. */
    static hiddenAliases: string[];
    /** A command ID, used mostly in error or verbose reporting. */
    static id: string;
    static plugin: Plugin | undefined;
    static readonly pluginAlias?: string;
    static readonly pluginName?: string;
    static readonly pluginType?: string;
    /** Mark the command as a given state (e.g. beta or deprecated) in help */
    static state?: 'beta' | 'deprecated' | string;
    /** When set to false, allows a variable amount of arguments */
    static strict: boolean;
    /**
     * The tweet-sized description for your class, used in a parent-commands
     * sub-command listing and as the header for the command help.
     */
    static summary?: string;
    /**
     * An override string (or strings) for the default usage documentation.
     */
    static usage: string | string[] | undefined;
    protected debug: (...args: any[]) => void;
    id: string | undefined;
    private static readonly _base;
    constructor(argv: string[], config: Config);
    /**
     * actual command run code goes here
     */
    abstract run(): Promise<any>;
    /**
     * instantiate and run the command
     *
     * @param {Command.Class} this - the command class
     * @param {string[]} argv argv
     * @param {LoadOptions} opts options
     * @returns {Promise<unknown>} result
     */
    static run<T extends Command>(this: new (argv: string[], config: Config) => T, argv?: string[], opts?: LoadOptions): Promise<ReturnType<T['run']>>;
    protected get ctor(): typeof Command;
    protected catch(err: CommandError): Promise<any>;
    error(input: Error | string, options: {
        code?: string;
        exit: false;
    } & PrettyPrintableError): void;
    error(input: Error | string, options?: {
        code?: string;
        exit?: number;
    } & PrettyPrintableError): never;
    exit(code?: number): never;
    protected finally(_: Error | undefined): Promise<any>;
    protected init(): Promise<any>;
    /**
     * Determine if the command is being run with the --json flag in a command that supports it.
     *
     * @returns {boolean} true if the command supports json and the --json flag is present
     */
    jsonEnabled(): boolean;
    log(message?: string, ...args: any[]): void;
    protected logJson(json: unknown): void;
    logToStderr(message?: string, ...args: any[]): void;
    protected parse<F extends FlagOutput, B extends FlagOutput, A extends ArgOutput>(options?: Input<F, B, A>, argv?: string[]): Promise<ParserOutput<F, B, A>>;
    protected toErrorJson(err: unknown): any;
    protected toSuccessJson(result: unknown): any;
    warn(input: Error | string): Error | string;
    protected warnIfCommandDeprecated(): void;
    protected warnIfFlagDeprecated(flags: Record<string, unknown>): void;
    protected _run<T>(): Promise<T>;
    private removeEnvVar;
}
export declare namespace Command {
    /**
     * The Command class exported by a command file.
     */
    type Class = typeof Command & {
        id: string;
        run(argv?: string[], config?: LoadOptions): Promise<any>;
    };
    /**
     * A cached command that's had a `load` method attached to it.
     *
     * The `Plugin` class loads the commands from the manifest (if it exists) or requires and caches
     * the commands directly from the commands directory inside the plugin. At this point the plugin
     * is working with `Command.Cached`. It then appends a `load` method to each one. If the a command
     * is executed then the `load` method is used to require the command class.
     */
    type Loadable = Cached & {
        load(): Promise<Command.Class>;
    };
    /**
     * A cached version of the command. This is created by the cachedCommand utility and
     * stored in the oclif.manifest.json.
     */
    type Cached = {
        [key: string]: unknown;
        aliasPermutations?: string[];
        aliases: string[];
        args: {
            [name: string]: Arg.Cached;
        };
        deprecateAliases?: boolean;
        deprecationOptions?: Deprecation;
        description?: string;
        examples?: Example[];
        flags: {
            [name: string]: Flag.Cached;
        };
        hasDynamicHelp?: boolean;
        hidden: boolean;
        hiddenAliases: string[];
        id: string;
        isESM?: boolean;
        permutations?: string[];
        pluginAlias?: string;
        pluginName?: string;
        pluginType?: string;
        relativePath?: string[];
        state?: 'beta' | 'deprecated' | string;
        strict?: boolean;
        summary?: string;
        type?: string;
        usage?: string | string[];
    };
    type Flag = IFlag<any>;
    namespace Flag {
        type Cached = Omit<Flag, 'input' | 'parse'> & (BooleanFlagProps | OptionFlagProps) & {
            hasDynamicHelp?: boolean;
        };
        type Any = Cached | Flag;
    }
    type Arg = IArg<any>;
    namespace Arg {
        type Cached = Omit<Arg, 'input' | 'parse'> & ArgProps;
        type Any = Arg | Cached;
    }
    type Example = {
        command: string;
        description: string;
    } | string;
}