@breadc/core 1.0.0-beta.1

package/dist/index.d.mts

@@ -0,0 +1,696 @@
+//#region src/utils/types.d.ts
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type IsEqual<T, U> = (<G>() => G extends T ? 1 : 0) extends (<G>() => G extends U ? 1 : 0) ? true : false;
+type Lowercase = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+type Uppercase = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
+type Letter = Lowercase | Uppercase;
+//#endregion
+//#region src/breadc/types/infer.d.ts
+/**
+ * Infer option raw name
+ *
+ * Examples:
+ * + const t1: InferOptionRawName<'--option' | '--hello'> = 'hello'
+ * + const t2: InferOptionRawName<'-r, --root'> = 'root'
+ * + const t3: InferOptionRawName<'--page-index'> = 'page-index'
+ */
+type InferOptionRawName<S extends string> = S extends `-${Letter}, --no-${infer R} <${string}>` ? R : S extends `-${Letter}, --no-${infer R} [${string}]` ? R : S extends `-${Letter}, --no-${infer R}` ? R : S extends `-${Letter}, --${infer R} <${string}>` ? R : S extends `-${Letter}, --${infer R} [${string}]` ? R : S extends `-${Letter}, --${infer R}` ? R : S extends `--no-${string} <${string}>` ? never : S extends `--no-${string} [${string}]` ? never : S extends `--no-${infer R}` ? R : S extends `--${infer R} <${string}>` ? R : S extends `--${infer R} [${string}]` ? R : S extends `--${infer R}` ? R : string;
+/**
+ * Infer camel case option name
+ */
+type InferOptionName<T extends string> = InferOptionRawName<T> extends `${infer P1}-${infer P2}-${infer P3}` ? `${P1}${Capitalize<P2>}${Capitalize<P3>}` : InferOptionRawName<T> extends `${infer P1}-${infer P2}` ? `${P1}${Capitalize<P2>}` : InferOptionRawName<T>;
+/**
+ * Infer the raw option type: boolean or string or string[]
+ */
+type InferOptionRawType<S extends string> = S extends `-${Letter}, --${string} <${string}>` ? undefined | string : S extends `-${Letter}, --${string} [...${string}]` ? string[] : S extends `-${Letter}, --${string} [${string}]` ? false | true | string : S extends `-${Letter}, --${string}` ? boolean : S extends `--${string} <${string}>` ? undefined | string : S extends `--${string} [...${string}]` ? string[] : S extends `--${string} [${string}]` ? false | true | string : S extends `--${string}` ? boolean : undefined | boolean | string | string[];
+/**
+ * Infer the raw option type: boolean or string or string[]
+ */
+type InferOptionInitialType<S extends string> = S extends `-${Letter}, --${string} <${string}>` ? undefined | string : S extends `-${Letter}, --${string} [...${string}]` ? string[] : S extends `-${Letter}, --${string} [${string}]` ? string : S extends `-${Letter}, --${string}` ? boolean : S extends `--${string} <${string}>` ? undefined | string : S extends `--${string} [...${string}]` ? string[] : S extends `--${string} [${string}]` ? undefined | string : S extends `--${string}` ? boolean : boolean | string | string[];
+type NonTrueNullable<T> = IsEqual<T, false | true | string> extends true ? T & string & {} : T & {};
+/**
+ * Infer the option type with config
+ */
+type InferOptionType<S extends string, I extends InferOptionInitialType<S>, C extends OptionInit<S, I>> = C['default'] extends {} ? C['cast'] extends ((...args: any[]) => infer R) ? IsEqual<R, C['default']> extends true ? R : never : C['default'] | (C['initial'] extends {} ? C['initial'] | NonTrueNullable<InferOptionRawType<S>> : NonTrueNullable<InferOptionRawType<S>>) : C['cast'] extends ((...args: any[]) => infer R) ? R : C['initial'] extends {} ? C['initial'] | NonTrueNullable<InferOptionRawType<S>> : InferOptionRawType<S>;
+/**
+ * Infer option information
+ */
+type InferOption<S extends string, I extends InferOptionInitialType<S>, C extends OptionInit<S, I, unknown>> = { [k in InferOptionName<S>]: InferOptionType<S, I, C> };
+/**
+ * Infer the raw argument type: required or optional or spread
+ */
+type InferArgumentRawType<S extends string> = S extends `<${string}>` ? string : S extends `[...${string}]` ? string[] : S extends `[${string}]` ? undefined | string : undefined | string | string[];
+/**
+ * Infer the argument type with config
+ */
+type InferArgumentType<S extends string, I extends InferArgumentRawType<S>, C extends ArgumentInit<S, I, unknown> | NonNullableArgumentInit<S, NonNullable<I>, unknown>> = C['default'] extends {} ? C['cast'] extends ((...args: any[]) => infer R) ? IsEqual<R, C['default']> extends true ? R : never : C['default'] | (C['initial'] extends {} ? C['initial'] | NonNullable<InferArgumentRawType<S>> : NonNullable<InferArgumentRawType<S>>) : C['cast'] extends ((...args: any[]) => infer R) ? R : C['initial'] extends {} ? C['initial'] | NonNullable<InferArgumentRawType<S>> : InferArgumentRawType<S>;
+/**
+ * Infer the arguments type
+ */
+type InferArgumentsType<S extends string> = S extends `<${string}> ${infer U}` ? [string, ...InferArgumentsType1<U>] : S extends `[...${string}] ${string}` ? never : S extends `[${string}] ${infer U}` ? [undefined | string, ...InferArgumentsType2<U>] : S extends `${string} ${infer U}` ? InferArgumentsType<U> : S extends `<${string}>` ? [string] : S extends `[...${string}]` ? [string[]] : S extends `[${string}]` ? [undefined | string] : [];
+type InferArgumentsType1<S extends string> = S extends `<${string}> ${infer U}` ? [string, ...InferArgumentsType<U>] : S extends `[...${string}] ${string}` ? never : S extends `[${string}] ${infer U}` ? [undefined | string, ...InferArgumentsType2<U>] : S extends `${string} ${string}` ? never : S extends `<${string}>` ? [string] : S extends `[...${string}]` ? [string[]] : S extends `[${string}]` ? [undefined | string] : S extends `${string}` ? never : [];
+type InferArgumentsType2<S extends string> = S extends `<${string}> ${string}` ? never : S extends `[...${string}] ${string}` ? never : S extends `[${string}] ${infer U}` ? [undefined | string, ...InferArgumentsType2<U>] : S extends `${string} ${string}` ? never : S extends `<${string}>` ? never : S extends `[...${string}]` ? [string[]] : S extends `[${string}]` ? [undefined | string] : S extends `${string}` ? never : [];
+//#endregion
+//#region src/breadc/types/init.d.ts
+type BreadcInit = {
+  /**
+   * CLI app version
+   */
+  version?: string;
+  /**
+   * CLI app description
+   */
+  description?: string;
+  /**
+   * I18n language or custom i18n function
+   *
+   * @default 'en'
+   */
+  /**
+   * Logger
+   */
+  /**
+   * Builtin command configuration
+   */
+  builtin?: {
+    version?: boolean | {
+      /**
+       * @default '-v, --version'
+       */
+      spec?: string;
+      /**
+       *
+       */
+      description?: string;
+    };
+    help?: boolean | {
+      /**
+       * @default '-h, --help'
+       */
+      spec?: string;
+      /**
+       *
+       */
+      description?: string;
+    };
+  };
+};
+type OptionInit<Spec extends string, Initial extends InferOptionInitialType<Spec>, Cast extends unknown = unknown> = {
+  /**
+   * Option description
+   */
+  description?: string;
+  /**
+   * Generate negated option
+   */
+  negated?: boolean;
+  /**
+   * Overwrite the initial value of the corresponding matched option.
+   * - &lt;required&gt;: undefined
+   * - \[optional\]: false
+   * - \[...remaining\]: \[\]
+   */
+  initial?: Initial;
+  /**
+   * Cast initial value to the result
+   */
+  cast?: (value: Initial extends {} ? Initial : InferOptionRawType<Spec>) => Cast;
+  /**
+   * Default option value if it is not provided
+   */
+  default?: Cast;
+};
+type NonNullableOptionInit<Spec extends string, Initial extends NonTrueNullable<InferOptionInitialType<Spec>>, Cast extends unknown = unknown> = {
+  /**
+   * Option description
+   */
+  description?: string;
+  /**
+   * Generate corresponding negated option
+   *
+   * @default false
+   */
+  negated?: InferOptionRawType<Spec> extends boolean ? boolean : never;
+  /**
+   * Overwrite the initial value of the corresponding matched option.
+   * - `--option`: `false`
+   * - `--option [optional]`: `false`
+   * - `--option <required>`: `undefined`
+   * - `--option [...spread]`: `[]`
+   */
+  initial: Initial;
+  /**
+   * Cast initial value to the result
+   */
+  cast?: (value: Initial extends {} ? Initial : InferOptionRawType<Spec>) => Cast;
+  /**
+   * Default option value when its value or initial value is not provided
+   */
+  default?: Cast;
+};
+type GroupInit<Spec extends string> = {};
+type CommandInit<Spec extends string> = {};
+type ArgumentInit<Spec extends string, Initial extends InferArgumentRawType<Spec>, Cast extends unknown = unknown> = {
+  /**
+   * Overwrite the initial value of the corresponding matched option.
+   * - &lt;required&gt; : undefined
+   * - \[optional\] : undefined
+   * - \[...remaining\] : \[\]
+   */
+  initial?: Initial;
+  /**
+   * Cast initial value to the result
+   */
+  cast?: (value: Initial extends {} ? Initial : InferArgumentRawType<Spec>) => Cast;
+  /**
+   * Default argument value if it is not provided
+   */
+  default?: Cast;
+};
+type NonNullableArgumentInit<Spec extends string, Initial extends NonNullable<InferArgumentRawType<Spec>>, Cast extends unknown = unknown> = {
+  /**
+   * Overwrite the initial value of the corresponding matched option.
+   * - &lt;required&gt; : undefined
+   * - \[optional\] : undefined
+   * - \[...remaining\] : \[\]
+   */
+  initial: Initial;
+  /**
+   * Cast initial value to the result
+   */
+  cast?: (value: Initial extends {} ? Initial : InferArgumentRawType<Spec>) => Cast;
+  /**
+   * Default argument value if it is not provided
+   */
+  default?: Cast;
+};
+//#endregion
+//#region src/breadc/types/middleware.d.ts
+/**
+ * Unknown command middleware
+ *
+ * @public
+ */
+type UnknownCommandMiddleware<Data extends {} = {}> = (context: Context<Data>) => Promise<any> | any;
+/**
+ * Unknown option middleware
+ *
+ * @public
+ */
+type UnknownOptionMiddleware<Data extends {} = {}> = (context: Context<Data>, key: string, value: string | undefined) => MatchedUnknownOption | null | undefined;
+interface ActionMiddlewareNextFn {
+  <NextData extends {} = {}>(nextContextData?: {
+    data?: NextData;
+  }): Promise<Context<NextData>>;
+}
+type InferMiddlewareNextFn<Fn extends ActionMiddlewareNextFn> = Awaited<ReturnType<Fn>>['data'];
+/**
+ * Command action middleware
+ *
+ * @public
+ */
+type ActionMiddleware<Data extends {} = {}, NextFn extends ActionMiddlewareNextFn = ActionMiddlewareNextFn> = (context: Context<Data>, next: NextFn) => Promise<Context<InferMiddlewareNextFn<NextFn>>>;
+type InferMiddlewareData<Middleware extends ActionMiddleware<any, ActionMiddlewareNextFn>> = Awaited<ReturnType<Middleware>>['data'];
+//#endregion
+//#region src/breadc/types/internal.d.ts
+/**
+ * @internal
+ */
+type InternalBreadc = Breadc<any, any> & {
+  /**
+   * @internal
+   */
+  _init: BreadcInit;
+  /**
+   * @internal
+   */
+  _commands: (InternalCommand | InternalGroup)[];
+  /**
+   * @internal
+   */
+  _version?: InternalOption;
+  /**
+   * @internal
+   */
+  _help?: InternalOption;
+  /**
+   * @internal
+   */
+  _options: InternalOption[];
+  /**
+   * @internal
+   */
+  _actionMiddlewares: ActionMiddleware<any, any>[];
+  /**
+   * @internal
+   */
+  _unknownCommandMiddlewares: UnknownCommandMiddleware<any>[];
+  /**
+   * @internal
+   */
+  _unknownOptionMiddlewares: UnknownOptionMiddleware<any>[];
+};
+type InternalGroup = Group<string, GroupInit<string>, any, any> & {
+  /**
+   * Mark whether it is a default command
+   *
+   * @internal
+   */
+  _default?: false;
+  /**
+   * It is lazy built when running
+   *
+   * @internal
+   */
+  _pieces: [string[]];
+  /**
+   * @internal
+   */
+  _commands: InternalCommand[];
+  /**
+   * @internal
+   */
+  _options: InternalOption[];
+  /**
+   * @internal
+   */
+  _actionMiddlewares?: ActionMiddleware[];
+  /**
+   * @internal
+   */
+  _unknownOptionMiddlewares?: UnknownOptionMiddleware<any>[];
+};
+type InternalCommand = Command & {
+  /**
+   * @internal
+   */
+  _group?: InternalGroup;
+  /**
+   * @internal
+   */
+  _aliases: string[];
+  /**
+   * Mark whether it is a default command
+   *
+   * @internal
+   */
+  _default?: boolean;
+  /**
+   * @internal
+   */
+  _pieces: string[][];
+  /**
+   * It is lazy built when running
+   *
+   * @internal
+   */
+  _arguments: InternalArgument[];
+  /**
+   * @internal
+   */
+  _options: InternalOption[];
+  /**
+   * @internal
+   */
+  _actionMiddlewares?: ActionMiddleware<any, any>[];
+  /**
+   * @internal
+   */
+  _unknownOptionMiddlewares?: UnknownOptionMiddleware<any>[];
+  /**
+   * @internal
+   */
+  _actionFn?: Function;
+};
+type OptionType = 'boolean' | 'required' | 'optional' | 'spread';
+type InternalOption = Option & {
+  type: OptionType;
+  long: string;
+  short?: string | undefined;
+  argument?: string | undefined;
+};
+type ArgumentType = 'required' | 'optional' | 'spread';
+type InternalArgument = Argument & {
+  type: ArgumentType;
+};
+//#endregion
+//#region src/runtime/lexer.d.ts
+declare class TokenStream {
+  private readonly args;
+  private readonly tokens;
+  private cursor;
+  constructor(args: string[]);
+  reset(): this;
+  /**
+   * Get the current arg token and advance the cursor
+   *
+   * @returns next arg
+   */
+  next(): Token | undefined;
+  /**
+   * Move the cursor to preivous position
+   */
+  prev(): void;
+  /**
+   * Peek the next arg and does not advance the cursor
+   *
+   * @returns next arg
+   */
+  peek(): Token | undefined;
+  /**
+   * Return all remaining raw arguments, advancing the cursor to the end
+   *
+   * @returns all remaining raw arguments
+   */
+  remaining(): Token[];
+  /**
+   * Return whether has consumed all the args
+   *
+   * @returns whether has consumed all the args
+   */
+  get isEnd(): boolean;
+  [Symbol.iterator](): Generator<Token, void, unknown>;
+}
+declare class Token {
+  readonly text: string;
+  constructor(arg: string);
+  /**
+   * @returns raw arg string
+   */
+  toRaw(): string;
+  /**
+   * @returns whether arg is empty
+   */
+  get isEmpty(): boolean;
+  /**
+   * @returns whether arg looks like a stdio argument (`-`)
+   */
+  get isStdio(): boolean;
+  /**
+   * @returns whether arg looks like an argument escape (`--`)
+   */
+  get isEscape(): boolean;
+  /**
+   * @returns whether arg looks like a negative number (`-123`)
+   */
+  get isNegativeNumber(): boolean;
+  /**
+   * @returns whether arg looks like a number (`123`, `-123`)
+   */
+  get isNumber(): boolean;
+  /**
+   * @returns whether arg can treat as a long-flag
+   */
+  get isLong(): boolean;
+  /**
+   * Treat as a long-flag, un-checked version
+   *
+   * @returns a long flag and its argument
+   */
+  toLong(): [key: string, value: string | undefined];
+  /**
+   * Treat as a long-flag, checked version
+   *
+   * @returns a long flag and its argument
+   */
+  checkToLong(): [key: string, value: string | undefined] | undefined;
+  /**
+   * @returns whether arg can treat as a long-flag
+   */
+  get isShort(): boolean;
+  /**
+   * Treat as a short-flag, un-checked version
+   *
+   * @returns a short flag and its argument
+   */
+  toShort(): [key: string, value: string | undefined];
+  /**
+   * Treat as a short-flag, checked version
+   *
+   * @returns a short flag and its argument
+   */
+  checkToShort(): [key: string, value: string | undefined] | undefined;
+  get length(): number;
+  toString(): string;
+  [Symbol.iterator](): StringIterator<string>;
+}
+//#endregion
+//#region src/runtime/matched.d.ts
+declare class MatchedArgument {
+  readonly argument: InternalArgument;
+  readonly token: Token | undefined;
+  dirty: boolean;
+  raw: string | string[] | undefined;
+  constructor(argument: Argument<string, any, any> | InternalArgument);
+  value<T = any>(): T;
+  accept(_context: Context, value: string | string[] | undefined): this;
+}
+declare class MatchedOption {
+  readonly option: InternalOption;
+  dirty: boolean;
+  raw: any;
+  constructor(option: Option<string, any, any> | InternalOption);
+  value<T = any>(): T;
+  accept(context: Context, long: string, text: string | undefined): this;
+}
+interface MatchedUnknownOption<T = any> {
+  name: string;
+  type?: OptionType;
+  value: T;
+}
+//#endregion
+//#region src/runtime/context.d.ts
+type Context<Data extends {} = {}> = {
+  /**
+   * Data used in the command action
+   */
+  data: Data;
+  /**
+   * Output of the command action
+   */
+  output?: any;
+  /**
+   * Matched commands or groups, sorted by appearance order
+   */
+  group?: InternalGroup;
+  /**
+   * Matched command
+   */
+  command?: InternalCommand;
+  /**
+   * Match command pieces
+   */
+  readonly pieces: string[];
+  /**
+   * Matched options
+   */
+  readonly options: Map<string, MatchedOption>;
+  /**
+   * Matched arguments
+   */
+  readonly arguments: MatchedArgument[];
+  /**
+   * Remaing arguments
+   */
+  readonly remaining: string[];
+  /**
+   * Breadc app instance
+   */
+  readonly breadc: InternalBreadc;
+  /**
+   * Input token stream
+   */
+  readonly tokens: TokenStream;
+};
+//#endregion
+//#region src/breadc/types/app.d.ts
+/**
+ * @public
+ */
+type Breadc<Data extends {} = {}, Options extends Record<never, never> = {}> = {
+  name: string;
+  version: string | undefined;
+  group<GS extends string, G extends Group<GS>>(group: G): G;
+  group<GS extends string, GI extends GroupInit<GS>>(spec: GS, description?: string, init?: GI): Group<GS, GI, Data, Options>;
+  /**
+   * Add option
+   *
+   * @param spec
+   * @param init
+   */
+  option<Opt extends Option<any, any, any>>(option: Opt): Breadc<Data, Options & InferOptionFromInstance<Opt>>;
+  option<OS extends string, Initial extends NonTrueNullable<InferOptionInitialType<OS>>, OI extends NonNullableOptionInit<OS, Initial>>(spec: OS, description: string, init: OI): Breadc<Data, Options & InferOption<OS, Initial, OI>>;
+  option<OS extends string, Initial extends InferOptionInitialType<OS>, OI extends OptionInit<OS, Initial>>(spec: OS, description?: string, init?: OI): Breadc<Data, Options & InferOption<OS, Initial, OI>>;
+  command<S extends string, I extends CommandInit<S>>(spec: S, description?: string, init?: I): Command<S, I, Data, Options, InferArgumentsType<S>, unknown>;
+  command<S extends string, I extends CommandInit<S>>(command: Command<S, I, Data, Options>): Command<S, I, Data, Options, InferArgumentsType<S>, unknown>;
+  /**
+   * Action middleware
+   */
+  use<Middleware extends ActionMiddleware<Data, ActionMiddlewareNextFn>>(middleware: Middleware): Breadc<InferMiddlewareData<Middleware>, Options>;
+  /**
+   * Allow unknown option middleware
+   */
+  onUnknownCommand(middleware?: boolean | UnknownCommandMiddleware<Data>): Breadc<Data, Options>;
+  /**
+   * Allow unknown option middleware
+   */
+  allowUnknownOption(middleware?: UnknownOptionMiddleware<Data>): Breadc<Data, Options>;
+  /**
+   * Parse CLI options
+   *
+   * @param argv CLI arguments
+   */
+  parse<PArgs extends any[] = any[], POpts extends Record<string, any> = {}>(argv: string[]): {
+    args: PArgs;
+    options: Prettify<Options & POpts>;
+    '--': string[];
+    context: Context<Data>;
+  };
+  /**
+   * Parse and run corresponding command actions
+   *
+   * @param argv CLI arguments
+   */
+  run<T>(argv: string[]): Promise<T>;
+};
+type Group<Spec extends string = string, Init extends GroupInit<Spec> = GroupInit<Spec>, Data extends {} = {}, Options extends Record<never, never> = Record<never, never>> = {
+  spec: Spec;
+  init: Init | undefined;
+  /**
+   * Add option
+   *
+   * @param spec
+   * @param init
+   */
+  option<Opt extends Option<any, any, any>>(option: Opt): Group<Spec, Init, Data, Options & InferOptionFromInstance<Opt>>;
+  option<OS extends string, Initial extends NonTrueNullable<InferOptionInitialType<OS>>, OI extends NonNullableOptionInit<OS, Initial>>(spec: OS, description: string, init: OI): Group<Spec, Init, Data, Options & InferOption<OS, Initial, OI>>;
+  option<OS extends string, Initial extends InferOptionInitialType<OS>, OI extends OptionInit<OS, Initial>>(spec: OS, description?: string, init?: OI): Group<Spec, Init, Data, Options & InferOption<OS, Initial, OI>>;
+  command<S extends string, I extends CommandInit<S>>(spec: S, description?: string, init?: I): Command<S, I, Data, Options, InferArgumentsType<S>, unknown>;
+  command<S extends string, I extends CommandInit<S>>(command: Command<S, I, Options>): Command<S, I, Data, Options, InferArgumentsType<S>, unknown>;
+  /**
+   * Action middleware
+   */
+  use<Middleware extends ActionMiddleware<Data>>(middleware: Middleware): Group<Spec, Init, InferMiddlewareData<Middleware>, Options>;
+  /**
+   * Allow unknown options middleware
+   */
+  allowUnknownOption(middleware?: UnknownOptionMiddleware<Data>): Group<Spec, Init, Data, Options>;
+};
+type Command<Spec extends string = string, Init extends CommandInit<Spec> = CommandInit<Spec>, Data extends {} = {}, Options extends Record<never, never> = {}, Arguments extends unknown[] = InferArgumentsType<Spec>, Return extends unknown = unknown> = {
+  spec: Spec;
+  init: Init | undefined;
+  /**
+   * Alias command
+   *
+   * @param spec
+   */
+  alias(spec: string): Command<Spec, Init, Data, Options, Arguments, Return>;
+  /**
+   * Add option
+   *
+   * @param spec
+   * @param init
+   */
+  option<Opt extends Option<any, any, any>>(option: Opt): Command<Spec, Init, Data, Options & InferOptionFromInstance<Opt>, Arguments, Return>;
+  option<OS extends string, Initial extends NonTrueNullable<InferOptionInitialType<OS>>, OI extends NonNullableOptionInit<OS, Initial>>(spec: OS, description: string, init: OI): Command<Spec, Init, Data, Options & InferOption<OS, Initial, OI>, Arguments, Return>;
+  option<OS extends string, Initial extends InferOptionInitialType<OS>, OI extends OptionInit<OS, Initial>>(spec: OS, description?: string, init?: OI): Command<Spec, Init, Data, Options & InferOption<OS, Initial, OI>, Arguments, Return>;
+  /**
+   * Add argument
+   */
+  argument<AS extends string, Initial extends InferArgumentRawType<AS>, Cast extends unknown, AI extends ArgumentInit<AS, Initial, Cast>>(argument: Argument<AS, Initial, Cast, AI>): Command<Spec, Init, Data, Options, [...Arguments, InferArgumentType<AS, Initial, AI>], Return>;
+  argument<AS extends string, Initial extends NonNullable<InferArgumentRawType<AS>>, Cast extends unknown, AI extends NonNullableArgumentInit<AS, Initial, Cast>>(spec: AS, init: AI): Command<Spec, Init, Data, Options, [...Arguments, InferArgumentType<AS, Initial, AI>], Return>;
+  argument<AS extends string, Initial extends InferArgumentRawType<AS>, Cast extends unknown, AI extends ArgumentInit<AS, Initial, Cast>>(spec: AS, init?: AI): Command<Spec, Init, Data, Options, [...Arguments, InferArgumentType<AS, Initial, AI>], Return>;
+  /**
+   * Action middleware
+   */
+  use<Middleware extends ActionMiddleware<Data>>(middleware: Middleware): Command<Spec, Init, InferMiddlewareData<Middleware>, Options, Arguments, Return>;
+  /**
+   * Allow unknown options middleware
+   */
+  allowUnknownOption(middleware?: UnknownOptionMiddleware<Data>): Command<Spec, Init, Data, Options, Arguments, Return>;
+  /**
+   * Bind action function
+   */
+  action<R extends unknown>(fn: (...args: [...Arguments, Prettify<Options & {
+    '--': string[];
+  }>]) => Promise<R> | R): Command<Spec, Init, Data, Options, Arguments, R>;
+  /**
+   * Run command directly
+   */
+  (...args: [...Arguments, Prettify<Options & {
+    '--': string[];
+  }>]): Promise<Return>;
+};
+type Option<Spec extends string = string, Initial extends InferOptionInitialType<Spec> = InferOptionInitialType<Spec>, Init extends OptionInit<Spec, Initial> = OptionInit<Spec, Initial>> = {
+  spec: Spec;
+  init: Init;
+};
+type InferOptionFromInstance<Opt extends Option<any, any, any>> = Opt extends Option<infer OS, infer Initial, infer OI> ? InferOption<OS, Initial, OI & {}> : never;
+type Argument<Spec extends string = string, Initial extends InferArgumentRawType<Spec> = InferArgumentRawType<Spec>, Cast extends unknown = unknown, Init extends ArgumentInit<Spec, Initial, Cast> = ArgumentInit<Spec, Initial, Cast>> = {
+  spec: Spec;
+  type: ArgumentType;
+  name: string;
+  init: Init | undefined;
+};
+//#endregion
+//#region src/breadc/app.d.ts
+declare function breadc(name: string, init?: BreadcInit): Breadc;
+//#endregion
+//#region src/breadc/group.d.ts
+declare function group<S extends string, I extends GroupInit<S>>(spec: S, init?: I): Group<S, I, {}, {}>;
+//#endregion
+//#region src/breadc/option.d.ts
+declare function option<Spec extends string, Initial extends InferOptionInitialType<Spec>, Init extends OptionInit<Spec, Initial, unknown>>(spec: Spec, description?: string, init?: Init): Option<Spec, Initial, Init>;
+//#endregion
+//#region src/breadc/command.d.ts
+declare function command<S extends string, I extends CommandInit<S>>(spec: S, init?: I): Command<S, I, {}, {}, InferArgumentsType<S>, unknown>;
+declare function argument<Spec extends string, Initial extends NonNullable<InferArgumentRawType<Spec>>, Cast extends unknown, Init extends NonNullableArgumentInit<Spec, Initial, Cast>>(spec: Spec, init: Init): Argument<Spec, Initial, Cast, Init>;
+declare function argument<Spec extends string, Initial extends InferArgumentRawType<Spec>, Cast extends unknown, Init extends ArgumentInit<Spec, Initial, Cast>>(spec: Spec, init?: Init): Argument<Spec, Initial, Cast, Init>;
+//#endregion
+//#region src/error.d.ts
+declare abstract class BreadcError extends Error {}
+declare class BreadcAppError extends BreadcError {
+  static DUPLICATED_DEFAULT_COMMAND: string;
+  static DUPLICATED_COMMAND: string;
+  static NO_ACTION_BOUND: string;
+  cause: {
+    command?: InternalCommand;
+    commands?: (InternalCommand | InternalGroup)[];
+  };
+  constructor(message: string, cause: BreadcAppError['cause']);
+}
+declare class ResolveGroupError extends BreadcError {
+  static EMPTY: string;
+  static INVALID_ARG_IN_GROUP: string;
+  cause: {
+    spec: string;
+    position: number;
+  };
+  constructor(message: string, cause: ResolveGroupError['cause']);
+}
+declare class ResolveCommandError extends BreadcError {
+  static INVALID_ARG: string;
+  static INVALID_EMPTY_ARG: string;
+  static INVALID_REQUIRED_ARG: string;
+  static INVALID_OPTIONAL_ARG: string;
+  static INVALID_SPREAD_ARG: string;
+  static INVALID_ALIAS_FORMAT: string;
+  static PIECE_BEFORE_REQUIRED: string;
+  static REQUIRED_BEFORE_OPTIONAL: string;
+  static OPTIONAL_BEFORE_SPREAD: string;
+  static SPREAD_ONLY_ONCE: string;
+  cause: {
+    spec: string;
+    position: number;
+  };
+  constructor(message: string, cause: ResolveCommandError['cause']);
+}
+declare class ResolveOptionError extends BreadcError {
+  static INVALID_OPTION: string;
+  cause: {
+    spec: string;
+  };
+  constructor(message: string, cause: ResolveOptionError['cause']);
+}
+//#endregion
+export { type ActionMiddleware, type Argument, type ArgumentInit, type Breadc, BreadcAppError, BreadcError, type BreadcInit, type Command, type CommandInit, type Context, type Group, type GroupInit, MatchedArgument, MatchedOption, type MatchedUnknownOption, type Option, type OptionInit, ResolveCommandError, ResolveGroupError, ResolveOptionError, type UnknownCommandMiddleware, type UnknownOptionMiddleware, argument, breadc, command, group, option };