args-tokens 0.21.0 → 0.22.0

package/lib/index.d.ts

@@ -1,62 +1,62 @@
-import { ArgToken, ParserOptions, parseArgs$1 as parseArgs } from "./parser-FiQIAw-2.js";
-import { ArgResolveError$1 as ArgResolveError, ArgResolveErrorType, ArgSchema, ArgValues, Args, ExplicitlyProvided, ResolveArgs, resolveArgs$1 as resolveArgs } from "./resolver-C87QZIMT.js";
+import { ArgToken, ParserOptions, parseArgs$1 as parseArgs } from "./parser-Cbxholql.js";
+import { ArgExplicitlyProvided, ArgResolveError$1 as ArgResolveError, ArgResolveErrorType, ArgSchema, ArgValues, Args, ResolveArgs, resolveArgs$1 as resolveArgs } from "./resolver-BoS-UnqX.js";
 
 //#region src/parse.d.ts
 
 /**
-* Parse options for {@link parse} function.
-*/
+ * Parse options for {@link parse} function.
+ */
 interface ParseOptions<A extends Args> extends ParserOptions, ResolveArgs {
   /**
-  * Command line arguments, about details see {@link Args}.
-  */
+   * Command line arguments, about details see {@link Args}.
+   */
   args?: A;
 }
 /**
-* Parsed command line arguments.
-*/
+ * Parsed command line arguments.
+ */
 type ParsedArgs<A extends Args> = {
   /**
-  * Parsed values, same as `values` in {@link resolveArgs}.
-  */
+   * Parsed values, same as `values` in {@link resolveArgs}.
+   */
   values: ArgValues<A>;
   /**
-  * Positional arguments, same as `positionals` in {@link resolveArgs}.
-  */
+   * Positional arguments, same as `positionals` in {@link resolveArgs}.
+   */
   positionals: string[];
   /**
-  * Rest arguments, same as `rest` in {@link resolveArgs}.
-  */
+   * Rest arguments, same as `rest` in {@link resolveArgs}.
+   */
   rest: string[];
   /**
-  * Validation errors, same as `errors` in {@link resolveArgs}.
-  */
+   * Validation errors, same as `errors` in {@link resolveArgs}.
+   */
   error: AggregateError | undefined;
   /**
-  * Argument tokens, same as `tokens` which is parsed by {@link parseArgs}.
-  */
+   * Argument tokens, same as `tokens` which is parsed by {@link parseArgs}.
+   */
   tokens: ArgToken[];
   /**
-  * Explicit provision status, same as `explicit` in {@link resolveArgs}.
-  * Indicates which arguments were explicitly provided vs using default values.
-  */
-  explicit: ExplicitlyProvided<A>;
+   * Explicit provision status, same as `explicit` in {@link resolveArgs}.
+   * Indicates which arguments were explicitly provided vs using default values.
+   */
+  explicit: ArgExplicitlyProvided<A>;
 };
 /**
-* Parse command line arguments.
-* This function is a convenient API, that is used {@link parseArgs} and {@link resolveArgs} in internal.
-* @example
-* ```js
-* import { parse } from 'args-tokens'
-*
-* const { values, positionals } = parse(process.argv.slice(2))
-* console.log('values', values)
-* console.log('positionals', positionals)
-* ```
-* @param args - command line arguments
-* @param options - parse options, about details see {@link ParseOptions}
-* @returns An object that contains the values of the arguments, positional arguments, {@link AggregateError | validation errors}, and {@link ArgToken | argument tokens}.
-*/
+ * Parse command line arguments.
+ * This function is a convenient API, that is used {@link parseArgs} and {@link resolveArgs} in internal.
+ * @example
+ * ```js
+ * import { parse } from 'args-tokens'
+ *
+ * const { values, positionals } = parse(process.argv.slice(2))
+ * console.log('values', values)
+ * console.log('positionals', positionals)
+ * ```
+ * @param args - command line arguments
+ * @param options - parse options, about details see {@link ParseOptions}
+ * @returns An object that contains the values of the arguments, positional arguments, {@link AggregateError | validation errors}, and {@link ArgToken | argument tokens}.
+ */
 declare function parse<A extends Args>(args: string[], options?: ParseOptions<A>): ParsedArgs<A>;
 //#endregion
