@bemoje/cli 2.1.5 → 3.0.0

package/index.d.ts

@@ -2,13 +2,13 @@ import { Simplify, SetFieldType, SetRequired, AllUnionFields, CamelCase } from '
 
 /** Logger interface defining methods for different log levels. */
 interface Logger {
-  start: (...args: unknown[]) => void;
-  done: (...args: unknown[]) => void;
-  info: (...args: unknown[]) => void;
-  log: (...args: unknown[]) => void;
-  warn: (...args: unknown[]) => void;
-  error: (...args: unknown[]) => void;
-  debug: (...args: unknown[]) => void;
+    start: (...args: unknown[]) => void;
+    done: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    log: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
 }
 /** Parsed command-line arguments */
 type Arguments = (undefined | string | string[])[];
@@ -16,318 +16,296 @@ type Arguments = (undefined | string | string[])[];
 type Options = Record<string, undefined | boolean | string | string[]>;
 /** Result of parsing command-line input, including arguments, options, triggered actions, and execution method */
 type SubCommands = {
-  [name: string]: Command<Arguments, Options, any>;
+    [name: string]: Command<Arguments, Options, any>;
 };
 /** Base descriptor for command-line arguments with shared properties */
 interface Argument {
-  usage: string;
-  name: string;
-  description?: string;
-  required?: boolean;
-  variadic?: boolean;
-  choices?: string[];
-  defaultValue?: string | string[];
-  defaultValueDescription?: string;
+    usage: string;
+    name: string;
+    description?: string;
+    required?: boolean;
+    variadic?: boolean;
+    choices?: string[];
+    defaultValue?: string | string[];
+    defaultValueDescription?: string;
 }
 /** Base descriptor for command-line options with shared properties */
 interface Option {
-  type: 'boolean' | 'string';
-  flags: string;
-  short: string;
-  long: string;
-  name: string;
-  argName?: string;
-  description?: string;
-  required?: boolean;
-  variadic?: boolean;
-  negate?: boolean;
-  defaultValue?: boolean | string | string[];
-  defaultValueDescription?: string;
-  env?: string;
-  hidden?: boolean;
-  choices?: string[];
-  group?: string;
+    type: 'boolean' | 'string';
+    flags: string;
+    short: string;
+    long: string;
+    name: string;
+    argName?: string;
+    description?: string;
+    required?: boolean;
+    variadic?: boolean;
+    negate?: boolean;
+    defaultValue?: boolean | string | string[];
+    defaultValueDescription?: string;
+    env?: string;
+    hidden?: boolean;
+    choices?: string[];
+    group?: string;
 }
 /** Complete command configuration including all properties and substructures */
 interface ICommand {
-  /** Parent command if this is a subcommand */
-  readonly parent?: ICommand;
-  /** Help configuration and rendering */
-  /** Command name used for invocation */
-  name: string;
-  /** Alternative names for this command */
-  aliases: string[];
-  /** Optional version string */
-  version?: string;
-  /** Full command description */
-  description: string;
-  /** Brief single-line description */
-  summary?: string;
-  /** Whether command should be hidden from help */
-  hidden?: boolean;
-  /** Group name for organizing commands in help */
-  group?: string;
-  /** Positional arguments */
-  arguments: Argument[];
-  /** Named options/flags */
-  options: Option[];
-  /** Child subcommands */
-  commands: {
-    [name: string]: ICommand;
-  };
+    /** Parent command if this is a subcommand */
+    readonly parent?: ICommand;
+    /** Help configuration and rendering */
+    /** Command name used for invocation */
+    name: string;
+    /** Alternative names for this command */
+    aliases: string[];
+    /** Optional version string */
+    version?: string;
+    /** Full command description */
+    description: string;
+    /** Brief single-line description */
+    summary?: string;
+    /** Whether command should be hidden from help */
+    hidden?: boolean;
+    /** Group name for organizing commands in help */
+    group?: string;
+    /** Positional arguments */
+    arguments: Argument[];
+    /** Named options/flags */
+    options: Option[];
+    /** Child subcommands */
+    commands: {
+        [name: string]: ICommand;
+    };
 }
 interface IHelp {
-  /** output helpWidth, long lines are wrapped to fit */
-  helpWidth: number;
-  minWidthToWrap: number;
-  sortSubcommands: boolean;
-  sortOptions: boolean;
-  usageDisplayOptionsAs: string;
-  usageDisplaySubcommandAs: string;
-  /**
-   * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
-   */
-  visibleCommands(): ICommand[];
-  /**
-   * Compare options for sort.
-   */
-  compareOptions(a: Option, b: Option): number;
-  /**
-   * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
-   */
-  visibleOptions(): Option[];
-  /**
-   * Get an array of the arguments if any have a description.
-   */
-  visibleArguments(): Argument[];
-  /**
-   * Get the command term to show in the list of subcommands.
-   */
-  subcommandTerm(sub: ICommand): string;
-  /**
-   * Get the option term to show in the list of options.
-   */
-  optionTerm(option: Option): string;
-  /**
-   * Get the argument term to show in the list of arguments.
-   */
-  argumentTerm(argument: Argument): string;
-  /**
-   * Get the longest subcommand primary alias length.
-   */
-  longestSubcommandAliasLength(): number;
-  /**
-   * Get the longest subcommand term length.
-   */
-  longestSubcommandTermLength(): number;
-  /**
-   * Get the longest option term length.
-   */
-  longestOptionTermLength(): number;
-  /**
-   * Get the longest argument term length.
-   */
-  longestArgumentTermLength(): number;
-  /**
-   * Get the command usage to be displayed at the top of the built-in help.
-   */
-  commandUsage(): string;
-  /**
-   * Get the description for the command.
-   */
-  commandDescription(): string;
-  /**
-   * Get the subcommand summary to show in the list of subcommands.
-   * (Fallback to description for backwards compatibility.)
-   */
-  subcommandDescription(sub: ICommand): string;
-  /**
-   * Get the option description to show in the list of options.
-   */
-  optionDescription(option: Option): string;
-  /**
-   * Get the argument description to show in the list of arguments.
-   */
-  argumentDescription(argument: Argument): string;
-  /**
-   * Format a list of items, given a heading and an array of formatted items.
-   */
-  formatItemList(heading: string, items: string[]): string[];
-  /**
-   * Group items by their help group heading.
-   */
-  groupItems<T extends ICommand | Option>(
-    unsortedItems: T[],
-    visibleItems: T[],
-    getGroup: (item: T) => string,
-  ): Map<string, T[]>;
-  /**
-   * Return display width of string, ignoring ANSI escape sequences. Used in padding and wrapping calculations.
-   */
-  displayWidth(str: string): number;
-  /**
-   * Style the title for displaying in the help. Called with 'Usage:', 'Options:', etc.
-   */
-  styleTitle(str: string): string;
-  /**
-   * Style the usage line for displaying in the help. Applies specific styling to different parts like options, commands, and arguments.
-   */
-  styleUsage(str: string): string;
-  /**
-   * Style command descriptions for display in help output.
-   */
-  styleCommandDescription(str: string): string;
-  /**
-   * Style option descriptions for display in help output.
-   */
-  styleOptionDescription(str: string): string;
-  /**
-   * Style subcommand descriptions for display in help output.
-   */
-  styleSubcommandDescription(str: string): string;
-  /**
-   * Style argument descriptions for display in help output.
-   */
-  styleArgumentDescription(str: string): string;
-  /**
-   * Base style used by descriptions. Override in subclass to apply custom formatting.
-   */
-  styleDescriptionText(str: string): string;
-  /**
-   * Style option terms (flags) for display in help output.
-   */
-  styleOptionTerm(str: string): string;
-  /**
-   * Style subcommand terms for display in help output. Applies specific styling to different parts like options and arguments.
-   */
-  styleSubcommandTerm(str: string): string;
-  /**
-   * Style argument terms for display in help output.
-   */
-  styleArgumentTerm(str: string): string;
-  /**
-   * Base style used in terms and usage for options. Override in subclass to apply custom formatting.
-   */
-  styleOptionText(str: string): string;
-  /**
-   * Base style used in terms and usage for arguments. Override in subclass to apply custom formatting.
-   */
-  styleArgumentText(str: string): string;
-  /**
-   * Base style used in terms and usage for subcommands. Override in subclass to apply custom formatting.
-   */
-  styleSubcommandText(str: string): string;
-  /**
-   * Base style used in terms and usage for commands. Override in subclass to apply custom formatting.
-   */
-  styleCommandText(str: string): string;
-  /**
-   * Calculate the pad width from the maximum term length.
-   */
-  padWidth(): number;
-  /**
-   * Detect manually wrapped and indented strings by checking for line break followed by whitespace.
-   */
-  preformatted(str: string): boolean;
-  /**
-   * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines.
-   *
-   * So "TTT", 5, "DDD DDDD DD DDD" might be formatted for this.helpWidth=17 like so:
-   *   TTT  DDD DDDD
-   *        DD DDD
-   */
-  formatItem(term: string, termWidth: number, description: string): string;
-  /**
-   * Wrap a string at whitespace, preserving existing line breaks.
-   * Wrapping is skipped if the width is less than `minWidthToWrap`.
-   */
-  boxWrap(str: string, width: number): string;
-  /**
-   * Generate the built-in help text.
-   */
-  render(): string;
+    /** output helpWidth, long lines are wrapped to fit */
+    helpWidth: number;
+    minWidthToWrap: number;
+    sortSubcommands: boolean;
+    sortOptions: boolean;
+    usageDisplayOptionsAs: string;
+    usageDisplaySubcommandAs: string;
+    /**
+     * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
+     */
+    visibleCommands(): ICommand[];
+    /**
+     * Compare options for sort.
+     */
+    compareOptions(a: Option, b: Option): number;
+    /**
+     * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
+     */
+    visibleOptions(): Option[];
+    /**
+     * Get an array of the arguments if any have a description.
+     */
+    visibleArguments(): Argument[];
+    /**
+     * Get the command term to show in the list of subcommands.
+     */
+    subcommandTerm(sub: ICommand): string;
+    /**
+     * Get the option term to show in the list of options.
+     */
+    optionTerm(option: Option): string;
+    /**
+     * Get the argument term to show in the list of arguments.
+     */
+    argumentTerm(argument: Argument): string;
+    /**
+     * Get the longest subcommand primary alias length.
+     */
+    longestSubcommandAliasLength(): number;
+    /**
+     * Get the longest subcommand term length.
+     */
+    longestSubcommandTermLength(): number;
+    /**
+     * Get the longest option term length.
+     */
+    longestOptionTermLength(): number;
+    /**
+     * Get the longest argument term length.
+     */
+    longestArgumentTermLength(): number;
+    /**
+     * Get the command usage to be displayed at the top of the built-in help.
+     */
+    commandUsage(): string;
+    /**
+     * Get the description for the command.
+     */
+    commandDescription(): string;
+    /**
+     * Get the subcommand summary to show in the list of subcommands.
+     * (Fallback to description for backwards compatibility.)
+     */
+    subcommandDescription(sub: ICommand): string;
+    /**
+     * Get the option description to show in the list of options.
+     */
+    optionDescription(option: Option): string;
+    /**
+     * Get the argument description to show in the list of arguments.
+     */
+    argumentDescription(argument: Argument): string;
+    /**
+     * Format a list of items, given a heading and an array of formatted items.
+     */
+    formatItemList(heading: string, items: string[]): string[];
+    /**
+     * Group items by their help group heading.
+     */
+    groupItems<T extends ICommand | Option>(unsortedItems: T[], visibleItems: T[], getGroup: (item: T) => string): Map<string, T[]>;
+    /**
+     * Return display width of string, ignoring ANSI escape sequences. Used in padding and wrapping calculations.
+     */
+    displayWidth(str: string): number;
+    /**
+     * Style the title for displaying in the help. Called with 'Usage:', 'Options:', etc.
+     */
+    styleTitle(str: string): string;
+    /**
+     * Style the usage line for displaying in the help. Applies specific styling to different parts like options, commands, and arguments.
+     */
+    styleUsage(str: string): string;
+    /**
+     * Style command descriptions for display in help output.
+     */
+    styleCommandDescription(str: string): string;
+    /**
+     * Style option descriptions for display in help output.
+     */
+    styleOptionDescription(str: string): string;
+    /**
+     * Style subcommand descriptions for display in help output.
+     */
+    styleSubcommandDescription(str: string): string;
+    /**
+     * Style argument descriptions for display in help output.
+     */
+    styleArgumentDescription(str: string): string;
+    /**
+     * Base style used by descriptions. Override in subclass to apply custom formatting.
+     */
+    styleDescriptionText(str: string): string;
+    /**
+     * Style option terms (flags) for display in help output.
+     */
+    styleOptionTerm(str: string): string;
+    /**
+     * Style subcommand terms for display in help output. Applies specific styling to different parts like options and arguments.
+     */
+    styleSubcommandTerm(str: string): string;
+    /**
+     * Style argument terms for display in help output.
+     */
+    styleArgumentTerm(str: string): string;
+    /**
+     * Base style used in terms and usage for options. Override in subclass to apply custom formatting.
+     */
+    styleOptionText(str: string): string;
+    /**
+     * Base style used in terms and usage for arguments. Override in subclass to apply custom formatting.
+     */
+    styleArgumentText(str: string): string;
+    /**
+     * Base style used in terms and usage for subcommands. Override in subclass to apply custom formatting.
+     */
+    styleSubcommandText(str: string): string;
+    /**
+     * Base style used in terms and usage for commands. Override in subclass to apply custom formatting.
+     */
+    styleCommandText(str: string): string;
+    /**
+     * Calculate the pad width from the maximum term length.
+     */
+    padWidth(): number;
+    /**
+     * Detect manually wrapped and indented strings by checking for line break followed by whitespace.
+     */
+    preformatted(str: string): boolean;
+    /**
+     * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines.
+     *
+     * So "TTT", 5, "DDD DDDD DD DDD" might be formatted for this.helpWidth=17 like so:
+     *   TTT  DDD DDDD
+     *        DD DDD
+     */
+    formatItem(term: string, termWidth: number, description: string): string;
+    /**
+     * Wrap a string at whitespace, preserving existing line breaks.
+     * Wrapping is skipped if the width is less than `minWidthToWrap`.
+     */
+    boxWrap(str: string, width: number): string;
+    /**
+     * Generate the built-in help text.
+     */
+    render(): string;
 }
 /** Action handler function type, which receives parsed arguments and options as well as metadata about the command execution context. */
