@visulima/cerebro/dist/index.d.ts

A delightful toolkit for building Node-powered CLIs.

import { OptionDefinition as OptionDefinition$1 } from 'command-line-args';
import { TableConstructorOptions } from 'cli-table3';
import { Pail, ConstructorOptions } from '@visulima/pail/server';

type UpdateNotifierOptions = {
    alwaysRun?: boolean;
    debug?: boolean;
    distTag?: string;
    pkg: {
        name: string;
        version: string;
    };
    registryUrl?: string;
    shouldNotifyInNpmScript?: boolean;
    updateCheckInterval?: number;
};

interface Content {
    content?: string[] | string[][] | string | {
        data: string[];
        options: TableConstructorOptions;
    };
    header?: string;
    raw?: boolean;
}

type Options = Record<string, any>;

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

type TypeConstructor<T> = (value: any) => T extends (infer R)[] ? R | undefined : T | undefined;
type MultiplePropertyOptions<T> = any[] extends T ? {
    lazyMultiple: true;
} | {
    multiple: true;
} : unknown;
type OptionDefinition<T> = MultiplePropertyOptions<T> & Omit<OptionDefinition$1, "type|defaultValue"> & {
    conflicts?: string[] | string;
    defaultValue?: T | undefined;
    description?: string | undefined;
    hidden?: boolean;
    implies?: Record<string, any>;
    required?: boolean;
    type?: TypeConstructor<T> | undefined;
    typeLabel?: string | undefined;
};
type ArgumentDefinition<T = any> = Omit<OptionDefinition<T>, "multiple|lazyMultiple|defaultOption|alias|group|defaultValue">;
interface Command<O extends OptionDefinition<any> = any, TContext extends Toolbox = Toolbox> {
    alias?: string[] | string;
    argument?: ArgumentDefinition;
    commandPath?: string[];
    description?: string;
    examples?: string[] | string[][];
    execute: ((toolbox: TContext) => Promise<void>) | ((toolbox: TContext) => void);
    file?: string;
    group?: string;
    hidden?: boolean;
    name: string;
    options?: (O | OptionDefinition<boolean[]> | OptionDefinition<boolean> | OptionDefinition<number[]> | OptionDefinition<number> | OptionDefinition<string[]> | OptionDefinition<string>)[];
    usage?: Content[];
}

type ExtensionSetup = (toolbox: Toolbox) => Promise<void> | void;
interface Extension {
    description?: string;
    execute: ExtensionSetup;
    file?: string;
    name: string;
}

type CommandSection = {
    footer?: string;
    header?: string;
};
type CliRunOptions = {
    [key: string]: any;
    shouldExitProcess?: boolean;
};
interface Cli$1 {
    addCommand: <OD extends OptionDefinition<any> = any>(command: Command<OD>) => this;
    addExtension: (extension: Extension) => this;
    enableUpdateNotifier: ({ alwaysRun, distTag, updateCheckInterval }: Partial<Omit<UpdateNotifierOptions, "debug | pkg">>) => this;
    getCliName: () => string;
    getCommandSection: () => CommandSection;
    getCommands: () => Map<string, Command>;
    getCwd: () => string;
    getPackageName: () => string | undefined;
    getPackageVersion: () => string | undefined;
    run: (extraOptions: CliRunOptions) => Promise<void>;
    setCommandSection: (commandSection: CommandSection) => this;
    setDefaultCommand: (commandName: string) => this;
}

declare global {
    namespace Cerebro {
        interface ExtensionOverrides {
        }
    }
}

type CliOptions = {
    argv?: string[];
    cwd?: string;
    logger?: ConstructorOptions<string, string>;
    packageName?: string;
    packageVersion?: string;
};
declare class Cli implements Cli$1 {
    private readonly logger;
    private readonly argv;
    private readonly cwd;
    private readonly cliName;
    private readonly packageVersion;
    private readonly packageName;
    private readonly extensions;
    private readonly commands;
    private defaultCommand;
    private updateNotifierOptions;
    private commandSection;
    constructor(cliName: string, options?: CliOptions);
    setCommandSection(commandSection: CommandSection): this;
    getCommandSection(): CommandSection;
    setDefaultCommand(commandName: string): this;
    addCommand<OD extends OptionDefinition<any> = any>(command: Command<OD>): this;
    addExtension(extension: Extension): this;
    enableUpdateNotifier(options?: Partial<Omit<UpdateNotifierOptions, "debug | pkg">>): this;
    getCliName(): string;
    getPackageVersion(): string | undefined;
    getPackageName(): string | undefined;
    getCommands(): Map<string, Command>;
    getCwd(): string;
    run(extraOptions?: CliRunOptions): Promise<void>;
    private validateDoubleOptions;
    private addCoreExtensions;
    private prepareToolboxResult;
    private updateNotifier;
    private validateCommandOptions;
    private validateCommandArgsForConflicts;
    private addNegatableOption;
    private registerExtensions;
    private mapNegatableOptions;
    private mapImpliesOptions;
}

type OutputType = 1 | 2 | 4;
type VERBOSITY_LEVEL = 16 | 32 | 64 | 128 | 256;

export { type ArgumentDefinition, type Cli$1 as Cli, type CliOptions, type Command, type Extension, type OptionDefinition, type OutputType, type Toolbox, type VERBOSITY_LEVEL,  };

export = Cli;