-export { ArgResolveError, ArgResolveErrorType, ArgSchema, ArgToken, ArgValues, Args, ParseOptions, ParsedArgs, ParserOptions, ResolveArgs, parse, parseArgs, resolveArgs };
+export { ArgExplicitlyProvided, ArgResolveError, ArgResolveErrorType, ArgSchema, ArgToken, ArgValues, Args, ParseOptions, ParsedArgs, ParserOptions, ResolveArgs, parse, parseArgs, resolveArgs };

package/lib/parser-Cbxholql.d.ts

@@ -0,0 +1,91 @@
+//#region src/parser.d.ts
+/**
+ * Entry point of argument parser.
+ * @module
+ */
+/**
+ * forked from `nodejs/node` (`pkgjs/parseargs`)
+ * repository url: https://github.com/nodejs/node (https://github.com/pkgjs/parseargs)
+ * code url: https://github.com/nodejs/node/blob/main/lib/internal/util/parse_args/parse_args.js
+ *
+ * @author kazuya kawaguchi (a.k.a. kazupon)
+ * @license MIT
+ */
+/**
+ * Argument token Kind.
+ * - `option`: option token, support short option (e.g. `-x`) and long option (e.g. `--foo`)
+ * - `option-terminator`: option terminator (`--`) token, see guideline 10 in https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html
+ * - `positional`: positional token
+ */
+type ArgTokenKind = 'option' | 'option-terminator' | 'positional';
+/**
+ * Argument token.
+ */
+interface ArgToken {
+  /**
+   * Argument token kind.
+   */
+  kind: ArgTokenKind;
+  /**
+   * Argument token index, e.g `--foo bar` => `--foo` index is 0, `bar` index is 1.
+   */
+  index: number;
+  /**
+   * Option name, e.g. `--foo` => `foo`, `-x` => `x`.
+   */
+  name?: string;
+  /**
+   * Raw option name, e.g. `--foo` => `--foo`, `-x` => `-x`.
+   */
+  rawName?: string;
+  /**
+   * Option value, e.g. `--foo=bar` => `bar`, `-x=bar` => `bar`.
+   * If the `allowCompatible` option is `true`, short option value will be same as Node.js `parseArgs` behavior.
+   */
+  value?: string;
+  /**
+   * Inline value, e.g. `--foo=bar` => `true`, `-x=bar` => `true`.
+   */
+  inlineValue?: boolean;
+}
+/**
+ * Parser Options.
+ */
+interface ParserOptions {
+  /**
+   * [Node.js parseArgs](https://nodejs.org/api/util.html#parseargs-tokens) tokens compatible mode.
+   * @default false
+   */
+  allowCompatible?: boolean;
+}
+/**
+ * Parse command line arguments.
+ * @example
+ * ```js
+ * import { parseArgs } from 'args-tokens' // for Node.js and Bun
+ * // import { parseArgs } from 'jsr:@kazupon/args-tokens' // for Deno
+ *
+ * const tokens = parseArgs(['--foo', 'bar', '-x', '--bar=baz'])
+ * // do something with using tokens
+ * // ...
+ * console.log('tokens:', tokens)
+ * ```
+ * @param args command line arguments
+ * @param options parse options
+ * @returns Argument tokens.
+ */
+declare function parseArgs(args: string[], options?: ParserOptions): ArgToken[];
+/**
+ * Check if `arg` is a short option (e.g. `-f`).
+ * @param arg the argument to check
+ * @returns whether `arg` is a short option.
+ */
+declare function isShortOption(arg: string): boolean;
+/**
+ * Check if `arg` is a long option prefix (e.g. `--`).
+ * @param arg the argument to check
+ * @returns whether `arg` is a long option prefix.
+ */
+declare function hasLongOptionPrefix(arg: string): boolean;
+//#endregion
+export { ArgToken, ParserOptions, hasLongOptionPrefix as hasLongOptionPrefix$1, isShortOption as isShortOption$1, parseArgs as parseArgs$1 };

package/lib/parser.d.ts

