interface Cli {
    addCommand(command: Command): this;
    addPlugin(plugin: Plugin): this;
    run(options?: CliRunOptions): Promise<void>;
    runCommand(commandName: string, options?: RunCommandOptions): Promise<unknown>;
    setDefaultCommand(commandName: string): this;
    setCommandSection(section: CommandSection): this;
    getCliName(): string;
    getCommands(): Map<string, Command>;
    getCwd(): string;
    getPackageName(): string | undefined;
    getPackageVersion(): string | undefined;
    getPluginManager(): PluginManager;
    dispose(): void;
}

interface Command<O extends OptionDefinition = OptionDefinition, TContext extends Toolbox = Toolbox> {
    name: string;
    execute: (toolbox: TContext) => Promise<void> | void;
    description?: string;
    alias?: string | string[];
    argument?: ArgumentDefinition;
    options?: OptionDefinition[];
    hidden?: boolean;
    group?: string;
    examples?: string[] | string[][];
    usage?: Content[];
    file?: string;
    commandPath?: string[];
}

interface Plugin {
    name: string;
    description?: string;
    version?: string;
    dependencies?: string[];
    init?: (context: PluginContext) => Promise<void> | void;
    execute?: (toolbox: Toolbox) => Promise<void> | void;
    beforeCommand?: (toolbox: Toolbox) => Promise<void> | void;
    afterCommand?: (toolbox: Toolbox, result: unknown) => Promise<void> | void;
    onError?: (error: Error, toolbox: Toolbox) => Promise<void> | void;
}

interface Toolbox<T extends Console = Console> extends Cerebro.ExtensionOverrides {
    argument: string[];
    argv: Record<string, any>;
    command: Command;
    commandName: string;
    logger: T;
    options: Options;
    runtime: Cli;
}

interface OptionDefinition<T> {
    name: string;
    alias?: string | string[];
    type?: TypeConstructor<T>;
    description?: string;
    defaultValue?: T;
    required?: boolean;
    multiple?: boolean;
    lazyMultiple?: boolean;
    conflicts?: string | string[];
    implies?: Record<string, any>;
    hidden?: boolean;
    typeLabel?: string;
    group?: string;
}

interface ArgumentDefinition<T = any> {
    name: string;
    type?: TypeConstructor<T>;
    description?: string;
    defaultValue?: T;
    typeLabel?: string;
}

interface CliOptions<T extends Console = Console> {
    argv?: ReadonlyArray<string>;
    cwd?: string;
    logger?: T;
    packageName?: string;
    packageVersion?: string;
}

interface CliRunOptions {
    shouldExitProcess?: boolean;
    autoDispose?: boolean;
    [key: string]: any;
}

interface RunCommandOptions {
    argv?: string[];
    [key: string]: any;
}

interface CommandSection {
    header?: string;
    footer?: string;
}

type VERBOSITY_LEVEL = 16 | 32 | 64 | 128 | 256;

const VERBOSITY_QUIET = 16;
const VERBOSITY_NORMAL = 32;
const VERBOSITY_VERBOSE = 64;
const VERBOSITY_DEBUG = 128;

declare global {
    namespace Cerebro {
        interface ExtensionOverrides {
            myFeature: () => void;
            api: {
                get: (url: string) => Promise<unknown>;
            };
        }
    }
}

import type {
    Cli,
    CliOptions,
    CliRunOptions,
    RunCommandOptions,
    Command,
    OptionDefinition,
    ArgumentDefinition,
    Plugin,
    PluginContext,
    Toolbox,
    VERBOSITY_LEVEL,
} from "@visulima/cerebro";