@clerc/core 0.43.0 → 1.0.0-beta.1

package/dist/index.d.ts

@@ -1,481 +1,252 @@
-import { Equals, Dict, CamelCase, MaybeArray as MaybeArray$1 } from '@clerc/utils';
-import { OmitIndexSignature, LiteralUnion, Simplify } from 'type-fest';
+import { ErrorHandler as ErrorHandler$1 } from "lite-emit";
 
-declare const DOUBLE_DASH = "--";
-type TypeFunction<ReturnType = any> = (value: any) => ReturnType;
-type TypeFunctionArray<ReturnType> = readonly [TypeFunction<ReturnType>];
-type FlagType<ReturnType = any> = TypeFunction<ReturnType> | TypeFunctionArray<ReturnType>;
-type FlagSchemaBase<TF> = {
-    /**
-     * Type of the flag as a function that parses the argv string and returns the
-     * parsed value.
-     *
-     * @example
-     *
-     * ```
-     * type: String;
-     * ```
-     *
-     * @example Wrap in an array to accept multiple values. `type: [Boolean]`
-     *
-     * @example Custom function type that uses moment.js to parse string as date.
-     * `type: function CustomDate(value: string) { return moment(value).toDate();
-     * }`
-     */
-    type: TF;
-    /**
-     * A single-character alias for the flag.
-     *
-     * @example
-     *
-     * ```
-     * alias: "s";
-     * ```
-     */
-    alias?: string;
-} & Record<PropertyKey, unknown>;
-type FlagSchemaDefault<TF, DefaultType = any> = FlagSchemaBase<TF> & {
-    /**
-     * Default value of the flag. Also accepts a function that returns the default
-     * value. [Default: undefined]
-     *
-     * @example
-     *
-     * ```
-     * default: 'hello'
-     * ```
-     *
-     * @example
-     *
-     * ```
-     * default: () => [1, 2, 3]
-     * ```
-     */
-    default: DefaultType | (() => DefaultType);
-};
-type FlagSchema<TF = FlagType> = FlagSchemaBase<TF> | FlagSchemaDefault<TF>;
-type FlagTypeOrSchema<ExtraOptions = Record<string, unknown>> = FlagType | (FlagSchema & ExtraOptions);
-type Flags$1<ExtraOptions = Record<string, unknown>> = Record<string, FlagTypeOrSchema<ExtraOptions>>;
-type InferFlagType<Flag extends FlagTypeOrSchema> = Flag extends TypeFunctionArray<infer T> | FlagSchema<TypeFunctionArray<infer T>> ? Flag extends FlagSchemaDefault<TypeFunctionArray<T>, infer D> ? T[] | D : T[] : Flag extends TypeFunction<infer T> | FlagSchema<TypeFunction<infer T>> ? Flag extends FlagSchemaDefault<TypeFunction<T>, infer D> ? T | D : T | undefined : never;
-interface ParsedFlags<Schemas = Record<string, unknown>> {
-    flags: Schemas;
-    unknownFlags: Record<string, (string | boolean)[]>;
-    _: string[] & {
-        [DOUBLE_DASH]: string[];
-    };
-}
-type TypeFlag<Schemas extends Flags$1> = ParsedFlags<{
-    [flag in keyof Schemas]: InferFlagType<Schemas[flag]>;
-}>;
-
-type StripBrackets<Parameter extends string> = Parameter extends `<${infer ParameterName}>` | `[${infer ParameterName}]` ? ParameterName extends `${infer SpreadName}...` ? SpreadName : ParameterName : never;
-type ParameterType<Parameter extends string> = Parameter extends `<${infer _ParameterName}...>` | `[${infer _ParameterName}...]` ? string[] : Parameter extends `<${infer _ParameterName}>` ? string : Parameter extends `[${infer _ParameterName}]` ? string | undefined : never;
-type NonNullableParameters<T extends string[] | undefined> = T extends undefined ? [] : NonNullable<T>;
-type TransformParameters<C extends Command> = {
-    [Parameter in NonNullableParameters<C["parameters"]>[number] as CamelCase<StripBrackets<Parameter>>]: ParameterType<Parameter>;
-};
-type MakeEventMap<T extends Commands> = {
-    [K in keyof T]: [InterceptorContext];
-};
-type FallbackFlags<F extends Flags | undefined> = Equals<NonNullableFlag<F>["flags"], {}> extends true ? Dict<any> : NonNullableFlag<F>["flags"];
-type NonNullableFlag<F extends Flags | undefined> = TypeFlag<NonNullable<F>>;
-type ParseFlag<C extends Commands, N extends keyof C, GF extends GlobalFlagOptions = {}> = N extends keyof C ? OmitIndexSignature<NonNullableFlag<C[N]["flags"] & GF>["flags"]> : FallbackFlags<C[N]["flags"] & GF>["flags"];
-type ParseRaw<C extends Command, GF extends GlobalFlagOptions = {}> = NonNullableFlag<C["flags"] & GF> & {
-    flags: FallbackFlags<C["flags"] & GF>;
-    parameters: string[];
-    mergedFlags: FallbackFlags<C["flags"] & GF> & NonNullableFlag<C["flags"] & GF>["unknownFlags"];
-};
-type ParseParameters<C extends Commands = Commands, N extends keyof C = keyof C> = Equals<TransformParameters<C[N]>, {}> extends true ? N extends keyof C ? TransformParameters<C[N]> : Dict<string | string[] | undefined> : TransformParameters<C[N]>;
-
-type Locales = Dict<Dict<string>>;
-type TranslateFn = (name: string, ...args: string[]) => string | undefined;
-interface I18N {
-    add: (locales: Locales) => void;
-    t: TranslateFn;
-}
-
-interface Plugin<T extends Clerc = Clerc, U extends Clerc = Clerc> {
-    setup: (cli: T) => U;
+//#region ../utils/src/types/type-fest.d.ts
+type LiteralUnion<LiteralType, BaseType> = LiteralType | (BaseType & Record<never, never>);
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+type BuiltIns = Primitive | void | Date | RegExp;
+type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown) | Promise<unknown>;
+type UnknownArray = readonly unknown[];
+type MapsSetsOrArrays = ReadonlyMap<unknown, unknown> | WeakMap<WeakKey, unknown> | ReadonlySet<unknown> | WeakSet<WeakKey> | UnknownArray;
+type ConditionalDeepPrettify<T, E = never, I$1 = unknown> = T extends E ? T : T extends I$1 ? { [TypeKey in keyof T]: ConditionalDeepPrettify<T[TypeKey], E, I$1> } : T;
+type DeepPrettify<T, E = never> = ConditionalDeepPrettify<T, E | NonRecursiveType | MapsSetsOrArrays, object>;
+//#endregion
+//#region ../utils/src/types/index.d.ts
+type MaybeArray<T> = T | T[];
+type PartialRequired<T, K$1 extends keyof T> = T & { [P in K$1]-?: T[P] };
+type UnionToIntersection<U$1> = (U$1 extends any ? (k: U$1) => void : never) extends ((k: infer I) => void) ? I : never;
+//#endregion
+//#region ../parser/src/types.d.ts
+type FlagDefaultValue<T = unknown> = T | (() => T);
+/**
+* Defines how a string input is converted to the target type T.
+*
+* @template T The target type.
+*/
+type FlagTypeFunction<T = unknown> = (value: string) => T;
+/**
+* A callback function to conditionally stop parsing.
+* When it returns true, parsing stops and remaining arguments are preserved in `ignored`.
+*
+* @param type - The type of the current argument: 'known-flag' or 'unknown-flag' for flags, 'parameter' for positional arguments
+* @param arg - The current argument being processed
+* @returns true to stop parsing, false to continue
+*/
+type IgnoreFunction = (type: typeof KNOWN_FLAG | typeof UNKNOWN_FLAG | typeof PARAMETER, arg: string) => boolean;
+type FlagType<T = unknown> = FlagTypeFunction<T> | readonly [FlagTypeFunction<T>];
+interface BaseFlagOptions<T extends FlagType = FlagType> {
+  /**
+  * The type constructor or a function to convert the string value.
+  * To support multiple occurrences of a flag (e.g., --file a --file b), wrap the type in an array: [String], [Number].
+  * e.g., String, Number, [String], (val) => val.split(',')
+  */
+  type: T;
+  /** Aliases for the flag. */
+  alias?: MaybeArray<string>;
+  /** The default value of the flag. */
+  default?: unknown;
+}
+type FlagOptions = (BaseFlagOptions<BooleanConstructor> & {
+  /**
+  * Whether to enable the `--no-<flag>` syntax to set the value to false.
+  * Only useful for boolean flags.
+  * When set on a non-boolean flag, a type error will be shown.
+  *
+  * @default true
+  */
+  negatable?: boolean;
+}) | (BaseFlagOptions & {
+  negatable?: never;
+});
+type FlagDefinitionValue = FlagOptions | FlagType;
+type FlagsDefinition = Record<string, FlagDefinitionValue>;
+type RawInputType = string | boolean;
+interface ObjectInputType {
+  [key: string]: RawInputType | ObjectInputType;
 }
