bob-core 3.0.0-beta.4 → 3.0.0-beta.6

package/dist/esm/{src/lib → lib}/helpers.d.ts

@@ -1,4 +1,4 @@
 import { Command } from '../Command.js';
 import { BobError } from '../errors/index.js';
-export declare function isBobError(err: Error): err is BobError;
+export declare function isBobError(err: unknown): err is BobError;
 export declare function isBobCommandClass(cls: unknown): cls is typeof Command;

package/dist/esm/lib/types.d.ts

@@ -0,0 +1,99 @@
+import { Command } from '../Command.js';
+import { UX } from '../ux/index.js';
+export type ContextDefinition = any;
+export type CustomOptions = Record<string, unknown>;
+export type FlagKind = 'string' | 'number' | 'boolean' | 'option' | 'file' | 'directory' | 'url' | 'custom';
+/**
+ * Options handed to a flag's `parse`, `ask`, and `handler` callbacks.
+ *
+ * `definition` is typed as the canonical {@link FlagDefinition}. Builder-specific
+ * extras (`options`, `min`, `max`, `exists`, `secret`) live directly on
+ * {@link FlagDefinition}, so handlers can read them without `any` casts while still
+ * being honest that they are optional at the type level.
+ */
+export type FlagOpts<C extends ContextDefinition = ContextDefinition, P extends CustomOptions = CustomOptions> = {
+    name: string;
+    ux: UX;
+    ctx: C;
+    definition: FlagDefinition<C, P>;
+    cmd: typeof Command;
+};
+export type FlagDefinition<T = any, C extends CustomOptions = CustomOptions> = {
+    [key in keyof C]: C[keyof C];
+} & {
+    parse: (input: any, opts: FlagOpts<any, C>) => T;
+    type?: FlagKind;
+    ask?: (opts: FlagOpts) => Promise<any>;
+    description?: string;
+    required?: boolean;
+    default?: T | T[] | null | (() => T | T[] | null) | (() => Promise<T | T[] | null>);
+    multiple?: boolean;
+    help?: string;
+    alias?: string | readonly string[];
+    handler?: (value: T, opts: FlagOpts) => {
+        shouldStop: boolean;
+    } | void;
+};
+export type InitFlagDefinition<T = any, C extends CustomOptions = CustomOptions> = Omit<FlagDefinition<T, C>, 'parse'> & {
+    parse?: (input: any, opts: FlagOpts<any, C>) => T;
+};
+/** Infers the runtime return type of a flag definition, accounting for `multiple`. */
+export type InferFlagReturn<O> = O extends {
+    parse: (...args: any[]) => infer R;
+} ? O extends {
+    multiple: true;
+} ? [R] extends [Array<unknown>] ? R : R[] : R : never;
+/**
+ * `true` when the parsed value cannot be `null`:
+ *  - `required: true`
+ *  - `multiple: true` (always an array)
+ *  - `default` resolves to a value where neither `null` nor `undefined` is in the union
+ *    (covers `T`, `T[]`, `() => T`, `() => Promise<T>`)
+ */
+type IsGuaranteed<O> = O extends {
+    required: true;
+} ? true : O extends {
+    multiple: true;
+} ? true : O extends {
+    default: infer D;
+} ? null extends D ? false : undefined extends D ? false : true : false;
+/**
+ * Final value type seen by the handler — `T` if guaranteed (required, multiple,
+ * or non-null default), otherwise `T | null`.
+ */
+export type FlagReturnType<O> = IsGuaranteed<O> extends true ? InferFlagReturn<O> : InferFlagReturn<O> | null;
+/** Historic alias — kept so `FlagType<O>` keeps working as a value-inference helper. */
+export type FlagType<O> = InferFlagReturn<O>;
+/** Schema mapping flag names to their {@link FlagDefinition}. */
+export type FlagsSchema = {
+    [key: string]: FlagDefinition<any, any>;
+};
+/** Inferred runtime shape of all flags in a schema. */
+export type FlagsObject<Options extends FlagsSchema> = {
+    [Key in keyof Options]: FlagReturnType<Options[Key]>;
+};
+/**
+ * Schema for positional arguments.
+ *
+ * Note on booleans: positional booleans don't really make sense, so the
+ * canonical {@link Args} builder set deliberately omits `Args.boolean`. The
+ * type itself is a structural alias of {@link FlagsSchema} (rather than a
+ * branded subtype) to keep literal-type inference flowing through the builder
+ * generics without surprising errors. If you put `Flags.boolean()` in
+ * `static args`, the runtime parser will accept it but you're outside the
+ * supported design.
+ */
+export type ArgDefinition = FlagDefinition;
+export type ArgsSchema = FlagsSchema;
+export type InferFlags<T> = T extends {
+    flags: infer O extends FlagsSchema;
+} ? O : FlagsSchema;
+export type InferArgs<T> = T extends {
+    args: infer A extends ArgsSchema;
+} ? A : ArgsSchema;
+/** `{ flags, args }` pair for a given Command class — the second handler argument. */
+export type Parsed<T> = {
+    flags: FlagsObject<InferFlags<T>>;
+    args: FlagsObject<InferArgs<T>>;
+};
+export {};

