@oclif/command

constructor(argv: string[], config: Config.IConfig);

static aliases: string[];

static args?: Parser.args.Input;

argv: string[];

config: Config.IConfig;

readonly ctor: typeof Command;

protected debug: (...args: any[]) => void;

static description: string;

static examples: string[];

static flags?: flags.Input<any>;

static help: string;

static hidden: boolean;

static id: string;

id: string;

static parse: boolean;

static parserOptions: {};

static plugin: any;

static run: Config.Command.Class;

static strict: boolean;

static title: string;

static usage: string | string[];

protected catch: (err: any) => Promise<any>;

error: {
    (
        input: string | Error,
        options: { code?: string; exit: false } & PrettyPrintableError
    ): void;
    (input: string | Error, options?: any): never;
};

exit: (code?: number) => never;

protected finally: (_: Error | undefined) => Promise<any>;

protected init: () => Promise<any>;

log: (message?: string, ...args: any[]) => void;

protected parse: <F, A extends { [name: string]: any }>(
    options?: Parser.Input<F>,
    argv?: string[]
) => Parser.Output<F, A>;

abstract run: () => PromiseLike<any>;

warn: (input: string | Error) => void;

init: () => Promise<any>;

static run: (argv?: string[], options?: Config.LoadOptions) => PromiseLike<any>;

const string: Definition<string>;

build: {
    <T>(
        defaults: { parse: IOptionFlag<T>['parse'] } & Partial<IOptionFlag<T>>
    ): Definition<T>;
    (defaults: Partial<any>): Definition<string>;
};

enum: <T = string>(opts: Parser.flags.EnumFlagOptions<T>) => any

help: (
    opts?: Parser.flags.IBooleanFlag<boolean>
) => Parser.flags.IBooleanFlag<void>;

option: <T>(
    options: { parse: IOptionFlag<T>['parse'] } & Partial<IOptionFlag<T>>
) => IOptionFlag<T | undefined>;

version: (
    opts?: Parser.flags.IBooleanFlag<boolean>
) => Parser.flags.IBooleanFlag<void>;

type Definition<T> = {
    (
        options: {
            multiple: true;
        } & Partial<IOptionFlag<T[]>>
    ): IOptionFlag<T[]>;
    (
        options: (
            | {
                  required: true;
              }
            | {
                  default: Parser.flags.Default<T>;
              }
        ) &
            Partial<IOptionFlag<T>>
    ): IOptionFlag<T>;
    (options?: Partial<IOptionFlag<T>>): IOptionFlag<T | undefined>;
};

type ICompletion = {
    skipCache?: boolean;
    cacheDuration?: number;
    cacheKey?(ctx: ICompletionContext): Promise<string>;
    options(ctx: ICompletionContext): Promise<string[]>;
};

type ICompletionContext = {
    args?: {
        [name: string]: string;
    };
    flags?: {
        [name: string]: string;
    };
    argv?: string[];
    config: IConfig;
};

type IFlag<T> = Parser.flags.IBooleanFlag<T> | IOptionFlag<T>;

type Input<T extends Output> = {
    [P in keyof T]: IFlag<T[P]>;
};

type IOptionFlag<T> = Parser.flags.IOptionFlag<T> & {
    completion?: ICompletion;
};

type Output = Parser.flags.Output;