-type ActionHandler<A extends Arguments, O extends Options, Subs extends SubCommands> = (
-  ...args: [
+type ActionHandler<A extends Arguments, O extends Options, Subs extends SubCommands> = (...args: [
     ...A,
     O,
     {
-      path: string[];
-      name: string;
-      argv: string[];
-      args: A;
-      opts: O;
-      errors?: string[];
-      cmd: Command<A, O, Subs>;
-      logger: Logger;
-    },
-  ]
-) => Promise<void> | void;
+        path: string[];
+        name: string;
+        argv: string[];
+        args: A;
+        opts: O;
+        errors?: string[];
+        cmd: Command<A, O, Subs>;
+        logger: Logger;
+    }
+]) => Promise<void> | void;
 /** Predicate function type for hooks, which receives the same metadata as action handlers and returns a boolean indicating whether the hook's action should be executed. */
-type HookPredicate<
-  A extends Arguments = Arguments,
-  O extends Options = Options,
-  Subs extends SubCommands = SubCommands,
-> = (data: {
-  path: string[];
-  name: string;
-  argv: string[];
-  args: A;
-  opts: O;
-  errors?: string[];
-  cmd: Command<A, O, Subs>;
+type HookPredicate<A extends Arguments = Arguments, O extends Options = Options, Subs extends SubCommands = SubCommands> = (data: {
+    path: string[];
+    name: string;
+    argv: string[];
+    args: A;
+    opts: O;
+    errors?: string[];
+    cmd: Command<A, O, Subs>;
 }) => boolean;
 /** Action handler function type for hooks, which receives the same metadata as action handlers and is executed when its predicate returns true. Can also throw to indicate an error. */
-type HookActionHandler<
-  A extends Arguments = Arguments,
-  O extends Options = Options,
-  Subs extends SubCommands = SubCommands,
-> = (data: {
-  path: string[];
-  name: string;
-  argv: string[];
-  args: A;
-  opts: O;
-  errors?: string[];
-  cmd: Command<A, O, Subs>;
+type HookActionHandler<A extends Arguments = Arguments, O extends Options = Options, Subs extends SubCommands = SubCommands> = (data: {
+    path: string[];
+    name: string;
+    argv: string[];
+    args: A;
+    opts: O;
+    errors?: string[];
+    cmd: Command<A, O, Subs>;
 }) => Promise<void> | void | never;
 /** Hook definition type, which includes the option name that triggers the hook, a predicate function to determine when the hook should run, and an action handler to execute when triggered. */
-type HookDefinition<
-  A extends Arguments = Arguments,
-  O extends Options = Options,
-  Subs extends SubCommands = SubCommands,
-> = {
-  name: keyof O;
-  predicate: HookPredicate<A, O, Subs>;
-  action: HookActionHandler<A, O, Subs>;
+type HookDefinition<A extends Arguments = Arguments, O extends Options = Options, Subs extends SubCommands = SubCommands> = {
+    name: keyof O;
+    predicate: HookPredicate<A, O, Subs>;
+    action: HookActionHandler<A, O, Subs>;
 };
 /**
  * @see Command.prototype.parseArgv
  */
-type ParseArgvResult<
-  A extends Arguments = Arguments,
-  O extends Options = Options,
-  Subs extends SubCommands = SubCommands,
-> = {
-  /** The command or subcommand instance */
-  get cmd(): Command<A, O, Subs>;
-  /** The part of argv that makes out a subcommand path, or empty array when root command */
-  path: string[];
-  /** Command namer */
-  name: string;
-  /** Original argv array passed in or from process.argv, excluding subcommand path */
-  argv: string[];
-  /** Parsed arguments */
-  args: A;
-  /** Parsed options */
-  opts: O;
-  /** Error messages if parsing failed, otherwise undefined */
-  errors?: string[];
-  /** Names of all triggered hooks whose predicate returned true */
-  hooks: HookDefinition<A, O, Subs>[];
-  /** Calls the action handler with its expected args */
-  execute: () => Promise<void>;
+type ParseArgvResult<A extends Arguments = Arguments, O extends Options = Options, Subs extends SubCommands = SubCommands> = {
+    /** The command or subcommand instance */
+    get cmd(): Command<A, O, Subs>;
+    /** The part of argv that makes out a subcommand path, or empty array when root command */
+    path: string[];
+    /** Command namer */
+    name: string;
+    /** Original argv array passed in or from process.argv, excluding subcommand path */
+    argv: string[];
+    /** Parsed arguments */
+    args: A;
+    /** Parsed options */
+    opts: O;
+    /** Error messages if parsing failed, otherwise undefined */
+    errors?: string[];
+    /** Names of all triggered hooks whose predicate returned true */
+    hooks: HookDefinition<A, O, Subs>[];
+    /** Calls the action handler with its expected args */
+    execute: () => Promise<void>;
 };
 /** required variadic argument */
 type RequiredVariadicArgumentUsage = `<${string}...>`;
@@ -338,116 +316,70 @@ type RequiredArgumentUsage = `<${string}>`;
 /** optional argument */
 type OptionalArgumentUsage = `[${string}]`;
 /** Union of all argument usage pattern types */
-type ArgumentUsage =
-  | RequiredVariadicArgumentUsage
-  | OptionalVariadicArgumentUsage
-  | RequiredArgumentUsage
-  | OptionalArgumentUsage;
+type ArgumentUsage = RequiredVariadicArgumentUsage | OptionalVariadicArgumentUsage | RequiredArgumentUsage | OptionalArgumentUsage;
 /** Helper type to infer allowed argument usage patterns based on the command's existing argument types */
-type InferArgumentUsage<T extends Command<any, any, any>> =
-  T extends Command<infer A, any>
-    ? A extends string[]
-      ? ArgumentUsage
-      : A extends (string | (string | undefined))[]
-        ? OptionalArgumentUsage | OptionalVariadicArgumentUsage
-        : never
-    : never;
+type InferArgumentUsage<T extends Command<any, any, any>> = T extends Command<infer A, any> ? A extends string[] ? ArgumentUsage : A extends (string | (string | undefined))[] ? OptionalArgumentUsage | OptionalVariadicArgumentUsage : never : never;
 /** Helper type to infer allowed argument usage patterns based on the command's existing argument types */
-type AllowedArgumentUsage<T extends Command<any, any, any>, Usage extends ArgumentUsage> =
-  Usage extends InferArgumentUsage<T> ? Usage : never;
+type AllowedArgumentUsage<T extends Command<any, any, any>, Usage extends ArgumentUsage> = Usage extends InferArgumentUsage<T> ? Usage : never;
 /** Base type for addArgument options, extended by specific required/optional and variadic/non-variadic argument option types */
-type ArgumentOptionsBase = Omit<
-  Argument,
-  'name' | 'required' | 'variadic' | 'usage' | 'defaultValue' | 'defaultValueDescription'
->;
+type ArgumentOptionsBase = Omit<Argument, 'name' | 'required' | 'variadic' | 'usage' | 'defaultValue' | 'defaultValueDescription'>;
 /** Base type for addArgument options, extended by specific required/optional and variadic/non-variadic argument option types */
 type ExtendArgumentOptionsBase<T extends object = object> = Simplify<ArgumentOptionsBase & T>;
 /** Required positional argument descriptor. Usage: `<name>` */
 type RequiredArgumentOptions = ExtendArgumentOptionsBase;
 /** Optional positional argument with string default. Usage: `[name]` */
 type OptionalArgumentOptions = ExtendArgumentOptionsBase<{
-  defaultValue?: string;
-  defaultValueDescription?: string;
+    defaultValue?: string;
+    defaultValueDescription?: string;
 }>;
 /** Optional positional argument with required string default. Usage: `[name]` */
-type OptionalArgumentOptionsWithDefaultValue = SetFieldType<
-  SetRequired<OptionalArgumentOptions, 'defaultValue'>,
-  'defaultValue',
-  string
->;
+type OptionalArgumentOptionsWithDefaultValue = SetFieldType<SetRequired<OptionalArgumentOptions, 'defaultValue'>, 'defaultValue', string>;
 /** Required variadic argument accepting variadic values. Usage: `<name...>` */
 type RequiredVariadicArgumentOptions = ExtendArgumentOptionsBase;
 /** Optional variadic argument with array default. Usage: `[name...]` */
 type OptionalVariadicArgumentOptions = ExtendArgumentOptionsBase<{
-  defaultValue?: string[];
-  defaultValueDescription?: string;
+    defaultValue?: string[];
+    defaultValueDescription?: string;
 }>;
 /** Union of all addArgument options types */
-type ArgumentOptions = AllUnionFields<
-  | RequiredArgumentOptions
-  | OptionalArgumentOptions
-  | OptionalArgumentOptionsWithDefaultValue
-  | RequiredVariadicArgumentOptions
-  | OptionalVariadicArgumentOptions
->;
+type ArgumentOptions = AllUnionFields<RequiredArgumentOptions | OptionalArgumentOptions | OptionalArgumentOptionsWithDefaultValue | RequiredVariadicArgumentOptions | OptionalVariadicArgumentOptions>;
 /** Helper type for extracting argument name from usage pattern */
 type InferAddedArgumentType<Opts> = Opts extends {
-  choices: infer C extends string[];
-}
-  ? C[number]
-  : string;
+    choices: infer C extends string[];
+} ? C[number] : string;
 /** Union of all option usage pattern types */
-type OptionUsage<Long extends string> =
-  | `-${string}, --${Long}`
-  | `-${string}, --${Long} <${string}>`
-  | `-${string}, --${Long} [${string}]`
-  | `-${string}, --${Long} <${string}...>`
-  | `-${string}, --${Long} [${string}...]`;
+type OptionUsage<Long extends string> = `-${string}, --${Long}` | `-${string}, --${Long} <${string}>` | `-${string}, --${Long} [${string}]` | `-${string}, --${Long} <${string}...>` | `-${string}, --${Long} [${string}...]`;
 /** Base type for addOption options, extended by specific boolean/string and required/optional and variadic/non-variadic option types */
-type OptionOptionsBase = Omit<
-  Option,
-  'name' | 'required' | 'variadic' | 'type' | 'argName' | 'short' | 'long' | 'flags'
->;
+type OptionOptionsBase = Omit<Option, 'name' | 'required' | 'variadic' | 'type' | 'argName' | 'short' | 'long' | 'flags'>;
 /** Helper type to extend base addOption options with specific fields for different option types */
 type ExtendAddOptionOptionsBase<T extends object = object> = Simplify<OptionOptionsBase & T>;
 /** Boolean flag option. Usage: `-v, --verbose` */
 type BooleanOptionOptions = ExtendAddOptionOptionsBase<{
-  defaultValue?: boolean;
-  defaultValueDescription?: string;
+    defaultValue?: boolean;
+    defaultValueDescription?: string;
 }>;
 /** Required string option. Usage: `-f, --file <path>` */
 type RequiredOptionOptions = ExtendAddOptionOptionsBase<{
-  env?: undefined;
+    env?: undefined;
 }>;
 /** Optional string option with default. Usage: `-o, --output [path]` */
 type OptionalOptionOptions = ExtendAddOptionOptionsBase<{
-  defaultValue?: string;
-  defaultValueDescription?: string;
+    defaultValue?: string;
+    defaultValueDescription?: string;
 }>;
 /** Required option accepting variadic values. Usage: `-i, --include <patterns...>` */
 type RequiredVariadicOptionOptions = ExtendAddOptionOptionsBase<{
-  env?: undefined;
+    env?: undefined;
 }>;
 /** Optional option accepting variadic values with defaults. Usage: `-e, --exclude [patterns...]` */
 type OptionalVariadicOptionOptions = ExtendAddOptionOptionsBase<{
-  defaultValue?: string[];
-  defaultValueDescription?: string;
+    defaultValue?: string[];
+    defaultValueDescription?: string;
 }>;
 /** Union of all addOption options types */
-type OptionOptions = AllUnionFields<
-  | BooleanOptionOptions
-  | RequiredOptionOptions
-  | OptionalOptionOptions
-  | RequiredVariadicOptionOptions
-  | OptionalVariadicOptionOptions
->;
+type OptionOptions = AllUnionFields<BooleanOptionOptions | RequiredOptionOptions | OptionalOptionOptions | RequiredVariadicOptionOptions | OptionalVariadicOptionOptions>;
 /** Helper type to infer the resulting Command type after adding an option with specific options */
-type InferAddOptionResult<
-  A extends Arguments,
-  O extends Options,
-  NewOptions extends Options,
-  Subs extends SubCommands,
-> = Command<A, Simplify<O & NewOptions>, Subs>;
+type InferAddOptionResult<A extends Arguments, O extends Options, NewOptions extends Options, Subs extends SubCommands> = Command<A, Simplify<O & NewOptions>, Subs>;
 
 /**
  * This is a fork of the Help class from the 'commander' npm package. The Help class method names as well as the
@@ -455,395 +387,295 @@ type InferAddOptionResult<
  * custom adaptations, @see ICommand
  */
 declare class Help implements IHelp {
-  protected readonly cmd: ICommand;
-  /** output helpWidth, long lines are wrapped to fit */
-  helpWidth: number;
-  minWidthToWrap: number;
-  sortSubcommands: boolean;
-  sortOptions: boolean;
-  usageDisplayOptionsAs: string;
-  usageDisplaySubcommandAs: string;
-  constructor(cmd: ICommand);
-  /**
-   * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
-   */
-  visibleCommands(): ICommand[];
-  /**
-   * Compare options for sort.
-   */
-  compareOptions(a: Option, b: Option): number;
-  /**
-   * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
-   */
-  visibleOptions(): Option[];
-  /**
-   * Get an array of the arguments if any have a description.
-   */
-  visibleArguments(): Argument[];
-  /**
-   * Get the command term to show in the list of subcommands.
-   */
-  subcommandTerm(sub: ICommand): string;
-  /**
-   * Get the option term to show in the list of options.
-   */
-  optionTerm(option: Option): string;
-  /**
-   * Get the argument term to show in the list of arguments.
-   */
-  argumentTerm(argument: Argument): string;
-  /**
-   * Get the longest subcommand primary alias length.
-   */
-  longestSubcommandAliasLength(): number;
-  /**
-   * Get the longest subcommand term length.
-   */
-  longestSubcommandTermLength(): number;
-  /**
-   * Get the longest option term length.
-   */
-  longestOptionTermLength(): number;
-  /**
-   * Get the longest argument term length.
-   */
-  longestArgumentTermLength(): number;
-  /**
-   * Get the command usage to be displayed at the top of the built-in help.
-   */
-  commandUsage(): string;
-  /**
-   * Get the description for the command.
-   */
-  commandDescription(): string;
-  /**
-   * Get the subcommand summary to show in the list of subcommands.
-   * (Fallback to description for backwards compatibility.)
-   */
-  subcommandDescription(sub: ICommand): string;
-  /**
-   * Get the option description to show in the list of options.
-   */
-  optionDescription(option: Option): string;
-  /**
-   * Get the argument description to show in the list of arguments.
-   */
-  argumentDescription(argument: Argument): string;
-  /**
-   * Format a list of items, given a heading and an array of formatted items.
-   */
-  formatItemList(heading: string, items: string[]): string[];
-  /**
-   * Group items by their help group heading.
-   */
-  groupItems<T extends ICommand | Option>(
-    unsortedItems: T[],
-    visibleItems: T[],
-    getGroup: (item: T) => string,
-  ): Map<string, T[]>;
-  /**
-   * Return display width of string, ignoring ANSI escape sequences. Used in padding and wrapping calculations.
-   */
-  displayWidth(str: string): number;
-  /**
-   * Style the title for displaying in the help. Called with 'Usage:', 'Options:', etc.
-   */
-  styleTitle(str: string): string;
-  /**
-   * Style the usage line for displaying in the help. Applies specific styling to different parts like options, commands, and arguments.
-   */
-  styleUsage(str: string): string;
-  /**
-   * Style command descriptions for display in help output.
-   */
-  styleCommandDescription(str: string): string;
-  /**
-   * Style option descriptions for display in help output.
-   */
-  styleOptionDescription(str: string): string;
-  /**
-   * Style subcommand descriptions for display in help output.
-   */
-  styleSubcommandDescription(str: string): string;
-  /**
-   * Style argument descriptions for display in help output.
-   */
-  styleArgumentDescription(str: string): string;
-  /**
-   * Base style used by descriptions. Override in subclass to apply custom formatting.
-   */
-  styleDescriptionText(str: string): string;
-  /**
-   * Style option terms (flags) for display in help output.
-   */
-  styleOptionTerm(str: string): string;
-  /**
-   * Style subcommand terms for display in help output. Applies specific styling to different parts like options and arguments.
-   */
-  styleSubcommandTerm(str: string): string;
-  /**
-   * Style argument terms for display in help output.
-   */
-  styleArgumentTerm(str: string): string;
-  /**
-   * Base style used in terms and usage for options. Override in subclass to apply custom formatting.
-   */
-  styleOptionText(str: string): string;
-  /**
-   * Base style used in terms and usage for arguments. Override in subclass to apply custom formatting.
-   */
-  styleArgumentText(str: string): string;
-  /**
-   * Base style used in terms and usage for subcommands. Override in subclass to apply custom formatting.
-   */
-  styleSubcommandText(str: string): string;
-  /**
-   * Base style used in terms and usage for commands. Override in subclass to apply custom formatting.
-   */
-  styleCommandText(str: string): string;
-  /**
-   * Calculate the pad width from the maximum term length.
-   */
-  padWidth(): number;
-  /**
-   * Detect manually wrapped and indented strings by checking for line break followed by whitespace.
-   */
-  preformatted(str: string): boolean;
-  /**
-   * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines.
-   *
-   * So "TTT", 5, "DDD DDDD DD DDD" might be formatted for this.helpWidth=17 like so:
-   *   TTT  DDD DDDD
-   *        DD DDD
-   */
-  formatItem(term: string, termWidth: number, description: string): string;
-  /**
-   * Wrap a string at whitespace, preserving existing line breaks.
-   * Wrapping is skipped if the width is less than `minWidthToWrap`.
-   */
-  boxWrap(str: string, width: number): string;
-  /**
-   * Generate the built-in help text.
-   */
-  render(): string;
+    protected readonly cmd: ICommand;
+    /** output helpWidth, long lines are wrapped to fit */
+    helpWidth: number;
+    minWidthToWrap: number;
+    sortSubcommands: boolean;
+    sortOptions: boolean;
+    usageDisplayOptionsAs: string;
+    usageDisplaySubcommandAs: string;
+    constructor(cmd: ICommand);
+    /**
+     * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
+     */
+    visibleCommands(): ICommand[];
+    /**
+     * Compare options for sort.
+     */
+    compareOptions(a: Option, b: Option): number;
+    /**
+     * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
+     */
+    visibleOptions(): Option[];
+    /**
+     * Get an array of the arguments if any have a description.
+     */
+    visibleArguments(): Argument[];
+    /**
+     * Get the command term to show in the list of subcommands.
+     */
+    subcommandTerm(sub: ICommand): string;
+    /**
+     * Get the option term to show in the list of options.
+     */
+    optionTerm(option: Option): string;
+    /**
+     * Get the argument term to show in the list of arguments.
+     */
+    argumentTerm(argument: Argument): string;
+    /**
+     * Get the longest subcommand primary alias length.
+     */
+    longestSubcommandAliasLength(): number;
+    /**
+     * Get the longest subcommand term length.
+     */
+    longestSubcommandTermLength(): number;
+    /**
+     * Get the longest option term length.
+     */
+    longestOptionTermLength(): number;
+    /**
+     * Get the longest argument term length.
+     */
+    longestArgumentTermLength(): number;
+    /**
+     * Get the command usage to be displayed at the top of the built-in help.
+     */
+    commandUsage(): string;
+    /**
+     * Get the description for the command.
+     */
+    commandDescription(): string;
+    /**
+     * Get the subcommand summary to show in the list of subcommands.
+     * (Fallback to description for backwards compatibility.)
+     */
+    subcommandDescription(sub: ICommand): string;
+    /**
+     * Get the option description to show in the list of options.
+     */
+    optionDescription(option: Option): string;
+    /**
+     * Get the argument description to show in the list of arguments.
+     */
+    argumentDescription(argument: Argument): string;
+    /**
+     * Format a list of items, given a heading and an array of formatted items.
+     */
+    formatItemList(heading: string, items: string[]): string[];
+    /**
+     * Group items by their help group heading.
+     */
+    groupItems<T extends ICommand | Option>(unsortedItems: T[], visibleItems: T[], getGroup: (item: T) => string): Map<string, T[]>;
+    /**
+     * Return display width of string, ignoring ANSI escape sequences. Used in padding and wrapping calculations.
+     */
+    displayWidth(str: string): number;
+    /**
+     * Style the title for displaying in the help. Called with 'Usage:', 'Options:', etc.
+     */
+    styleTitle(str: string): string;
+    /**
+     * Style the usage line for displaying in the help. Applies specific styling to different parts like options, commands, and arguments.
+     */
+    styleUsage(str: string): string;
+    /**
+     * Style command descriptions for display in help output.
+     */
+    styleCommandDescription(str: string): string;
+    /**
+     * Style option descriptions for display in help output.
+     */
+    styleOptionDescription(str: string): string;
+    /**
+     * Style subcommand descriptions for display in help output.
+     */
+    styleSubcommandDescription(str: string): string;
+    /**
+     * Style argument descriptions for display in help output.
+     */
+    styleArgumentDescription(str: string): string;
+    /**
+     * Base style used by descriptions. Override in subclass to apply custom formatting.
+     */
+    styleDescriptionText(str: string): string;
+    /**
+     * Style option terms (flags) for display in help output.
+     */
+    styleOptionTerm(str: string): string;
+    /**
+     * Style subcommand terms for display in help output. Applies specific styling to different parts like options and arguments.
+     */
+    styleSubcommandTerm(str: string): string;
+    /**
+     * Style argument terms for display in help output.
+     */
+    styleArgumentTerm(str: string): string;
+    /**
+     * Base style used in terms and usage for options. Override in subclass to apply custom formatting.
+     */
+    styleOptionText(str: string): string;
+    /**
+     * Base style used in terms and usage for arguments. Override in subclass to apply custom formatting.
+     */
+    styleArgumentText(str: string): string;
+    /**
+     * Base style used in terms and usage for subcommands. Override in subclass to apply custom formatting.
+     */
+    styleSubcommandText(str: string): string;
+    /**
+     * Base style used in terms and usage for commands. Override in subclass to apply custom formatting.
+     */
+    styleCommandText(str: string): string;
+    /**
+     * Calculate the pad width from the maximum term length.
+     */
+    padWidth(): number;
+    /**
+     * Detect manually wrapped and indented strings by checking for line break followed by whitespace.
+     */
+    preformatted(str: string): boolean;
+    /**
+     * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines.
+     *
+     * So "TTT", 5, "DDD DDDD DD DDD" might be formatted for this.helpWidth=17 like so:
+     *   TTT  DDD DDDD
+     *        DD DDD
+     */
+    formatItem(term: string, termWidth: number, description: string): string;
+    /**
+     * Wrap a string at whitespace, preserving existing line breaks.
+     * Wrapping is skipped if the width is less than `minWidthToWrap`.
+     */
+    boxWrap(str: string, width: number): string;
+    /**
+     * Generate the built-in help text.
+     */
+    render(): string;
 }
 
 /**
  * a type-safe CLI composer that can parse argv and generate help without execution coupling.
  */
-declare class Command<
-  A extends Arguments = [],
-  O extends Options = {
+declare class Command<A extends Arguments = [], O extends Options = {
     help?: boolean;
     debug?: boolean;
-  },
-  Subs extends SubCommands = SubCommands,
-> implements ICommand
-{
-  /** parent command in the hierarchy, undefined for root command */
-  parent?: Command<Arguments, Options & O>;
-  /** the command name used to invoke it */
-  name: string;
-  /** semantic version string displayed by --version flag */
-  version?: string;
-  /** alternative names for invoking this command */
-  aliases: string[];
-  /** brief one-line description shown in command lists */
-  summary?: string;
-  /** full description displayed in help text */
-  description: string;
-  /** whether to exclude from help listings */
-  hidden?: boolean;
-  /** category for organizing related commands in help output */
-  group?: string;
-  /** positional arguments this command accepts */
-  arguments: Argument[];
-  /** cLI options (flags) this command recognizes */
-  options: Option[];
-  /** subcommands registered with this command */
-  commands: Subs;
-  /** main action handler executed when command is invoked */
-  protected action?: ActionHandler<A, O, Subs>;
-  /** option-driven actions (e.g., --help, --version) executed when their conditions match */
-  protected hooks: HookDefinition<Arguments, Options & O>[];
-  constructor(name: string, parent?: ICommand);
-  protected get help(): Help;
-  /** configure how the help is rendered */
-  helpConfiguration(cb?: (help: Help) => void): this;
-  /** renders formatted help text using provided help definition */
-  renderHelp(config?: { noColor?: boolean }): string;
-  /** sets the command name */
-  setName(name: string): void;
-  /** sets command aliases, flattening nested arrays */
-  setAliases(...aliases: (string | string[])[]): this;
-  /** adds aliases to existing ones */
-  addAliases(...aliases: (string | string[])[]): this;
-  /** sets the command version */
-  setVersion(version: string): InferAddOptionResult<
-    A,
-    O,
-    {
-      version?: boolean;
-    },
-    Subs
-  >;
-  /** sets the command summary */
-  setSummary(summary?: string): this;
-  /** sets command description, joining variadic lines */
-  setDescription(...lines: string[]): this;
-  /** sets whether command is hidden from help */
-  setHidden(hidden?: boolean | undefined): this;
-  /** sets the command group for help organization */
-  setGroup(group?: string): this;
-  /** add a subcommand and return the subcommand. All options are inherited by the subcommand. */
-  command<Name extends string, Sub extends Command<any, any, any> = Command<[], O, {}>>(
-    name: Name,
-    cb?: (cmd: Command<[], O, {}>, parent: this) => Sub,
-  ): Sub;
-  /** add a subcommand and return the subcommand. All options are inherited by the subcommand. */
-  addCommand<Name extends string, Sub extends Command<any, any, any> = Command<[], O, {}>>(
-    name: Name,
-    cb: (cmd: Command<[], O, {}>, parent: this) => Sub,
-  ): Command<
-    A,
-    O,
-    (SubCommands extends Subs ? {} : Subs) & {
-      [K in Name]: Sub;
-    }
-  >;
-  /** add required variadic argument, eg.: `<name...>` */
-  addArgument<const Opts extends RequiredVariadicArgumentOptions>(
-    usage: AllowedArgumentUsage<this, `<${string}...>`>,
-    options?: Opts,
-  ): Command<[...A, InferAddedArgumentType<Opts>[]], O, Subs>;
-  /** add required argument, eg.: `<name>` */
-  addArgument<const Opts extends RequiredArgumentOptions>(
-    usage: AllowedArgumentUsage<this, `<${string}>`>,
-    options?: Opts,
-  ): Command<[...A, InferAddedArgumentType<Opts>], O, Subs>;
-  /** add optional variadic argument with defaults, eg.: `[name...]` */
-  addArgument<const Opts extends OptionalVariadicArgumentOptions>(
-    usage: AllowedArgumentUsage<this, `[${string}...]`>,
-    options?: Opts,
-  ): Command<[...A, InferAddedArgumentType<Opts>[]], O, Subs>;
-  /** add optional argument with default, eg.: `[name]` */
-  addArgument<const Opts extends OptionalArgumentOptionsWithDefaultValue>(
-    usage: AllowedArgumentUsage<this, `[${string}]`>,
-    options: Opts,
-  ): Command<[...A, InferAddedArgumentType<Opts>], O, Subs>;
-  /** add optional argument, eg.: `[name]` */
-  addArgument<const Opts extends OptionalArgumentOptions>(
-    usage: AllowedArgumentUsage<this, `[${string}]`>,
-    options?: Opts,
-  ): Command<[...A, InferAddedArgumentType<Opts> | undefined], O, Subs>;
-  /** add optional string option, eg.: `-o, --output [path]` */
-  addOption<Long extends string>(
-    flags: `-${string}, --${Long} [${string}]`,
-    options?: SetFieldType<OptionalOptionOptions, 'defaultValue', undefined | never>,
-  ): Command<
-    A,
-    Simplify<
-      {
+}, Subs extends SubCommands = SubCommands> implements ICommand {
+    /** parent command in the hierarchy, undefined for root command */
+    parent?: Command<Arguments, Options & O>;
+    /** the command name used to invoke it */
+    name: string;
+    /** semantic version string displayed by --version flag */
+    version?: string;
+    /** alternative names for invoking this command */
+    aliases: string[];
+    /** brief one-line description shown in command lists */
+    summary?: string;
+    /** full description displayed in help text */
+    description: string;
+    /** whether to exclude from help listings */
+    hidden?: boolean;
+    /** category for organizing related commands in help output */
+    group?: string;
+    /** positional arguments this command accepts */
+    arguments: Argument[];
+    /** cLI options (flags) this command recognizes */
+    options: Option[];
+    /** subcommands registered with this command */
+    commands: Subs;
+    /** main action handler executed when command is invoked */
+    protected action?: ActionHandler<A, O, Subs>;
+    /** option-driven actions (e.g., --help, --version) executed when their conditions match */
+    protected hooks: HookDefinition<Arguments, Options & O>[];
+    constructor(name: string, parent?: ICommand);
+    protected get help(): Help;
+    /** configure how the help is rendered */
+    helpConfiguration(cb?: (help: Help) => void): this;
+    /** renders formatted help text using provided help definition */
+    renderHelp(config?: {
+        noColor?: boolean;
+    }): string;
+    /** sets the command name */
+    setName(name: string): void;
+    /** sets command aliases, flattening nested arrays */
+    setAliases(...aliases: (string | string[])[]): this;
+    /** adds aliases to existing ones */
+    addAliases(...aliases: (string | string[])[]): this;
+    /** sets the command version */
+    setVersion(version: string): InferAddOptionResult<A, O, {
+        version?: boolean;
+    }, Subs>;
+    /** sets the command summary */
+    setSummary(summary?: string): this;
+    /** sets command description, joining variadic lines */
+    setDescription(...lines: string[]): this;
+    /** sets whether command is hidden from help */
+    setHidden(hidden?: boolean | undefined): this;
+    /** sets the command group for help organization */
+    setGroup(group?: string): this;
+    /** add a subcommand and return the subcommand. All options are inherited by the subcommand. */
+    command<Name extends string, Sub extends Command<any, any, any> = Command<[], O, {}>>(name: Name, cb?: (cmd: Command<[], O, {}>, parent: this) => Sub): Sub;
+    /** add a subcommand and return the subcommand. All options are inherited by the subcommand. */
+    addCommand<Name extends string, Sub extends Command<any, any, any> = Command<[], O, {}>>(name: Name, cb: (cmd: Command<[], O, {}>, parent: this) => Sub): Command<A, O, (SubCommands extends Subs ? {} : Subs) & {
+        [K in Name]: Sub;
+    }>;
+    /** add required variadic argument, eg.: `<name...>` */
+    addArgument<const Opts extends RequiredVariadicArgumentOptions>(usage: AllowedArgumentUsage<this, `<${string}...>`>, options?: Opts): Command<[...A, InferAddedArgumentType<Opts>[]], O, Subs>;
+    /** add required argument, eg.: `<name>` */
+    addArgument<const Opts extends RequiredArgumentOptions>(usage: AllowedArgumentUsage<this, `<${string}>`>, options?: Opts): Command<[...A, InferAddedArgumentType<Opts>], O, Subs>;
+    /** add optional variadic argument with defaults, eg.: `[name...]` */
+    addArgument<const Opts extends OptionalVariadicArgumentOptions>(usage: AllowedArgumentUsage<this, `[${string}...]`>, options?: Opts): Command<[...A, InferAddedArgumentType<Opts>[]], O, Subs>;
+    /** add optional argument with default, eg.: `[name]` */
+    addArgument<const Opts extends OptionalArgumentOptionsWithDefaultValue>(usage: AllowedArgumentUsage<this, `[${string}]`>, options: Opts): Command<[...A, InferAddedArgumentType<Opts>], O, Subs>;
+    /** add optional argument, eg.: `[name]` */
+    addArgument<const Opts extends OptionalArgumentOptions>(usage: AllowedArgumentUsage<this, `[${string}]`>, options?: Opts): Command<[...A, InferAddedArgumentType<Opts> | undefined], O, Subs>;
+    /** add optional string option, eg.: `-o, --output [path]` */
+    addOption<Long extends string>(flags: `-${string}, --${Long} [${string}]`, options?: SetFieldType<OptionalOptionOptions, 'defaultValue', undefined | never>): Command<A, Simplify<{
         [K in CamelCase<Long>]?: string;
-      } & O
-    >,
-    Subs
-  >;
-  /** add optional string option with default, eg.: `-o, --output [path]` */
-  addOption<Long extends string>(
-    flags: `-${string}, --${Long} [${string}]`,
-    options: SetFieldType<SetRequired<OptionalOptionOptions, 'defaultValue'>, 'defaultValue', string>,
-  ): Command<
-    A,
-    Simplify<
-      {
+    } & O>, Subs>;
+    /** add optional string option with default, eg.: `-o, --output [path]` */
+    addOption<Long extends string>(flags: `-${string}, --${Long} [${string}]`, options: SetFieldType<SetRequired<OptionalOptionOptions, 'defaultValue'>, 'defaultValue', string>): Command<A, Simplify<{
         [K in CamelCase<Long>]: string;
-      } & O
-    >,
-    Subs
-  >;
-  /** add required variadic option, eg.: `-i, --include <patterns...>` */
-  addOption<Long extends string>(
-    flags: `-${string}, --${Long} <${string}...>`,
-    options?: RequiredVariadicOptionOptions,
-  ): Command<
-    A,
-    Simplify<
-      {
+    } & O>, Subs>;
+    /** add required variadic option, eg.: `-i, --include <patterns...>` */
+    addOption<Long extends string>(flags: `-${string}, --${Long} <${string}...>`, options?: RequiredVariadicOptionOptions): Command<A, Simplify<{
         [K in CamelCase<Long>]: string[];
-      } & O
-    >,
-    Subs
-  >;
-  /** add optional variadic option with defaults, eg.: `-e, --exclude [patterns...]` */
-  addOption<Long extends string>(
-    flags: `-${string}, --${Long} [${string}...]`,
-    options?: OptionalVariadicOptionOptions,
-  ): Command<
-    A,
-    Simplify<
-      {
+    } & O>, Subs>;
+    /** add optional variadic option with defaults, eg.: `-e, --exclude [patterns...]` */
+    addOption<Long extends string>(flags: `-${string}, --${Long} [${string}...]`, options?: OptionalVariadicOptionOptions): Command<A, Simplify<{
         [K in CamelCase<Long>]: string[];
-      } & O
-    >,
-    Subs
-  >;
-  /** add required string option, eg.: `-f, --file <path>` */
-  addOption<Long extends string>(
-    flags: `-${string}, --${Long} <${string}>`,
-    options?: RequiredOptionOptions,
-  ): Command<
-    A,
-    Simplify<
-      {
+    } & O>, Subs>;
+    /** add required string option, eg.: `-f, --file <path>` */
+    addOption<Long extends string>(flags: `-${string}, --${Long} <${string}>`, options?: RequiredOptionOptions): Command<A, Simplify<{
         [K in CamelCase<Long>]: string;
-      } & O
-    >,
-    Subs
-  >;
-  /** add boolean flag option with default, eg.: `-v, --verbose` */
-  addOption<Long extends string>(
-    flags: `-${string}, --${Long}`,
-    options: SetFieldType<SetRequired<BooleanOptionOptions, 'defaultValue'>, 'defaultValue', boolean>,
-  ): Command<
-    A,
-    Simplify<
-      {
+    } & O>, Subs>;
+    /** add boolean flag option with default, eg.: `-v, --verbose` */
+    addOption<Long extends string>(flags: `-${string}, --${Long}`, options: SetFieldType<SetRequired<BooleanOptionOptions, 'defaultValue'>, 'defaultValue', boolean>): Command<A, Simplify<{
         [K in CamelCase<Long>]: boolean;
-      } & O
-    >,
-    Subs
-  >;
-  /** add boolean flag option, eg.: `-v, --verbose` */
-  addOption<Long extends string>(
-    flags: `-${string}, --${Long}`,
-    options?: SetFieldType<BooleanOptionOptions, 'defaultValue', undefined | never>,
-  ): Command<
-    A,
-    Simplify<
-      {
+    } & O>, Subs>;
+    /** add boolean flag option, eg.: `-v, --verbose` */
+    addOption<Long extends string>(flags: `-${string}, --${Long}`, options?: SetFieldType<BooleanOptionOptions, 'defaultValue', undefined | never>): Command<A, Simplify<{
         [K in CamelCase<Long>]?: boolean;
-      } & O
-    >,
-    Subs
-  >;
-  /**
-   * register an action to be invoked when an option is set to true or string value.
-   *
-   * Hooks execute in addition to or instead of the main action handler,
-   * allowing for option-driven behavior. For example, `--help` and `--version`
-   * are implemented as hooks.
-   */
-  addOptionHook(optionName: keyof O, action: HookActionHandler<Arguments, O>): this;
-  /** parses command-line arguments with subcommand support and type-safe validation. */
-  parseArgv(argv?: string[]): ParseArgvResult<Arguments, Options & O>;
-  /**
-   * sets the main action handler for this command, which is executed after any matching option hooks when the command is invoked.
-   * The handler receives parsed arguments and options with correct typings.
-   */
-  setAction(fn: ActionHandler<A, O, Subs>): this;
-  /** returns a new Command instance. Override this method in subclasses. */
-  protected createSubcommand(name: string): Command<[], O, {}>;
+    } & O>, Subs>;
+    /**
+     * register an action to be invoked when an option is set to true or string value.
+     *
+     * Hooks execute in addition to or instead of the main action handler,
+     * allowing for option-driven behavior. For example, `--help` and `--version`
+     * are implemented as hooks.
+     */
+    addOptionHook(optionName: keyof O, action: HookActionHandler<Arguments, O>): this;
+    /** parses command-line arguments with subcommand support and type-safe validation. */
+    parseArgv(argv?: string[]): ParseArgvResult<Arguments, Options & O>;
+    /**
+     * sets the main action handler for this command, which is executed after any matching option hooks when the command is invoked.
+     * The handler receives parsed arguments and options with correct typings.
+     */
+    setAction(fn: ActionHandler<A, O, Subs>): this;
+    /** returns a new Command instance. Override this method in subclasses. */
+    protected createSubcommand(name: string): Command<[], O, {}>;
 }
 
 /**
@@ -869,55 +701,11 @@ declare function getCommandAndAncestors<C extends ICommand>(cmd: C): [typeof cmd
 /**
  * Parses option flags string into its components
  */
-declare function parseOptionFlags<Long extends string>(
-  flags: OptionUsage<Long>,
-): {
-  short: string;
-  long: Long;
-  name: CamelCase<Long>;
-  argName: string | undefined;
+declare function parseOptionFlags<Long extends string>(flags: OptionUsage<Long>): {
+    short: string;
+    long: Long;
+    name: CamelCase<Long>;
+    argName: string | undefined;
 };
 
-export {
-  type ActionHandler,
-  type AllowedArgumentUsage,
-  type Argument,
-  type ArgumentOptions,
-  type ArgumentUsage,
-  type Arguments,
-  type BooleanOptionOptions,
-  Command,
-  Help,
-  type HookActionHandler,
-  type HookDefinition,
-  type HookPredicate,
-  type ICommand,
-  type IHelp,
-  type InferAddOptionResult,
-  type InferAddedArgumentType,
-  type Logger,
-  type Option,
-  type OptionOptions,
-  type OptionUsage,
-  type OptionalArgumentOptions,
-  type OptionalArgumentOptionsWithDefaultValue,
-  type OptionalArgumentUsage,
-  type OptionalOptionOptions,
-  type OptionalVariadicArgumentOptions,
-  type OptionalVariadicArgumentUsage,
-  type OptionalVariadicOptionOptions,
-  type Options,
-  type ParseArgvResult,
-  type RequiredArgumentOptions,
-  type RequiredArgumentUsage,
-  type RequiredOptionOptions,
-  type RequiredVariadicArgumentOptions,
-  type RequiredVariadicArgumentUsage,
-  type RequiredVariadicOptionOptions,
-  type SubCommands,
-  findCommand,
-  findOption,
-  getCommandAncestors,
-  getCommandAndAncestors,
-  parseOptionFlags,
-};
+export { type ActionHandler, type AllowedArgumentUsage, type Argument, type ArgumentOptions, type ArgumentUsage, type Arguments, type BooleanOptionOptions, Command, Help, type HookActionHandler, type HookDefinition, type HookPredicate, type ICommand, type IHelp, type InferAddOptionResult, type InferAddedArgumentType, type Logger, type Option, type OptionOptions, type OptionUsage, type OptionalArgumentOptions, type OptionalArgumentOptionsWithDefaultValue, type OptionalArgumentUsage, type OptionalOptionOptions, type OptionalVariadicArgumentOptions, type OptionalVariadicArgumentUsage, type OptionalVariadicOptionOptions, type Options, type ParseArgvResult, type RequiredArgumentOptions, type RequiredArgumentUsage, type RequiredOptionOptions, type RequiredVariadicArgumentOptions, type RequiredVariadicArgumentUsage, type RequiredVariadicOptionOptions, type SubCommands, findCommand, findOption, getCommandAncestors, getCommandAndAncestors, parseOptionFlags };