package/dist/esm/shared/ask-helpers.d.ts

@@ -0,0 +1,7 @@
+import { FlagOpts } from '../lib/types.js';
+export declare function buildStringAsk(builderOpts: FlagOpts): Promise<any>;
+export declare function buildNumberAsk(builderOpts: FlagOpts): Promise<any>;
+export declare function buildOptionAsk(builderOpts: FlagOpts): Promise<any>;
+export declare function buildFileAsk(builderOpts: FlagOpts): Promise<any>;
+export declare function buildDirectoryAsk(builderOpts: FlagOpts): Promise<any>;
+export declare function buildUrlAsk(builderOpts: FlagOpts): Promise<any>;

package/dist/esm/shared/flagsUtils.d.ts

@@ -0,0 +1,5 @@
+import { numberFlag } from '../flags/number.js';
+import { optionFlag } from '../flags/option.js';
+import { FlagDefinition } from '../lib/types.js';
+export declare function isNumberFlag(flag: FlagDefinition): flag is ReturnType<typeof numberFlag>;
+export declare function isOptionFlag(flag: FlagDefinition<any, any>): flag is ReturnType<typeof optionFlag>;

package/dist/esm/ux/askForConfirmation.d.ts

@@ -0,0 +1,10 @@
+export type AskForConfirmationOptions = {
+    default?: boolean;
+    transformer?: (value: boolean) => string;
+};
+/**
+ * Yes/no confirmation prompt. Returns the user's choice, or `null` if they
+ * cancelled (Ctrl+C / SIGINT) — matching the cancellation contract used by
+ * every other prompt in the {@link UX} module.
+ */
+export declare function askForConfirmation(message?: string, opts?: AskForConfirmationOptions): Promise<boolean | null>;

package/dist/esm/{src/ux → ux}/askForToggle.d.ts

@@ -3,4 +3,8 @@ export type AskForToggleOptions = {
     active?: string;
     inactive?: string;
 };
-export declare function askForToggle(message: string, opts?: AskForToggleOptions): Promise<boolean>;
+/**
+ * Two-state toggle prompt with custom labels. Returns the chosen state, or
+ * `null` if cancelled (Ctrl+C / SIGINT).
+ */
+export declare function askForToggle(message: string, opts?: AskForToggleOptions): Promise<boolean | null>;

package/dist/esm/ux/helpers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Wraps an inquirer prompt so that cancellation (Ctrl+C / SIGINT, surfaced as
+ * `ExitPromptError`) resolves to `fallback` instead of throwing. Every other
+ * exception propagates so genuine failures stay visible.
+ */
+export declare function withCancelHandling<T>(fn: () => Promise<T>, fallback: T): Promise<T>;

