burgee/commander/v14

import { Command, program, createCommand, … } from 'burgee/commander/v14';

function humanReadableArgName(arg: Argument): string;

function useColor(): boolean | undefined;

class Argument {
    description: string;
    variadic: boolean;
    parseArg: ParseArg | undefined;
    defaultValue: unknown;
    defaultValueDescription: string | undefined;
    argChoices: string[] | undefined;
    required: boolean;
    _name: string;
    /** `<required>`, `[optional]`, bare = required; a trailing `...` makes it variadic. */
    constructor(name: string, description?: string);
    name(): string;
    _collectValue(value: unknown, previous: unknown): unknown[];
    default(value: unknown, description?: string): this;
    argParser(fn?: ParseArg): this;
    choices(values: readonly string[]): this;
    argRequired(): this;
    argOptional(): this;
}

class Command extends Current {
    createCommand(name?: string): Command;
    _excessArguments(args: string[]): void;
}

class CommanderError extends Error {
    code: string;
    exitCode: number;
    nestedError: unknown;
    constructor(exitCode: number, code: string, message?: string);
}

class DualOptions {
    positiveOptions: Map<string, Option>;
    negativeOptions: Map<string, Option>;
    dualOptions: Set<string>;
    constructor(options: Option[]);
    valueFromOption(value: unknown, option: Option): boolean;
}

class Help {
    helpWidth: number | undefined;
    minWidthToWrap: number;
    sortSubcommands: boolean;
    sortOptions: boolean;
    showGlobalOptions: boolean;
    /** Called after `configureHelp` overrides are applied and just before `formatHelp`. */
    prepareContext(contextOptions: HelpContext): void;
    visibleCommands(cmd: Command): Command[];
    compareOptions(a: Option, b: Option): number;
    visibleOptions(cmd: Command): Option[];
    visibleGlobalOptions(cmd: Command): Option[];
    visibleArguments(cmd: Command): Argument[];
    subcommandTerm(cmd: Command): string;
    optionTerm(option: Option): string;
    argumentTerm(argument: Argument): string;
    longestSubcommandTermLength(cmd: Command, helper: Help): number;
    longestOptionTermLength(cmd: Command, helper: Help): number;
    longestGlobalOptionTermLength(cmd: Command, helper: Help): number;
    longestArgumentTermLength(cmd: Command, helper: Help): number;
    commandUsage(cmd: Command): string;
    commandDescription(cmd: Command): string;
    /** Summary, falling back to description for backwards compatibility. */
    subcommandDescription(cmd: Command): string;
    optionDescription(option: Option): string;
    argumentDescription(argument: Argument): string;
    formatItemList(heading: string, items: string[], helper: Help): string[];
    /** Groups in order of first appearance among all items; members in order of the visible items. */
    groupItems<T>(unsortedItems: T[], visibleItems: T[], getGroup: (item: T) => string): Map<string, T[]>;
    formatHelp(cmd: Command, helper: Help): string;
    /** Width ignoring ANSI escapes, for padding and wrapping. */
    displayWidth(str: string): number;
    styleTitle(str: string): string;
    styleUsage(str: string): string;
    styleCommandDescription(str: string): string;
    styleOptionDescription(str: string): string;
    styleSubcommandDescription(str: string): string;
    styleArgumentDescription(str: string): string;
    styleDescriptionText(str: string): string;
    styleOptionTerm(str: string): string;
    styleSubcommandTerm(str: string): string;
    styleArgumentTerm(str: string): string;
    styleOptionText(str: string): string;
    styleArgumentText(str: string): string;
    styleSubcommandText(str: string): string;
    styleCommandText(str: string): string;
    padWidth(cmd: Command, helper: Help): number;
    /** Manually wrapped text: a line break followed by whitespace. */
    preformatted(str: string): boolean;
    /**
     * Pad the term and wrap the description, indenting the following lines:
     *   TTT  DDD DDDD
     *        DD DDD
     */
    formatItem(term: string, termWidth: number, description: string, helper: Help): string;
    /** Wrap at whitespace, preserving existing line breaks; skipped below `minWidthToWrap`. */
    boxWrap(str: string, width: number): string;
}

class InvalidArgumentError extends CommanderError {
    constructor(message?: string);
}

class InvalidArgumentError extends CommanderError {
    constructor(message?: string);
}

class Option {
    flags: string;
    description: string;
    required: boolean;
    optional: boolean;
    variadic: boolean;
    mandatory: boolean;
    short: string | undefined;
    long: string | undefined;
    negate: boolean;
    defaultValue: unknown;
    defaultValueDescription: string | undefined;
    presetArg: unknown;
    envVar: string | undefined;
    parseArg: ParseArg | undefined;
    hidden: boolean;
    argChoices: string[] | undefined;
    conflictsWith: string[];
    implied: Record<string, unknown> | undefined;
    helpGroupHeading: string | undefined;
    constructor(flags: string, description?: string);
    default(value: unknown, description?: string): this;
    /** Value used when the option appears without an option-argument. `parseArg` still runs. */
    preset(arg: unknown): this;
    conflicts(names: string | string[]): this;
    /** Values implied for other options when this one is set and they are not. `parseArg` does not run on them. */
    implies(impliedOptionValues: string | Record<string, unknown>): this;
    env(name: string): this;
    argParser(fn?: ParseArg): this;
    makeOptionMandatory(mandatory?: boolean): this;
    hideHelp(hide?: boolean): this;
    _collectValue(value: unknown, previous: unknown): unknown[];
    choices(values: readonly string[]): this;
    name(): string;
    /** camelCase key used on the options object; `--no-foo` shares `foo` with `--foo`. */
    attributeName(): string;
    helpGroup(heading: string): this;
    is(arg: string): boolean;
    /** Options are one of boolean, negated, required-argument or optional-argument. */
    isBoolean(): boolean;
}

const createArgument: (name: string, description?: string) => Argument;

const createCommand: (name?: string) => Command;

const createOption: (flags: string, description?: string) => Option;

const program: Command;

interface BurgeeParseOptions extends ParseOptions {
    stdout?: Writer;
    stderr?: Writer;
    exit?: (code: number) => void;
}

interface CommandOptions {
    hidden?: boolean;
    isDefault?: boolean;
    /** @deprecated since v7, replaced by hidden */
    noHelp?: boolean;
}

interface ErrorOptions {
    code?: string;
    exitCode?: number;
}

interface ExecutableCommandOptions extends CommandOptions {
    executableFile?: string;
}

interface HelpContext {
    error?: boolean;
    helpWidth?: number;
    outputHasColors?: boolean;
}

interface OutputContext {
    error?: boolean;
}

interface ParseOptions {
    from?: 'node' | 'electron' | 'user' | 'eval';
}

interface ParseOptionsResult {
    operands: string[];
    unknown: string[];
}

type AddHelpTextContext = {
    error: boolean;
    command: Command;
};

type AddHelpTextPosition = 'beforeAll' | 'before' | 'after' | 'afterAll';

type HelpConfiguration = Partial<Help>;

type HookEvent = 'preSubcommand' | 'preAction' | 'postAction';

type HookListener = (thisCommand: Command, actionCommand: Command) => void | Promise<void>;

type OptionValues = Record<string, any>;

type OptionValueSource = 'default' | 'config' | 'env' | 'cli' | 'implied' | (string & Record<never, never>) | undefined;

type OutputConfiguration = Partial<ResolvedOutputConfiguration>;