@@ -1,2 +1,2 @@
-import { ArgToken, ParserOptions, hasLongOptionPrefix$1 as hasLongOptionPrefix, isShortOption$1 as isShortOption, parseArgs$1 as parseArgs } from "./parser-FiQIAw-2.js";
+import { ArgToken, ParserOptions, hasLongOptionPrefix$1 as hasLongOptionPrefix, isShortOption$1 as isShortOption, parseArgs$1 as parseArgs } from "./parser-Cbxholql.js";
 export { ArgToken, ParserOptions, hasLongOptionPrefix, isShortOption, parseArgs };

package/lib/resolver-BoS-UnqX.d.ts

@@ -0,0 +1,173 @@
+import { ArgToken } from "./parser-Cbxholql.js";
+
+//#region src/resolver.d.ts
+
+/**
+ * An argument schema
+ * This schema is similar to the schema of the `node:utils`.
+ * difference is that:
+ * - `required` property and `description` property are added
+ * - `type` is not only 'string' and 'boolean', but also 'number', 'enum', 'positional', 'custom' too.
+ * - `default` property type, not support multiple types
+ */
+interface ArgSchema {
+  /**
+   * Type of argument.
+   */
+  type: 'string' | 'boolean' | 'number' | 'enum' | 'positional' | 'custom';
+  /**
+   * A single character alias for the argument.
+   */
+  short?: string;
+  /**
+   * A description of the argument.
+   */
+  description?: string;
+  /**
+   * Whether the argument is required or not.
+   */
+  required?: true;
+  /**
+   * Whether the argument allow multiple values or not.
+   */
+  multiple?: true;
+  /**
+   * Whether the negatable option for `boolean` type
+   */
+  negatable?: boolean;
+  /**
+   * The allowed values of the argument, and string only. This property is only used when the type is 'enum'.
+   */
+  choices?: string[] | readonly string[];
+  /**
+   * The default value of the argument.
+   * if the type is 'enum', the default value must be one of the allowed values.
+   */
+  default?: string | boolean | number;
+  /**
+   * Whether to convert the argument name to kebab-case.
+   */
+  toKebab?: true;
+  /**
+   * A function to parse the value of the argument. if the type is 'custom', this function is required.
+   * If argument value will be invalid, this function have to throw an error.
+   * @param value
+   * @returns Parsed value
+   * @throws An Error, If the value is invalid. Error type should be `Error` or extends it
+   */
+  parse?: (value: string) => any;
+}
+/**
+ * An object that contains {@link ArgSchema | argument schema}.
+ */
+interface Args {
+  [option: string]: ArgSchema;
+}
+/**
+ * An object that contains the values of the arguments.
+ */
+type ArgValues<T> = T extends Args ? ResolveArgValues<T, { [Arg in keyof T]: ExtractOptionValue<T[Arg]> }> : {
+  [option: string]: string | boolean | number | (string | boolean | number)[] | undefined;
+};
+type IsFunction<T> = T extends ((...args: any[]) => any) ? true : false;
+/**
+ * @internal
+ */
+type ExtractOptionValue<A extends ArgSchema> = A['type'] extends 'string' ? ResolveOptionValue<A, string> : A['type'] extends 'boolean' ? ResolveOptionValue<A, boolean> : A['type'] extends 'number' ? ResolveOptionValue<A, number> : A['type'] extends 'positional' ? ResolveOptionValue<A, string> : A['type'] extends 'enum' ? A['choices'] extends string[] | readonly string[] ? ResolveOptionValue<A, A['choices'][number]> : never : A['type'] extends 'custom' ? IsFunction<A['parse']> extends true ? ResolveOptionValue<A, ReturnType<NonNullable<A['parse']>>> : never : ResolveOptionValue<A, string | boolean | number>;
+type ResolveOptionValue<A extends ArgSchema, T> = A['multiple'] extends true ? T[] : T;
+/**
+ * @internal
+ */
+type ResolveArgValues<A extends Args, V extends Record<keyof A, unknown>> = { -readonly [Arg in keyof A]?: V[Arg] } & FilterArgs<A, V, 'default'> & FilterArgs<A, V, 'required'> & FilterPositionalArgs<A, V> extends infer P ? { [K in keyof P]: P[K] } : never;
+/**
+ * @internal
+ */
+type FilterArgs<A extends Args, V extends Record<keyof A, unknown>, K extends keyof ArgSchema> = { [Arg in keyof A as A[Arg][K] extends {} ? Arg : never]: V[Arg] };
+/**
+ * @internal
+ */
+type FilterPositionalArgs<A extends Args, V extends Record<keyof A, unknown>> = { [Arg in keyof A as A[Arg]['type'] extends 'positional' ? Arg : never]: V[Arg] };
+/**
+ * An arguments for {@link resolveArgs | resolve arguments}.
+ */
+interface ResolveArgs {
+  /**
+   * Whether to group short arguments.
+   * @default false
+   * @see guideline 5 in https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap12.html
+   */
+  shortGrouping?: boolean;
+  /**
+   * Skip positional arguments index.
+   * @default -1
+   */
+  skipPositional?: number;
+  /**
+   * Whether to convert the argument name to kebab-case. This option is applied to all arguments as `toKebab: true`, if set to `true`.
+   * @default false
+   */
+  toKebab?: boolean;
+}
+/**
+ * Tracks which arguments were explicitly provided by the user.
+ *
+ * Each property indicates whether the corresponding argument was explicitly
+ * provided (true) or is using a default value or not provided (false).
+ */
+type ArgExplicitlyProvided<A extends Args> = { [K in keyof A]: boolean };
+/**
+ * Resolve command line arguments.
+ * @param args - An arguments that contains {@link ArgSchema | arguments schema}.
+ * @param tokens - An array of {@link ArgToken | tokens}.
+ * @param resolveArgs - An arguments that contains {@link ResolveArgs | resolve arguments}.
+ * @returns An object that contains the values of the arguments, positional arguments, rest arguments, {@link AggregateError | validation errors}, and explicit provision status.
+ *
+ * @example
+ * ```typescript
+ * // passed tokens: --port 3000
+ *
+ * const { values, explicit } = resolveArgs({
+ *   port: {
+ *     type: 'number',
+ *     default: 8080
+ *   },
+ *   host: {
+ *     type: 'string',
+ *     default: 'localhost'
+ *   }
+ * }, parsedTokens)
+ *
+ * values.port // 3000
+ * values.host // 'localhost'
+ *
+ * explicit.port // true (explicitly provided)
+ * explicit.host // false (not provided, fallback to default)
+ * ```
+ */
+declare function resolveArgs<A extends Args>(args: A, tokens: ArgToken[], {
+  shortGrouping,
+  skipPositional,
+  toKebab
+}?: ResolveArgs): {
+  values: ArgValues<A>;
+  positionals: string[];
+  rest: string[];
+  error: AggregateError | undefined;
+  explicit: ArgExplicitlyProvided<A>;
+};
+/**
+ * An error type for {@link ArgResolveError}.
+ */
+type ArgResolveErrorType = 'type' | 'required';
+/**
+ * An error that occurs when resolving arguments.
+ * This error is thrown when the argument is not valid.
+ */
+declare class ArgResolveError extends Error {
+  name: string;
+  schema: ArgSchema;
+  type: ArgResolveErrorType;
+  constructor(message: string, name: string, type: ArgResolveErrorType, schema: ArgSchema);
+}
+//#endregion
+export { ArgExplicitlyProvided, ArgResolveError as ArgResolveError$1, ArgResolveErrorType, ArgSchema, ArgValues, Args, ExtractOptionValue, FilterArgs, FilterPositionalArgs, ResolveArgValues, ResolveArgs, resolveArgs as resolveArgs$1 };