package/dist/{cjs/src → esm}/ux/index.d.ts

@@ -12,32 +12,59 @@ import { AskForSearchOptions, SearchSource } from './askForSearch.js';
 import { AskForSelectOptions } from './askForSelect.js';
 import { AskForToggleOptions } from './askForToggle.js';
 import { KeyValueOptions, ProgressBarOptions, SelectOption, TableColumn } from './types.js';
+/**
+ * Interactive prompts and structured-output helpers exposed to commands as
+ * `this.ux`.
+ *
+ * **Cancellation contract:** every `askFor*` method returns `Promise<T | null>`,
+ * where `null` means the user cancelled the prompt (Ctrl+C / SIGINT). Callers
+ * should treat `null` as "user wants out" and react accordingly — there is no
+ * separate "cancelled" exception to catch.
+ */
 export declare class UX {
-    askForConfirmation(message?: string, opts?: AskForConfirmationOptions): Promise<boolean>;
+    /** Yes/no confirmation. Returns `null` on cancel. */
+    askForConfirmation(message?: string, opts?: AskForConfirmationOptions): Promise<boolean | null>;
+    /** Free-text input. Returns `null` on cancel. */
     askForInput(message: string, opts?: AskForInputOptions): Promise<string | null>;
+    /** Masked password input. Returns `null` on cancel. */
     askForPassword(message: string, opts?: AskForPasswordOptions): Promise<string | null>;
+    /** Numeric input with optional validator. Returns `null` on cancel. */
     askForNumber(message: string, opts?: AskForNumberOptions): Promise<number | null>;
+    /** Single-choice list. Returns `null` on cancel. */
     askForSelect<V = string>(message: string, choices: Array<string | SelectOption<V>>, opts?: AskForSelectOptions<V>): Promise<V | null>;
+    /** Multi-choice checkbox list. Returns `null` on cancel. */
     askForCheckbox<V = string>(message: string, choices: Array<string | SelectOption<V>>, opts?: AskForCheckboxOptions<V>): Promise<V[] | null>;
+    /** Type-ahead search backed by a custom source. Returns `null` on cancel. */
     askForSearch<V = string>(message: string, source: SearchSource<V>, opts?: AskForSearchOptions<V>): Promise<V | null>;
+    /** Comma-separated list input. Returns `null` on cancel. */
     askForList(message: string, opts?: AskForListOptions): Promise<string[] | null>;
-    askForToggle(message: string, opts?: AskForToggleOptions): Promise<boolean>;
+    /** Two-state toggle with custom labels. Returns `null` on cancel. */
+    askForToggle(message: string, opts?: AskForToggleOptions): Promise<boolean | null>;
+    /** Opens the user's editor (`$EDITOR`). Returns `null` on cancel. */
     askForEditor(message: string, opts?: AskForEditorOptions): Promise<string | null>;
+    /** Numbered list with manual entry. Returns `null` on cancel. */
     askForRawList<V = string>(message: string, choices: Array<{
         key?: string;
         name?: string;
         value: V;
     }>, opts?: AskForRawListOptions): Promise<V | null>;
+    /** Single-key expand prompt (Yes/No/Help-style). Returns `null` on cancel. */
     askForExpand<V = string>(message: string, choices: Array<{
         key: ExpandKey;
         name: string;
         value: V;
     }>, opts?: AskForExpandOptions): Promise<V | null>;
+    /** Filesystem file picker. Returns `null` on cancel. */
     askForFile(message: string, opts?: Omit<AskForFileSelectorOptions, 'type'>): Promise<string | null>;
+    /** Filesystem directory picker. Returns `null` on cancel. */
     askForDirectory(message: string, opts?: Omit<AskForFileSelectorOptions, 'type'>): Promise<string | null>;
+    /** Generic file/directory picker. Returns `null` on cancel. */
     askForFileSelector(message: string, opts?: AskForFileSelectorOptions): Promise<string | null>;
+    /** Renders a key/value list to the terminal. */
     keyValue(pairs: Record<string, unknown> | Array<[string, unknown]>, opts?: KeyValueOptions): void;
+    /** Renders rows as an aligned table with optional column metadata. */
     table<T extends Record<string, unknown>>(data: T[], columns?: TableColumn<T>[]): void;
+    /** Builds a progress bar bound to a known total. */
     newProgressBar(total: number, opts?: ProgressBarOptions): {
         increment: (amount?: number) => void;
         update: (value: number) => void;
@@ -45,6 +72,7 @@ export declare class UX {
         [Symbol.dispose]: () => void;
         [Symbol.asyncDispose]: () => void;
     };
+    /** Builds a spinner-style loader. */
     newLoader(text?: string, chars?: string[], delay?: number): {
         [Symbol.dispose]: () => void;
         [Symbol.asyncDispose]: () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bob-core",
-  "version": "3.0.0-beta.4",
+  "version": "3.0.0-beta.6",
   "description": "BOB Core",
   "type": "module",
   "main": "./dist/cjs/src/index.js",

package/dist/cjs/package-BYPkkzPN.cjs

@@ -1 +0,0 @@
-var e={name:`bob-core`,version:`3.0.0-beta.4`,description:`BOB Core`,type:`module`,main:`./dist/cjs/src/index.js`,module:`./dist/esm/src/index.js`,types:`./dist/esm/src/index.d.ts`,files:[`dist`],exports:{".":{import:{types:`./dist/esm/src/index.d.ts`,default:`./dist/esm/src/index.js`},require:{types:`./dist/cjs/src/index.d.ts`,default:`./dist/cjs/src/index.js`}}},scripts:{start:`node -r @swc-node/register debug/main.ts`,build:`rm -rf ./dist && vite build`,typecheck:`tsc --noEmit`,prepack:`npm run build`,test:`vitest run`,lint:`eslint .`,"lint:fix":`eslint . --fix`},author:`Léo Hubert`,license:`ISC`,devDependencies:{"@eslint/js":`^9.39.4`,"@faker-js/faker":`^10.3.0`,"@swc-node/register":`^1.11.1`,"@trivago/prettier-plugin-sort-imports":`^5.2.2`,"@types/minimist":`^1.2.5`,"@types/node":`^20.14.5`,"@types/string-similarity":`^4.0.2`,"@vitest/coverage-v8":`^4.1.0`,eslint:`^9.39.4`,"eslint-config-prettier":`^10.1.8`,"eslint-plugin-prettier":`^5.5.5`,prettier:`^3.6.2`,tsx:`^4.21.0`,typescript:`^5.9.3`,"typescript-eslint":`^8.57.0`,vite:`^8.0.0`,"vite-plugin-dts":`^4.5.4`,vitest:`^4.1.0`},dependencies:{"@inquirer/core":`^11.1.8`,"@inquirer/prompts":`^8.4.1`,chalk:`^5.6.2`,"inquirer-file-selector":`^1.0.1`,minimist:`^1.2.8`}};exports.default=e;

package/dist/cjs/src/Command.d.ts

@@ -1,48 +0,0 @@
-import { CommandParser } from './CommandParser.js';
-import { Logger } from './Logger.js';
-import { ArgsSchema, ContextDefinition, FlagsSchema, Parsed } from './lib/types.js';
-import { UX } from './ux/index.js';
-export type CommandRunExample = {
-    description: string;
-    command: string;
-};
-export type CommandRunOption<C = ContextDefinition> = {
-    logger: Logger;
-    ctx: C;
-} & ({
-    args: string[];
-} | {
-    args: Record<string, any>;
-    flags: Record<string, any>;
-});
-export declare abstract class Command<C extends ContextDefinition = ContextDefinition> {
-    static $type: "BobCommand";
-    static command: string;
-    static description: string;
-    static group?: string;
-    static args: ArgsSchema;
-    static flags: FlagsSchema;
-    static examples: CommandRunExample[];
-    static hidden: boolean;
-    static aliases: string[];
-    static disableDefaultOptions: boolean;
-    static disablePrompting: boolean;
-    static allowUnknownFlags: boolean;
-    static strictMode: boolean;
-    protected ctx: C;
-    protected logger: Logger;
-    protected ux: UX;
-    protected parser: CommandParser<FlagsSchema, ArgsSchema>;
-    protected preHandle?(): Promise<void | number>;
-    protected abstract handle(ctx: C, parsed: Parsed<any>): Promise<number | void> | number | void;
-    static baseFlags: FlagsSchema;
-    protected newCommandParser(opts: {
-        flags: FlagsSchema;
-        args: ArgsSchema;
-        ctx: ContextDefinition;
-        ux: UX;
-        cmd: typeof Command;
-    }): CommandParser<FlagsSchema, ArgsSchema>;
-    protected newUX(): UX;
-    run(runOpts: CommandRunOption<C>): Promise<number | void>;
-}

package/dist/cjs/src/CommandParser.d.ts

@@ -1,110 +0,0 @@
-import { Command } from './Command.js';
-import { ArgsSchema, ContextDefinition, FlagDefinition, FlagReturnType, FlagsObject, FlagsSchema } from './lib/types.js';
-import { UX } from './ux/index.js';
-/**
- * Parses command-line arguments into typed flags and arguments
- * Handles validation, type conversion, and default values
- */
-export declare class CommandParser<Flags extends FlagsSchema, Arguments extends ArgsSchema> {
-    protected opts: {
-        flags: Flags;
-        args: Arguments;
-        ctx?: ContextDefinition;
-        ux: UX;
-        cmd?: typeof Command;
-    };
-    protected flags: FlagsSchema;
-    protected parsedFlags: FlagsObject<Flags> | null;
-    protected args: ArgsSchema;
-    protected parsedArgs: FlagsObject<Arguments> | null;
-    protected ux: UX;
-    protected shouldPromptForMissingFlags: boolean;
-    protected shouldValidateUnknownFlags: boolean;
-    protected shouldRejectExtraArguments: boolean;
-    constructor(opts: {
-        flags: Flags;
-        args: Arguments;
-        ctx?: ContextDefinition;
-        ux: UX;
-        cmd?: typeof Command;
-    });
-    /**
-     * Parses raw command-line arguments into structured flags and arguments
-     * @param args - Raw command line arguments (typically from process.argv.slice(2))
-     * @returns Object containing parsed flags and arguments
-     * @throws {InvalidFlag} If an unknown flag is provided
-     * @throws {BadCommandFlag} If a value cannot be converted to the expected type
-     */
-    init(args: string[]): Promise<{
-        flags: FlagsObject<Flags>;
-        args: FlagsObject<Arguments>;
-    }>;
-    /**
-     * Validates the parsed flags and arguments
-     * @throws {Error} If validation fails
-     */
-    validate(): Promise<void>;
-    /**
-     * Retrieves a parsed flag value by name
-     * @param name - The flag name
-     * @param defaultValue - Optional default value if flag is not set
-     * @returns The typed flag value
-     * @throws {Error} If init() has not been called yet
-     */
-    flag<FlagName extends keyof Flags>(name: FlagName, defaultValue?: FlagReturnType<Flags[FlagName]>): FlagReturnType<Flags[FlagName]>;
-    setFlag<FlagName extends keyof Flags>(name: FlagName, value: FlagReturnType<Flags[FlagName]>): Promise<void>;
-    /**
-     * Retrieves a parsed argument value by name
-     * @param name - The argument name
-     * @param defaultValue - Optional default value if argument is not set
-     * @returns The typed argument value
-     * @throws {Error} If init() has not been called yet
-     */
-    argument<ArgName extends keyof Arguments>(name: ArgName, defaultValue?: FlagReturnType<Arguments[ArgName]>): FlagReturnType<Arguments[ArgName]>;
-    setArgument<ArgName extends keyof Arguments>(name: ArgName, value: FlagReturnType<Arguments[ArgName]>): Promise<void>;
-    /**
-     * Checks if a value should be considered "empty" for default value purposes
-     * @param value - The value to check
-     * @returns true if the value is null, undefined, or an empty array
-     */
-    private isEmptyValue;
-    /**
-     * Validates that all provided flags are recognized
-     * @throws {InvalidFlag} If an unknown flag is found
-     */
-    private validateUnknownFlags;
-    /**
-     * Processes named flags from minimist output
-     */
-    private handleOptions;
-    /**
-     * Processes positional arguments from minimist output
-     */
-    private handleArguments;
-    /**
-     * Resolves a flag value from the parsed flag values object
-     * Handles alias resolution, defaults, and type conversion
-     */
-    private resolveFlagValue;
-    /**
-     * Parses a raw value using the definition's parse function
-     */
-    private parseValue;
-    private buildOpts;
-    private safeParse;
-    /**
-     * Validates a schema (flags or args) and prompts for missing required values
-     */
-    private validateSchema;
-    /**
-     * Disables prompting for missing argument values
-     * Useful for non-interactive environments
-     */
-    disablePrompting(): this;
-    allowUnknownFlags(): this;
-    strictMode(): this;
-    /**
-     * Prompts the user to provide a missing value via its `ask` method
-     */
-    protected promptFor(name: string, definition: FlagDefinition): Promise<string | number | string[] | boolean | null>;
-}

package/dist/cjs/src/ExceptionHandler.d.ts

@@ -1,6 +0,0 @@
-import { Logger } from './Logger.js';
-export declare class ExceptionHandler {
-    private readonly logger;
-    constructor(logger: Logger);
-    handle(err: Error): number;
-}

package/dist/cjs/src/HelpFlag.d.ts

@@ -1,12 +0,0 @@
-import { ParameterOpts } from './lib/types.js';
-export declare const HelpCommandFlag: import('./lib/types.js').FlagProps<boolean> & import('./lib/types.js').CustomOptions & {
-    readonly alias: readonly ["h"];
-    readonly description: "Displays help information about the command";
-    readonly handler: (value: boolean, opts: ParameterOpts) => {
-        shouldStop: false;
-    } | {
-        shouldStop: true;
-    };
-} & {
-    parse(input: any, opts: ParameterOpts): boolean;
-};

package/dist/cjs/src/StringSimilarity.d.ts

@@ -1,26 +0,0 @@
-export interface SimilarityResult {
-    rating: number;
-    target: string;
-}
-export interface BestMatchResult {
-    bestMatch: SimilarityResult;
-    bestMatchIndex: number;
-    ratings: SimilarityResult[];
-}
-/**
- * String similarity calculator using Dice's Coefficient algorithm
- */
-export declare class StringSimilarity {
-    /**
-     * Generate bigrams (character pairs) from a string
-     */
-    private getBigrams;
-    /**
-     * Calculate Dice's Coefficient similarity between two strings (0-1 scale)
-     */
-    calculateSimilarity(str1: string, str2: string): number;
-    /**
-     * Find best matching string and ratings for all candidates
-     */
-    findBestMatch(target: string, candidates: string[]): BestMatchResult;
-}

package/dist/cjs/src/args/index.d.ts

@@ -1,67 +0,0 @@
-import { custom } from '../flags/custom.js';
-import { optionFlag } from '../flags/option.js';
-export declare const Args: {
-    string: {
-        (): import('../index.js').FlagProps<string> & import('../index.js').CustomOptions & {
-            parse(input: any, opts: import('../index.js').ParameterOpts): string;
-        };
-        <const U extends import('../index.js').FlagProps<string> & Partial<import('../index.js').CustomOptions>>(overrides: U & Record<Exclude<keyof U, string>, never>): import('../index.js').FlagProps<string> & import('../index.js').CustomOptions & U & {
-            parse(input: any, opts: import('../index.js').ParameterOpts): string;
-        };
-    };
-    number: {
-        (): import('../index.js').FlagProps<number> & {
-            min?: number;
-            max?: number;
-        } & {
-            parse(input: any, opts: import('../index.js').ParameterOpts): number;
-        };
-        <const U extends import('../index.js').FlagProps<number> & Partial<{
-            min?: number;
-            max?: number;
-        }>>(overrides: U & Record<Exclude<keyof U, keyof import('../index.js').FlagProps<T> | "min" | "max">, never>): import('../index.js').FlagProps<number> & {
-            min?: number;
-            max?: number;
-        } & U & {
-            parse(input: any, opts: import('../index.js').ParameterOpts): number;
-        };
-    };
-    option: typeof optionFlag;
-    file: {
-        (): import('../index.js').FlagProps<string> & {
-            exists?: boolean;
-        } & {
-            parse(input: any, opts: import('../index.js').ParameterOpts): string;
-        };
-        <const U extends import('../index.js').FlagProps<string> & Partial<{
-            exists?: boolean;
-        }>>(overrides: U & Record<Exclude<keyof U, keyof import('../index.js').FlagProps<T> | "exists">, never>): import('../index.js').FlagProps<string> & {
-            exists?: boolean;
-        } & U & {
-            parse(input: any, opts: import('../index.js').ParameterOpts): string;
-        };
-    };
-    directory: {
-        (): import('../index.js').FlagProps<string> & {
-            exists?: boolean;
-        } & {
-            parse(input: any, opts: import('../index.js').ParameterOpts): string;
-        };
-        <const U extends import('../index.js').FlagProps<string> & Partial<{
-            exists?: boolean;
-        }>>(overrides: U & Record<Exclude<keyof U, keyof import('../index.js').FlagProps<T> | "exists">, never>): import('../index.js').FlagProps<string> & {
-            exists?: boolean;
-        } & U & {
-            parse(input: any, opts: import('../index.js').ParameterOpts): string;
-        };
-    };
-    url: {
-        (): import('../index.js').FlagProps<URL> & import('../index.js').CustomOptions & {
-            parse(input: any, opts: import('../index.js').ParameterOpts): URL;
-        };
-        <const U extends import('../index.js').FlagProps<URL> & Partial<import('../index.js').CustomOptions>>(overrides: U & Record<Exclude<keyof U, string>, never>): import('../index.js').FlagProps<URL> & import('../index.js').CustomOptions & U & {
-            parse(input: any, opts: import('../index.js').ParameterOpts): URL;
-        };
-    };
-    custom: typeof custom;
-};

package/dist/cjs/src/errors/BobError.d.ts

@@ -1,5 +0,0 @@
-import { Logger } from '../Logger.js';
-export declare abstract class BobError extends Error {
-    $type: "BobError";
-    abstract pretty(logger: Logger): void;
-}

package/dist/cjs/src/errors/CommandNotFoundError.d.ts

@@ -1,7 +0,0 @@
-import { Logger } from '../Logger.js';
-import { BobError } from './BobError.js';
-export declare class CommandNotFoundError extends BobError {
-    readonly command: string;
-    constructor(command: string);
-    pretty(logger: Logger): void;
-}

package/dist/cjs/src/errors/MissingRequiredArgumentValue.d.ts

@@ -1,7 +0,0 @@
-import { Logger } from '../Logger.js';
-import { BobError } from './BobError.js';
-export declare class MissingRequiredArgumentValue extends BobError {
-    readonly argument: string;
-    constructor(argument: string);
-    pretty(logger: Logger): void;
-}

package/dist/cjs/src/errors/MissingRequiredFlagValue.d.ts

@@ -1,7 +0,0 @@
-import { Logger } from '../Logger.js';
-import { BobError } from './BobError.js';
-export declare class MissingRequiredFlagValue extends BobError {
-    readonly flag: string;
-    constructor(flag: string);
-    pretty(logger: Logger): void;
-}

package/dist/cjs/src/errors/TooManyArguments.d.ts

@@ -1,8 +0,0 @@
-import { Logger } from '../Logger.js';
-import { BobError } from './BobError.js';
-export declare class TooManyArguments extends BobError {
-    readonly expected: number;
-    readonly received: number;
-    constructor(expected: number, received: number);
-    pretty(logger: Logger): void;
-}

package/dist/cjs/src/errors/ValidationError.d.ts

@@ -1,3 +0,0 @@
-export declare class ValidationError extends Error {
-    constructor(message: string);
-}

package/dist/cjs/src/flags/boolean.d.ts

@@ -1,9 +0,0 @@
-import { ParameterOpts } from '../lib/types.js';
-export declare const booleanFlag: {
-    (): import('../lib/types.js').FlagProps<boolean> & import('../lib/types.js').CustomOptions & {
-        parse(input: any, opts: ParameterOpts): boolean;
-    };
-    <const U extends import('../lib/types.js').FlagProps<boolean> & Partial<import('../lib/types.js').CustomOptions>>(overrides: U & Record<Exclude<keyof U, string>, never>): import('../lib/types.js').FlagProps<boolean> & import('../lib/types.js').CustomOptions & U & {
-        parse(input: any, opts: ParameterOpts): boolean;
-    };
-};

package/dist/cjs/src/flags/custom.d.ts

@@ -1,9 +0,0 @@
-import { CustomOptions, FlagProps, ParameterOpts } from '../lib/types.js';
-export declare function custom<T, P extends CustomOptions = CustomOptions>(defaults?: FlagProps<T> & Partial<P>): {
-    (): FlagProps<T> & P & {
-        parse(input: any, opts: ParameterOpts): T;
-    };
-    <const U extends FlagProps<T> & Partial<P>>(overrides: U & Record<Exclude<keyof U, keyof FlagProps<T> | keyof P>, never>): FlagProps<T> & P & U & {
-        parse(input: any, opts: ParameterOpts): T;
-    };
-};

package/dist/cjs/src/flags/directory.d.ts

@@ -1,14 +0,0 @@
-export declare const directoryFlag: {
-    (): import('../index.js').FlagProps<string> & {
-        exists?: boolean;
-    } & {
-        parse(input: any, opts: import('../index.js').ParameterOpts): string;
-    };
-    <const U extends import('../index.js').FlagProps<string> & Partial<{
-        exists?: boolean;
-    }>>(overrides: U & Record<Exclude<keyof U, keyof import('../index.js').FlagProps<T> | "exists">, never>): import('../index.js').FlagProps<string> & {
-        exists?: boolean;
-    } & U & {
-        parse(input: any, opts: import('../index.js').ParameterOpts): string;
-    };
-};

package/dist/cjs/src/flags/file.d.ts

@@ -1,14 +0,0 @@
-export declare const fileFlag: {
-    (): import('../index.js').FlagProps<string> & {
-        exists?: boolean;
-    } & {
-        parse(input: any, opts: import('../index.js').ParameterOpts): string;
-    };
-    <const U extends import('../index.js').FlagProps<string> & Partial<{
-        exists?: boolean;
-    }>>(overrides: U & Record<Exclude<keyof U, keyof import('../index.js').FlagProps<T> | "exists">, never>): import('../index.js').FlagProps<string> & {
-        exists?: boolean;
-    } & U & {
-        parse(input: any, opts: import('../index.js').ParameterOpts): string;
-    };
-};

package/dist/cjs/src/flags/helpers.d.ts

@@ -1,3 +0,0 @@
-import { FlagDefinition } from '../lib/types.js';
-export declare function formatPromptMessage(name: string, definition: FlagDefinition): string;
-export declare function normalizeAliases(alias: string | readonly string[] | undefined): readonly string[];