-
-type CommandType = RootType | string;
-type FlagOptions = FlagSchema & {
-    description: string;
+/**
+* The parsed result.
+* @template TFlags The specific flags type inferred from ParserOptions.
+*/
+interface ParsedResult<TFlags extends Record<string, any>> {
+  /** Positional arguments or commands. */
+  parameters: string[];
+  /** Arguments after the `--` delimiter. */
+  doubleDash: string[];
+  /**
+  * The parsed flags.
+  * This is a strongly-typed object whose structure is inferred from the `flags` configuration in ParserOptions.
+  */
+  flags: TFlags;
+  /** The raw command-line arguments. */
+  raw: string[];
+  /** Unknown flags encountered during parsing. */
+  unknown: Record<string, RawInputType>;
+  /** Arguments that were not parsed due to ignore callback. */
+  ignored: string[];
+}
+type InferFlagDefault<T extends FlagDefinitionValue, Fallback> = T extends {
+  default: FlagDefaultValue<infer DefaultType>;
+} ? DefaultType : Fallback;
+type _InferFlags<T extends FlagsDefinition> = { [K in keyof T]: T[K] extends readonly [BooleanConstructor] | {
+  type: readonly [BooleanConstructor];
+} ? number : T[K] extends ObjectConstructor | {
+  type: ObjectConstructor;
+} ? ObjectInputType : T[K] extends readonly [FlagType<infer U>] | {
+  type: readonly [FlagType<infer U>];
+} ? U[] | InferFlagDefault<T[K], never> : T[K] extends FlagType<infer U> | {
+  type: FlagType<infer U>;
+} ? U | InferFlagDefault<T[K], [U] extends [boolean] ? never : undefined> : never };
+/**
+* An advanced utility type that infers the exact type of the `flags` object in the parsed result,
+* based on the provided `flags` configuration object T.
+*
+* @template T The type of the flags configuration object.
+*/
+type InferFlags<T extends FlagsDefinition> = Prettify<_InferFlags<T>>;
+//#endregion
+//#region ../parser/src/iterator.d.ts
+declare const KNOWN_FLAG = "known-flag";
+declare const UNKNOWN_FLAG = "unknown-flag";
+declare const PARAMETER = "parameter";
+//#endregion
+//#region src/types/clerc.d.ts
+type ErrorHandler = (error: unknown) => void;
+//#endregion
+//#region src/types/flag.d.ts
+type ClercFlagOptions = FlagOptions & {
+  description: string;
 };
-type Flag = FlagOptions & {
-    name: string;
+type ClercFlagsDefinition = Record<string, ClercFlagOptions>;
+//#endregion
+//#region src/types/parameters.d.ts
+type InferParameter<T extends string> = T extends `<${infer Name extends string}...>` | `[${infer Name extends string}...]` ? Record<Name, string[]> : T extends `<${infer Name extends string}>` ? Record<Name, string> : T extends `[${infer Name extends string}]` ? Record<Name, string | undefined> : never;
+type InferParameters<T extends string[]> = T extends (infer U extends string)[] ? Prettify<UnionToIntersection<InferParameter<U>>> : never;
+//#endregion
+//#region src/types/context.d.ts
+type AddStringIndex<T> = T & Record<string, any>;
+type InferFlagsWithGlobal<C extends Command, GF extends ClercFlagsDefinition> = AddStringIndex<InferFlags<NonNullable<C["flags"]> & Omit<GF, keyof NonNullable<C["flags"]>>>>;
+interface BaseContext<C extends Command = Command, GF extends ClercFlagsDefinition = {}> {
+  resolved: boolean;
+  command?: C;
+  calledAs?: string;
+  parameters: InferParameters<NonNullable<C["parameters"]>>;
+  flags: InferFlagsWithGlobal<C, GF>;
+  ignored: string[];
+  rawParsed: ParsedResult<InferFlagsWithGlobal<C, GF>>;
+  maybeMissingParameters?: boolean;
+}
+//#endregion
+//#region src/types/command.d.ts
+interface CommandCustomOptions {}
+interface CommandOptions<Parameters extends string[] = string[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> extends CommandCustomOptions {
+  alias?: MaybeArray<string>;
+  parameters?: Parameters;
+  flags?: Flags;
+  /**
+  * A callback function to conditionally stop parsing. When it returns true, parsing stops and remaining arguments are preserved in ignored.
+  */
+  ignore?: IgnoreFunction;
+}
+interface Command<Name$1 extends string = string, Parameters extends string[] = string[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> extends CommandOptions<Parameters, Flags> {
+  name: Name$1;
+  description: string;
+}
+type CommandWithHandler<Name$1 extends string = string, Parameters extends string[] = string[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> = Command<Name$1, Parameters, Flags> & {
+  handler?: CommandHandler<Command<Name$1, Parameters, Flags>>;
 };
-type GlobalFlagOption = FlagSchema;
-type Flags = Dict<FlagOptions>;
-type GlobalFlagOptions = Dict<GlobalFlagOption>;
-declare interface CommandCustomProperties {
-}
-interface CommandOptions<P extends string[] = string[], A extends MaybeArray$1<string | RootType> = MaybeArray$1<string | RootType>, F extends Flags = Flags> extends CommandCustomProperties {
-    alias?: A;
-    parameters?: P;
-    flags?: F;
+type CommandsRecord = Record<string, Command>;
+type CommandsMap = Map<string, Command>;
+type MakeEmitterEvents<Commands extends CommandsRecord, GlobalFlags extends ClercFlagsDefinition = ClercFlagsDefinition> = { [K in keyof Commands]: [CommandHandlerContext<Commands[K], GlobalFlags>] };
+type CommandHandlerContext<C extends Command = Command, GF extends ClercFlagsDefinition = ClercFlagsDefinition> = DeepPrettify<PartialRequired<BaseContext<C, GF>, "command" | "calledAs"> & {
+  resolved: true;
+}>;
+type CommandHandler<C extends Command = Command, GF extends ClercFlagsDefinition = ClercFlagsDefinition> = (context: CommandHandlerContext<C, GF>) => void;
+//#endregion
+//#region src/types/interceptor.d.ts
+type InterceptorContext<C extends Command = Command, GF extends ClercFlagsDefinition = {}> = DeepPrettify<BaseContext<C, GF>>;
+/**
+* Function to call the next interceptor in the chain.
+* **MUST** be awaited.
+*/
+type InterceptorNext = () => void | Promise<void>;
+type InterceptorHandler<C extends Command = Command, GF extends ClercFlagsDefinition = {}> = (context: InterceptorContext<C, GF>, next: InterceptorNext) => void | Promise<void>;
+interface InterceptorObject<C extends Command = Command, GF extends ClercFlagsDefinition = {}> {
+  enforce?: "pre" | "normal" | "post";
+  handler: InterceptorHandler<C, GF>;
+}
+type Interceptor<C extends Command = Command, GF extends ClercFlagsDefinition = {}> = InterceptorHandler<C, GF> | InterceptorObject<C, GF>;
+//#endregion
+//#region src/types/plugin.d.ts
+interface Plugin {
+  setup: (cli: Clerc) => void;
+}
+//#endregion
+//#region src/cli.d.ts
+interface CreateOptions {
+  name?: string;
+  scriptName?: string;
+  description?: string;
+  version?: string;
 }
-type Command<N extends string | RootType = string, O extends CommandOptions = CommandOptions> = O & {
-    name: N;
-    description: string;
-};
-type CommandAlias<N extends string | RootType = string, O extends CommandOptions = CommandOptions> = Command<N, O> & {
-    __isAlias?: true;
-};
-type CommandWithHandler<N extends string | RootType = string, O extends CommandOptions = CommandOptions> = Command<N, O> & {
-    handler?: HandlerInCommand<HandlerContext<Record<N, Command<N, O>> & Record<never, never>, N>>;
-};
-type Commands = Dict<Command> & {
-    [Root]?: Command;
-};
 interface ParseOptions {
-    argv?: string[];
-    run?: boolean;
-}
-interface HandlerContext<C extends Commands = Commands, N extends keyof C = keyof C, GF extends GlobalFlagOptions = {}> {
-    name?: LiteralUnion<N, string>;
-    called?: string | RootType;
-    resolved: boolean;
-    hasRootOrAlias: boolean;
-    hasRoot: boolean;
-    raw: Simplify<ParseRaw<C[N], GF>>;
-    parameters: Simplify<ParseParameters<C, N>>;
-    unknownFlags: ParsedFlags["unknownFlags"];
-    flags: Simplify<ParseFlag<C, N, GF> & Record<string, any>>;
-    cli: Clerc<C, GF>;
-}
-type Handler<C extends Commands = Commands, K extends keyof C = keyof C, GF extends GlobalFlagOptions = {}> = (ctx: HandlerContext<C, K, GF>) => void;
-type HandlerInCommand<C extends HandlerContext> = (ctx: {
-    [K in keyof C]: C[K];
-}) => void;
-type FallbackType<T, U> = {} extends T ? U : T;
-type InterceptorContext<C extends Commands = Commands> = HandlerContext<C> & {
-    flags: FallbackType<TypeFlag<NonNullable<C[keyof C]["flags"]>>["flags"], Dict<any>>;
-};
-type Interceptor<C extends Commands = Commands> = InterceptorFn<C> | InterceptorObject<C>;
-type InterceptorFn<C extends Commands = Commands> = (ctx: InterceptorContext<C>, next: () => void) => void;
-interface InterceptorObject<C extends Commands = Commands> {
-    enforce?: "pre" | "post";
-    fn: InterceptorFn<C>;
-}
-
-declare const Root: unique symbol;
-type RootType = typeof Root;
-declare class Clerc<C extends Commands = {}, GF extends GlobalFlagOptions = {}> {
-    #private;
-    get i18n(): I18N;
-    private constructor();
-    get _name(): string;
-    get _scriptName(): string;
-    get _description(): string;
-    get _version(): string;
-    /**
-     * @deprecated This is a typo. Use `_interceptor` instead.
-     */
-    get _inspectors(): Interceptor[];
-    get _interceptors(): Interceptor[];
-    get _commands(): C;
-    get _flags(): GF;
-    /**
-     * Create a new cli
-     *
-     * @example
-     *
-     * ```ts
-     * const cli = Clerc.create();
-     * ```
-     *
-     * @param name
-     * @param description
-     * @param version
-     * @returns
-     */
-    static create(name?: string, description?: string, version?: string): Clerc<{}, {}>;
-    /**
-     * Set the name of the cli
-     *
-     * @example
-     *
-     * ```ts
-     * Clerc.create().name("test");
-     * ```
-     *
-     * @param name
-     * @returns
-     */
-    name(name: string): this;
-    /**
-     * Set the script name of the cli
-     *
-     * @example
-     *
-     * ```ts
-     * Clerc.create().scriptName("test");
-     * ```
-     *
-     * @param scriptName
-     * @returns
-     */
-    scriptName(scriptName: string): this;
-    /**
-     * Set the description of the cli
-     *
-     * @example
-     *
-     * ```ts
-     * Clerc.create().description("test cli");
-     * ```
-     *
-     * @param description
-     * @returns
-     */
-    description(description: string): this;
-    /**
-     * Set the version of the cli
-     *
-     * @example
-     *
-     * ```ts
-     * Clerc.create().version("1.0.0");
-     * ```
-     *
-     * @param version
-     * @returns
-     */
-    version(version: string): this;
-    /**
-     * Set the Locale You must call this method once after you created the Clerc
-     * instance.
-     *
-     * @example
-     *
-     * ```ts
-     * Clerc.create()
-     *   .locale("en")
-     *   .command(...)
-     * ```
-     *
-     * @param locale
-     * @returns
-     */
-    locale(locale: string): this;
-    /**
-     * Set the fallback Locale You must call this method once after you created
-     * the Clerc instance.
-     *
-     * @example
-     *
-     * ```ts
-     * Clerc.create()
-     *   .fallbackLocale("en")
-     *   .command(...)
-     * ```
-     *
-     * @param fallbackLocale
-     * @returns
-     */
-    fallbackLocale(fallbackLocale: string): this;
-    /**
-     * Register a error handler
-     *
-     * @example
-     *
-     * ```ts
-     * Clerc.create().errorHandler((err) => {
-     * 	console.log(err);
-     * });
-     * ```
-     *
-     * @param handler
-     * @returns
-     */
-    errorHandler(handler: (err: any) => void): this;
-    /**
-     * Register a command
-     *
-     * @example
-     *
-     * ```ts
-     * Clerc.create().command("test", "test command", {
-     * 	alias: "t",
-     * 	flags: {
-     * 		foo: {
-     * 			alias: "f",
-     * 			description: "foo flag",
-     * 		},
-     * 	},
-     * });
-     * ```
-     *
-     * @example
-     *
-     * ```ts
-     * Clerc.create().command("", "root", {
-     * 	flags: {
-     * 		foo: {
-     * 			alias: "f",
-     * 			description: "foo flag",
-     * 		},
-     * 	},
-     * });
-     * ```
-     *
-     * @param name
-     * @param description
-     * @param options
-     * @returns
-     */
-    command<N extends string | RootType, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray$1<string | RootType> = MaybeArray$1<string | RootType>, F extends Flags = Flags>(c: CommandWithHandler<N, O & CommandOptions<[...P], A, F>>): this & Clerc<C & Record<N, Command<N, O>>, GF>;
-    command<N extends string | RootType, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray$1<string | RootType> = MaybeArray$1<string | RootType>, F extends Flags = Flags>(name: N, description: string, options?: O & CommandOptions<[...P], A, F>): this & Clerc<C & Record<N, Command<N, O>>, GF>;
-    /**
-     * Register a global flag
-     *
-     * @example
-     *
-     * ```ts
-     * Clerc.create().flag("help", "help", {
-     * 	alias: "h",
-     * 	type: Boolean,
-     * });
-     * ```
-     *
-     * @param name
-     * @param description
-     * @param options
-     * @returns
-     */
-    flag<N extends string, O extends GlobalFlagOption>(name: N, description: string, options: O): this & Clerc<C, GF & Record<N, O>>;
-    /**
-     * Register a handler
-     *
-     * @example
-     *
-     * ```ts
-     * Clerc.create()
-     * 	.command("test", "test command")
-     * 	.on("test", (ctx) => {
-     * 		console.log(ctx);
-     * 	});
-     * ```
-     *
-     * @param name
-     * @param handler
-     * @returns
-     */
-    on<K extends LiteralUnion<keyof CM, string | RootType>, CM extends this["_commands"] = this["_commands"]>(name: K, handler: Handler<CM, K, this["_flags"]>): this;
-    /**
-     * Use a plugin
-     *
-     * @example
-     *
-     * ```ts
-     * Clerc.create().use(plugin);
-     * ```
-     *
-     * @param plugin
-     * @returns
-     */
-    use<T extends Clerc, U extends Clerc>(plugin: Plugin<T, U>): this & Clerc<C & U["_commands"]> & U;
-    /**
-     * @deprecated This is a typo. Use `intercetor()` instead.
-     */
-    inspector(interceptor: Interceptor): this;
-    /**
-     * Register a interceptor
-     *
-     * @example
-     *
-     * ```ts
-     * Clerc.create().interceptor((ctx, next) => {
-     * 	console.log(ctx);
-     * 	next();
-     * });
-     * ```
-     *
-     * @param interceptor
-     * @returns
-     */
-    interceptor(interceptor: Interceptor): this;
-    /**
-     * Parse the command line arguments
-     *
-     * @example
-     *
-     * ```ts
-     * Clerc.create().parse(process.argv.slice(2)); // Optional
-     * ```
-     *
-     * @param args
-     * @param optionsOrArgv
-     * @returns
-     */
-    parse(optionsOrArgv?: string[] | ParseOptions): this;
-    /**
-     * Run matched command
-     *
-     * @example
-     *
-     * ```ts
-     * Clerc.create().parse({ run: false }).runMatchedCommand();
-     * ```
-     *
-     * @returns
-     */
-    runMatchedCommand(): this;
-}
-
-declare class CommandExistsError extends Error {
-    commandName: string;
-    constructor(commandName: string, t: TranslateFn);
-}
+  run?: boolean;
+}
+declare class Clerc<Commands extends CommandsRecord = {}, GlobalFlags extends ClercFlagsDefinition = {}> {
+  #private;
+  private constructor();
+  get _name(): string;
+  get _scriptName(): string;
+  get _description(): string;
+  get _version(): string;
+  get _commands(): CommandsMap;
+  get _globalFlags(): GlobalFlags;
+  static create(options?: CreateOptions): Clerc;
+  name(name: string): this;
+  scriptName(scriptName: string): this;
+  description(description: string): this;
+  version(version: string): this;
+  use(plugin: Plugin): this;
+  errorHandler(handler: ErrorHandler$1): this;
+  command<Name$1 extends string, Parameters extends string[] = [], Flags extends ClercFlagsDefinition = {}>(command: CommandWithHandler<Name$1, [...Parameters], Flags>): Clerc<Commands & Record<string, CommandWithHandler<Name$1, Parameters, Flags>>, GlobalFlags>;
+  command<Name$1 extends string, Parameters extends string[] = [], Flags extends ClercFlagsDefinition = {}>(name: Name$1 extends keyof Commands ? ["COMMAND ALREADY EXISTS"] : Name$1, description: string, options?: CommandOptions<[...Parameters], Flags>): Clerc<Commands & Record<Name$1, Command<Name$1, Parameters, Flags>>, GlobalFlags>;
+  globalFlag<Name$1 extends string, Flag extends FlagDefinitionValue>(name: Name$1, description: string, options: Flag): Clerc<Commands, GlobalFlags & Record<Name$1, Flag>>;
+  interceptor(interceptor: Interceptor<Command, GlobalFlags>): this;
+  on<Name$1 extends LiteralUnion<keyof Commands, string>>(name: Name$1, handler: CommandHandler<Commands[Name$1], GlobalFlags>): this;
+  run(): void;
+  parse(argv?: string[], {
+    run
+  }?: ParseOptions): this;
+}
+//#endregion
+//#region src/commands.d.ts
+declare function resolveCommand(commandsMap: CommandsMap, parameters: string[]): [Command, string] | [undefined, undefined];
+//#endregion
+//#region src/errors.d.ts
 declare class NoSuchCommandError extends Error {
-    commandName: string;
-    constructor(commandName: string, t: TranslateFn);
+  commandName: string;
+  constructor(commandName: string);
 }
 declare class NoCommandGivenError extends Error {
-    constructor(t: TranslateFn);
-}
-declare class CommandNameConflictError extends Error {
-    n1: string;
-    n2: string;
-    constructor(n1: string, n2: string, t: TranslateFn);
-}
-declare class ScriptNameNotSetError extends Error {
-    constructor(t: TranslateFn);
-}
-declare class DescriptionNotSetError extends Error {
-    constructor(t: TranslateFn);
-}
-declare class VersionNotSetError extends Error {
-    constructor(t: TranslateFn);
-}
-declare class InvalidCommandNameError extends Error {
-    commandName: string;
-    constructor(commandName: string, t: TranslateFn);
-}
-declare class LocaleNotCalledFirstError extends Error {
-    constructor(t: TranslateFn);
-}
-
-type MaybeArray<T> = T | T[];
-
-declare const definePlugin: <T extends Clerc<{}, {}>, U extends Clerc<{}, {}>>(p: Plugin<T, U>) => Plugin<T, U>;
-declare const defineHandler: <C extends Clerc<{}, {}>, K extends keyof C["_commands"]>(_cli: C, _key: K, handler: Handler<C["_commands"], K>) => Handler<C["_commands"], K>;
-declare const defineInterceptor: <C extends Clerc<{}, {}>>(_cli: C, interceptor: Interceptor<C["_commands"]>) => Interceptor<C["_commands"]>;
-/**
- * @deprecated This is a typo. Use `defineInterceptor` instead.
- */
-declare const defineInspector: <C extends Clerc<{}, {}>>(_cli: C, interceptor: Interceptor<C["_commands"]>) => Interceptor<C["_commands"]>;
-declare const defineCommand: <N extends string | typeof Root, O extends CommandOptions<[...P], MaybeArray<string | typeof Root>, Flags>, P extends string[]>(command: Command<N, O & CommandOptions<[...P], MaybeArray<string | typeof Root>, Flags>>, handler?: HandlerInCommand<HandlerContext<Record<N, Command<N, O>> & Record<never, never>, N, {}>> | undefined) => CommandWithHandler<N, O & CommandOptions<[...P], MaybeArray<string | typeof Root>, Flags>>;
-
-declare function resolveFlattenCommands(commands: Commands, t: TranslateFn): Map<string[] | typeof Root, CommandAlias>;
-declare function resolveCommand(commands: Commands, argv: string[], t: TranslateFn): [Command<string | RootType> | undefined, string[] | RootType | undefined];
-declare const resolveArgv: () => string[];
-declare function compose(interceptors: Interceptor[]): (ctx: InterceptorContext) => void;
-declare const isValidName: (name: CommandType) => boolean;
-declare const withBrackets: (s: string, isOptional?: boolean) => string;
-declare const formatCommandName: (name: string | string[] | RootType) => string;
-declare const detectLocale: () => string;
-declare const stripFlags: (argv: string[]) => string[];
-
-export { Clerc, Command, CommandAlias, CommandCustomProperties, CommandExistsError, CommandNameConflictError, CommandOptions, CommandType, CommandWithHandler, Commands, DescriptionNotSetError, FallbackType, Flag, FlagOptions, Flags, GlobalFlagOption, GlobalFlagOptions, Handler, HandlerContext, HandlerInCommand, I18N, Interceptor, InterceptorContext, InterceptorFn, InterceptorObject, InvalidCommandNameError, LocaleNotCalledFirstError, Locales, MakeEventMap, NoCommandGivenError, NoSuchCommandError, ParseOptions, Plugin, Root, RootType, ScriptNameNotSetError, TranslateFn, VersionNotSetError, compose, defineCommand, defineHandler, defineInspector, defineInterceptor, definePlugin, detectLocale, formatCommandName, isValidName, resolveArgv, resolveCommand, resolveFlattenCommands, stripFlags, withBrackets };
+  constructor();
+}
+declare class InvalidCommandError extends Error {
+  constructor(message: string);
+}
+declare class MissingRequiredMetadataError extends Error {
+  constructor(metadataName: string);
+}
+declare class InvalidParametersError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/helpers.d.ts
+declare const defineCommand: <Name$1 extends string, Parameters extends string[] = [], Flags extends ClercFlagsDefinition = {}>(command: CommandWithHandler<Name$1, [...Parameters], Flags>) => CommandWithHandler<Name$1, [...Parameters], Flags>;
+//#endregion
+//#region src/ignore.d.ts
+declare function createStopAtFirstParameter(): IgnoreFunction;
+//#endregion
+//#region src/plugin.d.ts
+declare const definePlugin: (plugin: Plugin) => Plugin;
+//#endregion
+export { BaseContext, Clerc, ClercFlagOptions, ClercFlagsDefinition, Command, CommandCustomOptions, CommandHandler, CommandHandlerContext, CommandOptions, CommandWithHandler, CommandsMap, CommandsRecord, ErrorHandler, InferParameters, Interceptor, InterceptorContext, InterceptorHandler, InterceptorNext, InterceptorObject, InvalidCommandError, InvalidParametersError, MakeEmitterEvents, MissingRequiredMetadataError, NoCommandGivenError, NoSuchCommandError, Plugin, createStopAtFirstParameter, defineCommand, definePlugin, resolveCommand };