package/lib/resolver.d.ts

@@ -1,3 +1,3 @@
-import "./parser-FiQIAw-2.js";
-import { ArgResolveError$1 as ArgResolveError, ArgResolveErrorType, ArgSchema, ArgValues, Args, ExplicitlyProvided, ExtractOptionValue, FilterArgs, FilterPositionalArgs, ResolveArgValues, ResolveArgs, resolveArgs$1 as resolveArgs } from "./resolver-C87QZIMT.js";
-export { ArgResolveError, ArgResolveErrorType, ArgSchema, ArgValues, Args, ExplicitlyProvided, ExtractOptionValue, FilterArgs, FilterPositionalArgs, ResolveArgValues, ResolveArgs, resolveArgs };
+import "./parser-Cbxholql.js";
+import { ArgExplicitlyProvided, ArgResolveError$1 as ArgResolveError, ArgResolveErrorType, ArgSchema, ArgValues, Args, ExtractOptionValue, FilterArgs, FilterPositionalArgs, ResolveArgValues, ResolveArgs, resolveArgs$1 as resolveArgs } from "./resolver-BoS-UnqX.js";
+export { ArgExplicitlyProvided, ArgResolveError, ArgResolveErrorType, ArgSchema, ArgValues, Args, ExtractOptionValue, FilterArgs, FilterPositionalArgs, ResolveArgValues, ResolveArgs, resolveArgs };

package/lib/utils.d.ts

@@ -1,15 +1,15 @@
 //#region src/utils.d.ts
 /**
-* Entry point of utils.
-*
-* Note that this entry point is used by gunshi to import utility functions.
-*
-* @module
-*/
+ * Entry point of utils.
+ *
+ * Note that this entry point is used by gunshi to import utility functions.
+ *
+ * @module
+ */
 /**
-* @author kazuya kawaguchi (a.k.a. kazupon)
-* @license MIT
-*/
+ * @author kazuya kawaguchi (a.k.a. kazupon)
+ * @license MIT
+ */
 declare function kebabnize(str: string): string;
 //#endregion
 export { kebabnize };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "args-tokens",
   "description": "parseArgs tokens compatibility and more high-performance parser",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "author": {
     "name": "kazuya kawaguchi",
     "email": "kawakazu80@gmail.com"
@@ -75,7 +75,7 @@
     "@kazupon/eslint-config": "^0.31.1",
     "@kazupon/prettier-config": "^0.1.1",
     "@types/node": "^22.16.0",
-    "@typescript/native-preview": "7.0.0-dev.20250708.1",
+    "@typescript/native-preview": "7.0.0-dev.20250710.1",
     "@vitest/eslint-plugin": "^1.3.4",
     "bumpp": "^10.2.0",
     "deno": "^2.4.1",
@@ -98,7 +98,7 @@
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.36.0",
     "vitest": "^3.2.4",
-    "zod": "^3.25.76"
+    "zod": "^4.0.0"
   },
   "prettier": "@kazupon/prettier-config",
   "lint-staged": {

package/lib/parser-FiQIAw-2.d.ts

@@ -1,91 +0,0 @@
-//#region src/parser.d.ts
-/**
-* Entry point of argument parser.
-* @module
-*/
-/**
-* forked from `nodejs/node` (`pkgjs/parseargs`)
-* repository url: https://github.com/nodejs/node (https://github.com/pkgjs/parseargs)
-* code url: https://github.com/nodejs/node/blob/main/lib/internal/util/parse_args/parse_args.js
-*
-* @author kazuya kawaguchi (a.k.a. kazupon)
-* @license MIT
-*/
-/**
-* Argument token Kind.
-* - `option`: option token, support short option (e.g. `-x`) and long option (e.g. `--foo`)
-* - `option-terminator`: option terminator (`--`) token, see guideline 10 in https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html
-* - `positional`: positional token
-*/
-type ArgTokenKind = "option" | "option-terminator" | "positional";
-/**
-* Argument token.
-*/
-interface ArgToken {
-  /**
-  * Argument token kind.
-  */
-  kind: ArgTokenKind;
-  /**
-  * Argument token index, e.g `--foo bar` => `--foo` index is 0, `bar` index is 1.
-  */
-  index: number;
-  /**
-  * Option name, e.g. `--foo` => `foo`, `-x` => `x`.
-  */
-  name?: string;
-  /**
-  * Raw option name, e.g. `--foo` => `--foo`, `-x` => `-x`.
-  */
-  rawName?: string;
-  /**
-  * Option value, e.g. `--foo=bar` => `bar`, `-x=bar` => `bar`.
-  * If the `allowCompatible` option is `true`, short option value will be same as Node.js `parseArgs` behavior.
-  */
-  value?: string;
-  /**
-  * Inline value, e.g. `--foo=bar` => `true`, `-x=bar` => `true`.
-  */
-  inlineValue?: boolean;
-}
-/**
-* Parser Options.
-*/
-interface ParserOptions {
-  /**
-  * [Node.js parseArgs](https://nodejs.org/api/util.html#parseargs-tokens) tokens compatible mode.
-  * @default false
-  */
-  allowCompatible?: boolean;
-}
-/**
-* Parse command line arguments.
-* @example
-* ```js
-* import { parseArgs } from 'args-tokens' // for Node.js and Bun
-* // import { parseArgs } from 'jsr:@kazupon/args-tokens' // for Deno
-*
-* const tokens = parseArgs(['--foo', 'bar', '-x', '--bar=baz'])
-* // do something with using tokens
-* // ...
-* console.log('tokens:', tokens)
-* ```
-* @param args command line arguments
-* @param options parse options
-* @returns Argument tokens.
-*/
-declare function parseArgs(args: string[], options?: ParserOptions): ArgToken[];
-/**
-* Check if `arg` is a short option (e.g. `-f`).
-* @param arg the argument to check
-* @returns whether `arg` is a short option.
-*/
-declare function isShortOption(arg: string): boolean;
-/**
-* Check if `arg` is a long option prefix (e.g. `--`).
-* @param arg the argument to check
-* @returns whether `arg` is a long option prefix.
-*/
-declare function hasLongOptionPrefix(arg: string): boolean;
-//#endregion
-export { ArgToken, ParserOptions, hasLongOptionPrefix as hasLongOptionPrefix$1, isShortOption as isShortOption$1, parseArgs as parseArgs$1 };

package/lib/resolver-C87QZIMT.d.ts

@@ -1,175 +0,0 @@
-import { ArgToken } from "./parser-FiQIAw-2.js";
-
-//#region src/resolver.d.ts
-
-/**
-* An argument schema
-* This schema is similar to the schema of the `node:utils`.
-* difference is that:
-* - `required` property and `description` property are added
-* - `type` is not only 'string' and 'boolean', but also 'number', 'enum', 'positional', 'custom' too.
-* - `default` property type, not support multiple types
-*/
-interface ArgSchema {
-  /**
-  * Type of argument.
-  */
-  type: "string" | "boolean" | "number" | "enum" | "positional" | "custom";
-  /**
-  * A single character alias for the argument.
-  */
-  short?: string;
-  /**
-  * A description of the argument.
-  */
-  description?: string;
-  /**
-  * Whether the argument is required or not.
-  */
-  required?: true;
-  /**
-  * Whether the argument allow multiple values or not.
-  */
-  multiple?: true;
-  /**
-  * Whether the negatable option for `boolean` type
-  */
-  negatable?: boolean;
-  /**
-  * The allowed values of the argument, and string only. This property is only used when the type is 'enum'.
-  */
-  choices?: string[] | readonly string[];
-  /**
-  * The default value of the argument.
-  * if the type is 'enum', the default value must be one of the allowed values.
-  */
-  default?: string | boolean | number;
-  /**
-  * Whether to convert the argument name to kebab-case.
-  */
-  toKebab?: true;
-  /**
-  * A function to parse the value of the argument. if the type is 'custom', this function is required.
-  * If argument value will be invalid, this function have to throw an error.
-  * @param value
-  * @returns Parsed value
-  * @throws An Error, If the value is invalid. Error type should be `Error` or extends it
-  */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  parse?: (value: string) => any;
-}
-/**
-* An object that contains {@link ArgSchema | argument schema}.
-*/
-interface Args {
-  [option: string]: ArgSchema;
-}
-/**
-* An object that contains the values of the arguments.
-*/
-type ArgValues<T> = T extends Args ? ResolveArgValues<T, { [Arg in keyof T]: ExtractOptionValue<T[Arg]> }> : {
-  [option: string]: string | boolean | number | (string | boolean | number)[] | undefined;
-};
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type IsFunction<T> = T extends ((...args: any[]) => any) ? true : false;
-/**
-* @internal
-*/
-type ExtractOptionValue<A extends ArgSchema> = A["type"] extends "string" ? ResolveOptionValue<A, string> : A["type"] extends "boolean" ? ResolveOptionValue<A, boolean> : A["type"] extends "number" ? ResolveOptionValue<A, number> : A["type"] extends "positional" ? ResolveOptionValue<A, string> : A["type"] extends "enum" ? A["choices"] extends string[] | readonly string[] ? ResolveOptionValue<A, A["choices"][number]> : never : A["type"] extends "custom" ? IsFunction<A["parse"]> extends true ? ResolveOptionValue<A, ReturnType<NonNullable<A["parse"]>>> : never : ResolveOptionValue<A, string | boolean | number>;
-type ResolveOptionValue<A extends ArgSchema, T> = A["multiple"] extends true ? T[] : T;
-/**
-* @internal
-*/
-type ResolveArgValues<A extends Args, V extends Record<keyof A, unknown>> = { -readonly [Arg in keyof A]?: V[Arg] } & FilterArgs<A, V, "default"> & FilterArgs<A, V, "required"> & FilterPositionalArgs<A, V> extends infer P ? { [K in keyof P]: P[K] } : never;
-/**
-* @internal
-*/
-type FilterArgs<A extends Args, V extends Record<keyof A, unknown>, K extends keyof ArgSchema> = { [Arg in keyof A as A[Arg][K] extends {} ? Arg : never]: V[Arg] };
-/**
-* @internal
-*/
-type FilterPositionalArgs<A extends Args, V extends Record<keyof A, unknown>> = { [Arg in keyof A as A[Arg]["type"] extends "positional" ? Arg : never]: V[Arg] };
-/**
-* An arguments for {@link resolveArgs | resolve arguments}.
-*/
-interface ResolveArgs {
-  /**
-  * Whether to group short arguments.
-  * @default false
-  * @see guideline 5 in https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap12.html
-  */
-  shortGrouping?: boolean;
-  /**
-  * Skip positional arguments index.
-  * @default -1
-  */
-  skipPositional?: number;
-  /**
-  * Whether to convert the argument name to kebab-case. This option is applied to all arguments as `toKebab: true`, if set to `true`.
-  * @default false
-  */
-  toKebab?: boolean;
-}
-/**
-* Tracks which arguments were explicitly provided by the user.
-*
-* Each property indicates whether the corresponding argument was explicitly
-* provided (true) or is using a default value or not provided (false).
-*/
-type ExplicitlyProvided<A extends Args> = { readonly [K in keyof A]: boolean };
-/**
-* Resolve command line arguments.
-* @param args - An arguments that contains {@link ArgSchema | arguments schema}.
-* @param tokens - An array of {@link ArgToken | tokens}.
-* @param resolveArgs - An arguments that contains {@link ResolveArgs | resolve arguments}.
-* @returns An object that contains the values of the arguments, positional arguments, rest arguments, {@link AggregateError | validation errors}, and explicit provision status.
-*
-* @example
-* ```typescript
-* // passed tokens: --port 3000
-*
-* const { values, explicit } = resolveArgs({
-*   port: {
-*     type: 'number',
-*     default: 8080
-*   },
-*   host: {
-*     type: 'string',
-*     default: 'localhost'
-*   }
-* }, parsedTokens)
-*
-* values.port // 3000
-* values.host // 'localhost'
-*
-* explicit.port // true (explicitly provided)
-* explicit.host // false (not provided, fallback to default)
-* ```
-*/
-declare function resolveArgs<A extends Args>(args: A, tokens: ArgToken[], {
-  shortGrouping,
-  skipPositional,
-  toKebab
-}?: ResolveArgs): {
-  values: ArgValues<A>;
-  positionals: string[];
-  rest: string[];
-  error: AggregateError | undefined;
-  explicit: ExplicitlyProvided<A>;
-};
-/**
-* An error type for {@link ArgResolveError}.
-*/
-type ArgResolveErrorType = "type" | "required";
-/**
-* An error that occurs when resolving arguments.
-* This error is thrown when the argument is not valid.
-*/
-declare class ArgResolveError extends Error {
-  name: string;
-  schema: ArgSchema;
-  type: ArgResolveErrorType;
-  constructor(message: string, name: string, type: ArgResolveErrorType, schema: ArgSchema);
-}
-//#endregion
-export { ArgResolveError as ArgResolveError$1, ArgResolveErrorType, ArgSchema, ArgValues, Args, ExplicitlyProvided, ExtractOptionValue, FilterArgs, FilterPositionalArgs, ResolveArgValues, ResolveArgs, resolveArgs as resolveArgs$1 };