@optique/core 0.5.0-dev.79 → 0.5.0-dev.82

package/dist/parser.d.cts

@@ -1,7 +1,10 @@
 import { Message } from "./message.cjs";
-import { OptionName, Usage } from "./usage.cjs";
+import { Usage } from "./usage.cjs";
 import { DocFragments, DocPage } from "./doc.cjs";
-import { ValueParser, ValueParserResult } from "./valueparser.cjs";
+import { ValueParserResult } from "./valueparser.cjs";
+import { MultipleErrorOptions, MultipleOptions, WithDefaultError, WithDefaultOptions, map, multiple, optional, withDefault } from "./modifiers.cjs";
+import { ArgumentErrorOptions, ArgumentOptions, CommandErrorOptions, CommandOptions, FlagErrorOptions, FlagOptions, OptionErrorOptions, OptionOptions, argument, command, constant, flag, option } from "./primitives.cjs";
+import { LongestMatchErrorOptions, LongestMatchOptions, ObjectErrorOptions, ObjectOptions, OrErrorOptions, OrOptions, concat, group, longestMatch, merge, object, or, tuple } from "./constructs.cjs";
 
 //#region src/parser.d.ts
 
@@ -144,1239 +147,6 @@ type ParserResult<TState> = {
    */
   readonly error: Message;
 };
-/**
- * Creates a parser that always succeeds without consuming any input and
- * produces a constant value of the type {@link T}.
- * @template T The type of the constant value produced by the parser.
- */
-declare function constant<const T>(value: T): Parser<T, T>;
-/**
- * Options for the {@link option} parser.
- */
-interface OptionOptions {
-  /**
-   * The description of the option, which can be used for help messages.
-   */
-  readonly description?: Message;
-}
-/**
- * Creates a parser for various styles of command-line options that take an
- * argument value, such as `--option=value`, `-o value`, or `/option:value`.
- * @template T The type of value this parser produces.
- * @param args The {@link OptionName}s to parse, followed by
- *             a {@link ValueParser} that defines how to parse the value of
- *             the option.  If no value parser is provided, the option is
- *             treated as a boolean flag.
- * @returns A {@link Parser} that can parse the specified options and their
- *          values.
- */
-declare function option<T>(...args: readonly [...readonly OptionName[], ValueParser<T>]): Parser<T, ValueParserResult<T> | undefined>;
-/**
- * Creates a parser for various styles of command-line options that take an
- * argument value, such as `--option=value`, `-o value`, or `/option:value`.
- * @template T The type of value this parser produces.
- * @param args The {@link OptionName}s to parse, followed by
- *             a {@link ValueParser} that defines how to parse the value of
- *             the option, and an optional {@link OptionOptions} object
- *             that allows you to specify a description or other metadata.
- * @returns A {@link Parser} that can parse the specified options and their
- *          values.
- */
-declare function option<T>(...args: readonly [...readonly OptionName[], ValueParser<T>, OptionOptions]): Parser<T, ValueParserResult<T> | undefined>;
-/**
- * Creates a parser for various styles of command-line options that do not
- * take an argument value, such as `--option`, `-o`, or `/option`.
- * @param optionNames The {@link OptionName}s to parse.
- * @return A {@link Parser} that can parse the specified options as Boolean
- *         flags, producing `true` if the option is present.
- */
-declare function option(...optionNames: readonly OptionName[]): Parser<boolean, ValueParserResult<boolean> | undefined>;
-/**
- * Creates a parser for various styles of command-line options that take an
- * argument value, such as `--option=value`, `-o value`, or `/option:value`.
- * @param args The {@link OptionName}s to parse, followed by
- *             an optional {@link OptionOptions} object that allows you to
- *             specify a description or other metadata.
- * @returns A {@link Parser} that can parse the specified options and their
- *          values.
- */
-declare function option(...args: readonly [...readonly OptionName[], OptionOptions]): Parser<boolean, ValueParserResult<boolean> | undefined>;
-/**
- * Options for the {@link flag} parser.
- */
-interface FlagOptions {
-  /**
-   * The description of the flag, which can be used for help messages.
-   */
-  readonly description?: Message;
-}
-/**
- * Creates a parser for command-line flags that must be explicitly provided.
- * Unlike {@link option}, this parser fails if the flag is not present, making
- * it suitable for required boolean flags that don't have a meaningful default.
- *
- * The key difference from {@link option} is:
- * - {@link option} without a value parser: Returns `false` when not present
- * - {@link flag}: Fails parsing when not present, only produces `true`
- *
- * This is useful for dependent options where the presence of a flag changes
- * the shape of the result type.
- *
- * @param args The {@link OptionName}s to parse, followed by an optional
- *             {@link FlagOptions} object that allows you to specify
- *             a description or other metadata.
- * @returns A {@link Parser} that produces `true` when the flag is present
- *          and fails when it is not present.
- *
- * @example
- * ```typescript
- * // Basic flag usage
- * const parser = flag("-f", "--force");
- * // Succeeds with true: parse(parser, ["-f"])
- * // Fails: parse(parser, [])
- *
- * // With description
- * const verboseFlag = flag("-v", "--verbose", {
- *   description: "Enable verbose output"
- * });
- * ```
- */
-declare function flag(...args: readonly [...readonly OptionName[], FlagOptions] | readonly OptionName[]): Parser<true, ValueParserResult<true> | undefined>;
-/**
- * Options for the {@link argument} parser.
- */
-interface ArgumentOptions {
-  /**
-   * The description of the argument, which can be used for help messages.
-   */
-  readonly description?: Message;
-}
-/**
- * Creates a parser that expects a single argument value.
- * This parser is typically used for positional arguments
- * that are not options or flags.
- * @template T The type of the value produced by the parser.
- * @param valueParser The {@link ValueParser} that defines how to parse
- *                    the argument value.
- * @param options Optional configuration for the argument parser,
- *                allowing you to specify a description or other metadata.
- * @returns A {@link Parser} that expects a single argument value and produces
- *          the parsed value of type {@link T}.
- */
-declare function argument<T>(valueParser: ValueParser<T>, options?: ArgumentOptions): Parser<T, ValueParserResult<T> | undefined>;
-/**
- * Creates a parser that makes another parser optional, allowing it to succeed
- * without consuming input if the wrapped parser fails to match.
- * If the wrapped parser succeeds, this returns its value.
- * If the wrapped parser fails, this returns `undefined` without consuming input.
- * @template TValue The type of the value returned by the wrapped parser.
- * @template TState The type of the state used by the wrapped parser.
- * @param parser The {@link Parser} to make optional.
- * @returns A {@link Parser} that produces either the result of the wrapped parser
- *          or `undefined` if the wrapped parser fails to match.
- */
-declare function optional<TValue, TState>(parser: Parser<TValue, TState>): Parser<TValue | undefined, [TState] | undefined>;
-/**
- * Options for the {@link withDefault} parser.
- */
-interface WithDefaultOptions {
-  /**
-   * Custom message to display in help output instead of the formatted default value.
-   * This allows showing descriptive text like "SERVICE_URL environment variable"
-   * instead of the actual default value.
-   *
-   * @example
-   * ```typescript
-   * withDefault(
-   *   option("--url", url()),
-   *   process.env["SERVICE_URL"],
-   *   { message: message`${envVar("SERVICE_URL")} environment variable` }
-   * )
-   * ```
-   */
-  readonly message?: Message;
-}
-/**
- * Error type for structured error messages in {@link withDefault} default value callbacks.
- * Unlike regular errors that only support string messages, this error type accepts
- * a {@link Message} object that supports rich formatting, colors, and structured content.
- *
- * @example
- * ```typescript
- * withDefault(option("--url", url()), () => {
- *   if (!process.env.INSTANCE_URL) {
- *     throw new WithDefaultError(
- *       message`Environment variable ${envVar("INSTANCE_URL")} is not set.`
- *     );
- *   }
- *   return new URL(process.env.INSTANCE_URL);
- * })
- * ```
- *
- * @since 0.5.0
- */
-declare class WithDefaultError extends Error {
-  /**
-   * The structured message associated with this error.
-   */
-  readonly errorMessage: Message;
-  /**
-   * Creates a new WithDefaultError with a structured message.
-   * @param message The structured {@link Message} describing the error.
-   */
-  constructor(message: Message);
-}
-/**
- * Creates a parser that makes another parser use a default value when it fails
- * to match or consume input. This is similar to {@link optional}, but instead
- * of returning `undefined` when the wrapped parser doesn't match, it returns
- * a specified default value.
- * @template TValue The type of the value returned by the wrapped parser.
- * @template TState The type of the state used by the wrapped parser.
- * @template TDefault The type of the default value.
- * @param parser The {@link Parser} to wrap with default behavior.
- * @param defaultValue The default value to return when the wrapped parser
- *                     doesn't match or consume input. Can be a value of type
- *                     {@link TDefault} or a function that returns such a value.
- * @returns A {@link Parser} that produces either the result of the wrapped parser
- *          or the default value if the wrapped parser fails to match
- *          (union type {@link TValue} | {@link TDefault}).
- */
-declare function withDefault<TValue, TState, TDefault = TValue>(parser: Parser<TValue, TState>, defaultValue: TDefault | (() => TDefault)): Parser<TValue | TDefault, [TState] | undefined>;
-/**
- * Creates a parser that makes another parser use a default value when it fails
- * to match or consume input. This is similar to {@link optional}, but instead
- * of returning `undefined` when the wrapped parser doesn't match, it returns
- * a specified default value.
- * @template TValue The type of the value returned by the wrapped parser.
- * @template TState The type of the state used by the wrapped parser.
- * @template TDefault The type of the default value.
- * @param parser The {@link Parser} to wrap with default behavior.
- * @param defaultValue The default value to return when the wrapped parser
- *                     doesn't match or consume input. Can be a value of type
- *                     {@link TDefault} or a function that returns such a value.
- * @param options Optional configuration including custom help display message.
- * @returns A {@link Parser} that produces either the result of the wrapped parser
- *          or the default value if the wrapped parser fails to match
- *          (union type {@link TValue} | {@link TDefault}).
- * @since 0.5.0
- */
-declare function withDefault<TValue, TState, TDefault = TValue>(parser: Parser<TValue, TState>, defaultValue: TDefault | (() => TDefault), options?: WithDefaultOptions): Parser<TValue | TDefault, [TState] | undefined>;
-/**
- * Creates a parser that transforms the result value of another parser using
- * a mapping function. This enables value transformation while preserving
- * the original parser's parsing logic and state management.
- *
- * The `map()` function is useful for:
- * - Converting parsed values to different types
- * - Applying transformations like string formatting or boolean inversion
- * - Computing derived values from parsed input
- * - Creating reusable transformations that can be applied to any parser
- *
- * @template T The type of the value produced by the original parser.
- * @template U The type of the value produced by the mapping function.
- * @template TState The type of the state used by the original parser.
- * @param parser The {@link Parser} whose result will be transformed.
- * @param transform A function that transforms the parsed value from type T to type U.
- * @returns A {@link Parser} that produces the transformed value of type U
- *          while preserving the original parser's state type and parsing behavior.
- *
- * @example
- * ```typescript
- * // Transform boolean flag to its inverse
- * const parser = object({
- *   disallow: map(option("--allow"), b => !b)
- * });
- *
- * // Transform string to uppercase
- * const upperParser = map(argument(string()), s => s.toUpperCase());
- *
- * // Transform number to formatted string
- * const prefixedParser = map(option("-n", integer()), n => `value: ${n}`);
- * ```
- */
-declare function map<T, U, TState>(parser: Parser<T, TState>, transform: (value: T) => U): Parser<U, TState>;
-/**
- * Options for the {@link multiple} parser.
- */
-interface MultipleOptions {
-  /**
-   * The minimum number of occurrences required for the parser to succeed.
-   * If the number of occurrences is less than this value,
-   * the parser will fail with an error.
-   * @default `0`
-   */
-  readonly min?: number;
-  /**
-   * The maximum number of occurrences allowed for the parser.
-   * If the number of occurrences exceeds this value,
-   * the parser will fail with an error.
-   * @default `Infinity`
-   */
-  readonly max?: number;
-}
-/**
- * Creates a parser that allows multiple occurrences of a given parser.
- * This parser can be used to parse multiple values of the same type,
- * such as multiple command-line arguments or options.
- * @template TValue The type of the value that the parser produces.
- * @template TState The type of the state used by the parser.
- * @param parser The {@link Parser} to apply multiple times.
- * @param options Optional configuration for the parser,
- *                allowing you to specify the minimum and maximum number of
- *                occurrences allowed.
- * @returns A {@link Parser} that produces an array of values
- *          of type {@link TValue} and an array of states
- *          of type {@link TState}.
- */
-declare function multiple<TValue, TState>(parser: Parser<TValue, TState>, options?: MultipleOptions): Parser<readonly TValue[], readonly TState[]>;
-/**
- * Creates a parser that combines multiple parsers into a single object parser.
- * Each parser in the object is applied to parse different parts of the input,
- * and the results are combined into an object with the same structure.
- * @template T A record type where each value is a {@link Parser}.
- * @param parsers An object containing named parsers that will be combined
- *                into a single object parser.
- * @returns A {@link Parser} that produces an object with the same keys as
- *          the input, where each value is the result of the corresponding
- *          parser.
- */
-declare function object<T extends {
-  readonly [key: string | symbol]: Parser<unknown, unknown>;
-}>(parsers: T): Parser<{ readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
-/**
- * Creates a labeled parser that combines multiple parsers into a single
- * object parser with an associated label for documentation or error reporting.
- * @template T A record type where each value is a {@link Parser}.
- * @param label A descriptive label for this parser group, used for
- *              documentation and error messages.
- * @param parsers An object containing named parsers that will be combined
- *                into a single object parser.
- * @returns A {@link Parser} that produces an object with the same keys as
- *          the input, where each value is the result of the corresponding
- *          parser.
- */
-declare function object<T extends {
-  readonly [key: string | symbol]: Parser<unknown, unknown>;
-}>(label: string, parsers: T): Parser<{ readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
-/**
- * Creates a parser that combines multiple parsers into a sequential tuple parser.
- * The parsers are applied in the order they appear in the array, and all must
- * succeed for the tuple parser to succeed.
- * @template T A readonly array type where each element is a {@link Parser}.
- * @param parsers An array of parsers that will be applied sequentially
- *                to create a tuple of their results.
- * @returns A {@link Parser} that produces a readonly tuple with the same length
- *          as the input array, where each element is the result of the
- *          corresponding parser.
- */
-declare function tuple<const T extends readonly Parser<unknown, unknown>[]>(parsers: T): Parser<{ readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
-/**
- * Creates a labeled parser that combines multiple parsers into a sequential
- * tuple parser with an associated label for documentation or error reporting.
- * @template T A readonly array type where each element is a {@link Parser}.
- * @param label A descriptive label for this parser group, used for
- *              documentation and error messages.
- * @param parsers An array of parsers that will be applied sequentially
- *                to create a tuple of their results.
- * @returns A {@link Parser} that produces a readonly tuple with the same length
- *          as the input array, where each element is the result of the
- *          corresponding parser.
- */
-declare function tuple<const T extends readonly Parser<unknown, unknown>[]>(label: string, parsers: T): Parser<{ readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
-/**
- * Creates a parser that combines two mutually exclusive parsers into one.
- * The resulting parser will try each of the provided parsers in order,
- * and return the result of the first successful parser.
- * @template TA The type of the value returned by the first parser.
- * @template TB The type of the value returned by the second parser.
- * @template TStateA The type of the state used by the first parser.
- * @template TStateB The type of the state used by the second parser.
- * @param a The first {@link Parser} to try.
- * @param b The second {@link Parser} to try.
- * @returns A {@link Parser} that tries to parse using the provided parsers
- *          in order, returning the result of the first successful parser.
- */
-declare function or<TA, TB, TStateA, TStateB>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>): Parser<TA | TB, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>]>;
-/**
- * Creates a parser that combines three mutually exclusive parsers into one.
- * The resulting parser will try each of the provided parsers in order,
- * and return the result of the first successful parser.
- * @template TA The type of the value returned by the first parser.
- * @template TB The type of the value returned by the second parser.
- * @template TC The type of the value returned by the third parser.
- * @template TStateA The type of the state used by the first parser.
- * @template TStateB The type of the state used by the second parser.
- * @template TStateC The type of the state used by the third parser.
- * @param a The first {@link Parser} to try.
- * @param b The second {@link Parser} to try.
- * @param c The third {@link Parser} to try.
- * @return A {@link Parser} that tries to parse using the provided parsers
- *         in order, returning the result of the first successful parser.
- */
-declare function or<TA, TB, TC, TStateA, TStateB, TStateC>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>): Parser<TA | TB | TC, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>]>;
-/**
- * Creates a parser that combines four mutually exclusive parsers into one.
- * The resulting parser will try each of the provided parsers in order,
- * and return the result of the first successful parser.
- * @template TA The type of the value returned by the first parser.
- * @template TB The type of the value returned by the second parser.
- * @template TC The type of the value returned by the third parser.
- * @template TD The type of the value returned by the fourth parser.
- * @template TStateA The type of the state used by the first parser.
- * @template TStateB The type of the state used by the second parser.
- * @template TStateC The type of the state used by the third parser.
- * @template TStateD The type of the state used by the fourth parser.
- * @param a The first {@link Parser} to try.
- * @param b The second {@link Parser} to try.
- * @param c The third {@link Parser} to try.
- * @param d The fourth {@link Parser} to try.
- * @return A {@link Parser} that tries to parse using the provided parsers
- *         in order, returning the result of the first successful parser.
- */
-declare function or<TA, TB, TC, TD, TStateA, TStateB, TStateC, TStateD>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>): Parser<TA | TB | TC | TD, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>]>;
-/**
- * Creates a parser that combines five mutually exclusive parsers into one.
- * The resulting parser will try each of the provided parsers in order,
- * and return the result of the first successful parser.
- * @template TA The type of the value returned by the first parser.
- * @template TB The type of the value returned by the second parser.
- * @template TC The type of the value returned by the third parser.
- * @template TD The type of the value returned by the fourth parser.
- * @template TE The type of the value returned by the fifth parser.
- * @template TStateA The type of the state used by the first parser.
- * @template TStateB The type of the state used by the second parser.
- * @template TStateC The type of the state used by the third parser.
- * @template TStateD The type of the state used by the fourth parser.
- * @template TStateE The type of the state used by the fifth parser.
- * @param a The first {@link Parser} to try.
- * @param b The second {@link Parser} to try.
- * @param c The third {@link Parser} to try.
- * @param d The fourth {@link Parser} to try.
- * @param e The fifth {@link Parser} to try.
- * @return A {@link Parser} that tries to parse using the provided parsers
- *         in order, returning the result of the first successful parser.
- */
-declare function or<TA, TB, TC, TD, TE, TStateA, TStateB, TStateC, TStateD, TStateE>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>): Parser<TA | TB | TC | TD | TE, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>]>;
-/**
- * Creates a parser that combines six mutually exclusive parsers into one.
- * The resulting parser will try each of the provided parsers in order,
- * and return the result of the first successful parser.
- * @template TA The type of the value returned by the first parser.
- * @template TB The type of the value returned by the second parser.
- * @template TC The type of the value returned by the third parser.
- * @template TD The type of the value returned by the fourth parser.
- * @template TE The type of the value returned by the fifth parser.
- * @template TF The type of the value returned by the sixth parser.
- * @template TStateA The type of the state used by the first parser.
- * @template TStateB The type of the state used by the second parser.
- * @template TStateC The type of the state used by the third parser.
- * @template TStateD The type of the state used by the fourth parser.
- * @template TStateE The type of the state used by the fifth parser.
- * @template TStateF The type of the state used by the sixth parser.
- * @param a The first {@link Parser} to try.
- * @param b The second {@link Parser} to try.
- * @param c The third {@link Parser} to try.
- * @param d The fourth {@link Parser} to try.
- * @param e The fifth {@link Parser} to try.
- * @param f The sixth {@link Parser} to try.
- * @return A {@link Parser} that tries to parse using the provided parsers
- *         in order, returning the result of the first successful parser.
- * @since 0.3.0
- */
-declare function or<TA, TB, TC, TD, TE, TF, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>): Parser<TA | TB | TC | TD | TE | TF, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>]>;
-/**
- * Creates a parser that combines seven mutually exclusive parsers into one.
- * The resulting parser will try each of the provided parsers in order,
- * and return the result of the first successful parser.
- * @template TA The type of the value returned by the first parser.
- * @template TB The type of the value returned by the second parser.
- * @template TC The type of the value returned by the third parser.
- * @template TD The type of the value returned by the fourth parser.
- * @template TE The type of the value returned by the fifth parser.
- * @template TF The type of the value returned by the sixth parser.
- * @template TG The type of the value returned by the seventh parser.
- * @template TStateA The type of the state used by the first parser.
- * @template TStateB The type of the state used by the second parser.
- * @template TStateC The type of the state used by the third parser.
- * @template TStateD The type of the state used by the fourth parser.
- * @template TStateE The type of the state used by the fifth parser.
- * @template TStateF The type of the state used by the sixth parser.
- * @template TStateG The type of the state used by the seventh parser.
- * @param a The first {@link Parser} to try.
- * @param b The second {@link Parser} to try.
- * @param c The third {@link Parser} to try.
- * @param d The fourth {@link Parser} to try.
- * @param e The fifth {@link Parser} to try.
- * @param f The sixth {@link Parser} to try.
- * @param g The seventh {@link Parser} to try.
- * @return A {@link Parser} that tries to parse using the provided parsers
- *         in order, returning the result of the first successful parser.
- * @since 0.3.0
- */
-declare function or<TA, TB, TC, TD, TE, TF, TG, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>): Parser<TA | TB | TC | TD | TE | TF | TG, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>]>;
-/**
- * Creates a parser that combines eight mutually exclusive parsers into one.
- * The resulting parser will try each of the provided parsers in order,
- * and return the result of the first successful parser.
- * @template TA The type of the value returned by the first parser.
- * @template TB The type of the value returned by the second parser.
- * @template TC The type of the value returned by the third parser.
- * @template TD The type of the value returned by the fourth parser.
- * @template TE The type of the value returned by the fifth parser.
- * @template TF The type of the value returned by the sixth parser.
- * @template TG The type of the value returned by the seventh parser.
- * @template TH The type of the value returned by the eighth parser.
- * @template TStateA The type of the state used by the first parser.
- * @template TStateB The type of the state used by the second parser.
- * @template TStateC The type of the state used by the third parser.
- * @template TStateD The type of the state used by the fourth parser.
- * @template TStateE The type of the state used by the fifth parser.
- * @template TStateF The type of the state used by the sixth parser.
- * @template TStateG The type of the state used by the seventh parser.
- * @template TStateH The type of the state used by the eighth parser.
- * @param a The first {@link Parser} to try.
- * @param b The second {@link Parser} to try.
- * @param c The third {@link Parser} to try.
- * @param d The fourth {@link Parser} to try.
- * @param e The fifth {@link Parser} to try.
- * @param f The sixth {@link Parser} to try.
- * @param g The seventh {@link Parser} to try.
- * @param h The eighth {@link Parser} to try.
- * @return A {@link Parser} that tries to parse using the provided parsers
- *         in order, returning the result of the first successful parser.
- * @since 0.3.0
- */
-declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>, h: Parser<TH, TStateH>): Parser<TA | TB | TC | TD | TE | TF | TG | TH, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>] | [7, ParserResult<TStateH>]>;
-/**
- * Creates a parser that combines nine mutually exclusive parsers into one.
- * The resulting parser will try each of the provided parsers in order,
- * and return the result of the first successful parser.
- * @template TA The type of the value returned by the first parser.
- * @template TB The type of the value returned by the second parser.
- * @template TC The type of the value returned by the third parser.
- * @template TD The type of the value returned by the fourth parser.
- * @template TE The type of the value returned by the fifth parser.
- * @template TF The type of the value returned by the sixth parser.
- * @template TG The type of the value returned by the seventh parser.
- * @template TH The type of the value returned by the eighth parser.
- * @template TI The type of the value returned by the ninth parser.
- * @template TStateA The type of the state used by the first parser.
- * @template TStateB The type of the state used by the second parser.
- * @template TStateC The type of the state used by the third parser.
- * @template TStateD The type of the state used by the fourth parser.
- * @template TStateE The type of the state used by the fifth parser.
- * @template TStateF The type of the state used by the sixth parser.
- * @template TStateG The type of the state used by the seventh parser.
- * @template TStateH The type of the state used by the eighth parser.
- * @template TStateI The type of the state used by the ninth parser.
- * @param a The first {@link Parser} to try.
- * @param b The second {@link Parser} to try.
- * @param c The third {@link Parser} to try.
- * @param d The fourth {@link Parser} to try.
- * @param e The fifth {@link Parser} to try.
- * @param f The sixth {@link Parser} to try.
- * @param g The seventh {@link Parser} to try.
- * @param h The eighth {@link Parser} to try.
- * @param i The ninth {@link Parser} to try.
- * @return A {@link Parser} that tries to parse using the provided parsers
- *         in order, returning the result of the first successful parser.
- * @since 0.3.0
- */
-declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TI, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>, h: Parser<TH, TStateH>, i: Parser<TI, TStateI>): Parser<TA | TB | TC | TD | TE | TF | TG | TH | TI, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>] | [7, ParserResult<TStateH>] | [8, ParserResult<TStateI>]>;
-/**
- * Creates a parser that combines ten mutually exclusive parsers into one.
- * The resulting parser will try each of the provided parsers in order,
- * and return the result of the first successful parser.
- * @template TA The type of the value returned by the first parser.
- * @template TB The type of the value returned by the second parser.
- * @template TC The type of the value returned by the third parser.
- * @template TD The type of the value returned by the fourth parser.
- * @template TE The type of the value returned by the fifth parser.
- * @template TF The type of the value returned by the sixth parser.
- * @template TG The type of the value returned by the seventh parser.
- * @template TH The type of the value returned by the eighth parser.
- * @template TI The type of the value returned by the ninth parser.
- * @template TJ The type of the value returned by the tenth parser.
- * @template TStateA The type of the state used by the first parser.
- * @template TStateB The type of the state used by the second parser.
- * @template TStateC The type of the state used by the third parser.
- * @template TStateD The type of the state used by the fourth parser.
- * @template TStateE The type of the state used by the fifth parser.
- * @template TStateF The type of the state used by the sixth parser.
- * @template TStateG The type of the state used by the seventh parser.
- * @template TStateH The type of the state used by the eighth parser.
- * @template TStateI The type of the state used by the ninth parser.
- * @template TStateJ The type of the state used by the tenth parser.
- * @param a The first {@link Parser} to try.
- * @param b The second {@link Parser} to try.
- * @param c The third {@link Parser} to try.
- * @param d The fourth {@link Parser} to try.
- * @param e The fifth {@link Parser} to try.
- * @param f The sixth {@link Parser} to try.
- * @param g The seventh {@link Parser} to try.
- * @param h The eighth {@link Parser} to try.
- * @param i The ninth {@link Parser} to try.
- * @param j The tenth {@link Parser} to try.
- * @return A {@link Parser} that tries to parse using the provided parsers
- *         in order, returning the result of the first successful parser.
- * @since 0.3.0
- */
-declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>, h: Parser<TH, TStateH>, i: Parser<TI, TStateI>, j: Parser<TJ, TStateJ>): Parser<TA | TB | TC | TD | TE | TF | TG | TH | TI | TJ, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>] | [7, ParserResult<TStateH>] | [8, ParserResult<TStateI>] | [9, ParserResult<TStateJ>]>;
-/**
- * Creates a parser that combines two mutually exclusive parsers into one,
- * selecting the parser that consumes the most tokens.
- * The resulting parser will try both parsers and return the result
- * of the parser that consumed more input tokens.
- * @template TA The type of the value returned by the first parser.
- * @template TB The type of the value returned by the second parser.
- * @template TStateA The type of the state used by the first parser.
- * @template TStateB The type of the state used by the second parser.
- * @param a The first {@link Parser} to try.
- * @param b The second {@link Parser} to try.
- * @returns A {@link Parser} that tries to parse using both parsers
- *          and returns the result of the parser that consumed more tokens.
- * @since 0.3.0
- */
-declare function longestMatch<TA, TB, TStateA, TStateB>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>): Parser<TA | TB, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>]>;
-/**
- * Creates a parser that combines three mutually exclusive parsers into one,
- * selecting the parser that consumes the most tokens.
- * The resulting parser will try all parsers and return the result
- * of the parser that consumed the most input tokens.
- * @template TA The type of the value returned by the first parser.
- * @template TB The type of the value returned by the second parser.
- * @template TC The type of the value returned by the third parser.
- * @template TStateA The type of the state used by the first parser.
- * @template TStateB The type of the state used by the second parser.
- * @template TStateC The type of the state used by the third parser.
- * @param a The first {@link Parser} to try.
- * @param b The second {@link Parser} to try.
- * @param c The third {@link Parser} to try.
- * @returns A {@link Parser} that tries to parse using all parsers
- *          and returns the result of the parser that consumed the most tokens.
- * @since 0.3.0
- */
-declare function longestMatch<TA, TB, TC, TStateA, TStateB, TStateC>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>): Parser<TA | TB | TC, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>]>;
-/**
- * Creates a parser that combines four mutually exclusive parsers into one,
- * selecting the parser that consumes the most tokens.
- * The resulting parser will try all parsers and return the result
- * of the parser that consumed the most input tokens.
- * @template TA The type of the value returned by the first parser.
- * @template TB The type of the value returned by the second parser.
- * @template TC The type of the value returned by the third parser.
- * @template TD The type of the value returned by the fourth parser.
- * @template TStateA The type of the state used by the first parser.
- * @template TStateB The type of the state used by the second parser.
- * @template TStateC The type of the state used by the third parser.
- * @template TStateD The type of the state used by the fourth parser.
- * @param a The first {@link Parser} to try.
- * @param b The second {@link Parser} to try.
- * @param c The third {@link Parser} to try.
- * @param d The fourth {@link Parser} to try.
- * @returns A {@link Parser} that tries to parse using all parsers
- *          and returns the result of the parser that consumed the most tokens.
- * @since 0.3.0
- */
-declare function longestMatch<TA, TB, TC, TD, TStateA, TStateB, TStateC, TStateD>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>): Parser<TA | TB | TC | TD, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>]>;
-/**
- * Creates a parser that combines five mutually exclusive parsers into one,
- * selecting the parser that consumes the most tokens.
- * The resulting parser will try all parsers and return the result
- * of the parser that consumed the most input tokens.
- * @template TA The type of the value returned by the first parser.
- * @template TB The type of the value returned by the second parser.
- * @template TC The type of the value returned by the third parser.
- * @template TD The type of the value returned by the fourth parser.
- * @template TE The type of the value returned by the fifth parser.
- * @template TStateA The type of the state used by the first parser.
- * @template TStateB The type of the state used by the second parser.
- * @template TStateC The type of the state used by the third parser.
- * @template TStateD The type of the state used by the fourth parser.
- * @template TStateE The type of the state used by the fifth parser.
- * @param a The first {@link Parser} to try.
- * @param b The second {@link Parser} to try.
- * @param c The third {@link Parser} to try.
- * @param d The fourth {@link Parser} to try.
- * @param e The fifth {@link Parser} to try.
- * @returns A {@link Parser} that tries to parse using all parsers
- *          and returns the result of the parser that consumed the most tokens.
- * @since 0.3.0
- */
-declare function longestMatch<TA, TB, TC, TD, TE, TStateA, TStateB, TStateC, TStateD, TStateE>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>): Parser<TA | TB | TC | TD | TE, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>]>;
-/**
- * Helper type to check if all members of a union are object-like.
- * This allows merge() to work with parsers like withDefault() that produce union types.
- */
-type AllObjectLike<T> = T extends readonly unknown[] ? never : T extends Record<string | symbol, unknown> ? T : never;
-/**
- * Helper type to extract object-like types from parser value types,
- * including union types where all members are objects.
- */
-type ExtractObjectTypes<P> = P extends Parser<infer V, unknown> ? [AllObjectLike<V>] extends [never] ? never : V : never;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the two parsers into a single object.
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>>(a: ExtractObjectTypes<TA> extends never ? never : TA, b: ExtractObjectTypes<TB> extends never ? never : TB): Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser
- * with a label for documentation and help text organization.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @param label A descriptive label for this merged group, used for
- *              documentation and help messages.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the two parsers into a single object.
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>>(label: string, a: ExtractObjectTypes<TA> extends never ? never : TA, b: ExtractObjectTypes<TB> extends never ? never : TB): Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the two parsers into a single object.
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>>(a: ExtractObjectTypes<TA> extends never ? never : TA, b: ExtractObjectTypes<TB> extends never ? never : TB, c: ExtractObjectTypes<TC> extends never ? never : TC): Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser
- * with a label for documentation and help text organization.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @param label A descriptive label for this merged group, used for
- *              documentation and help messages.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the two parsers into a single object.
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @template TD The type of the fourth parser.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @param d The fourth {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the two parsers into a single object.
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>>(a: TA, b: TB, c: TC, d: TD): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser
- * with a label for documentation and help text organization.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @template TD The type of the fourth parser.
- * @param label A descriptive label for this merged group, used for
- *              documentation and help messages.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @param d The fourth {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the two parsers into a single object.
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @template TD The type of the fourth parser.
- * @template TE The type of the fifth parser.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @param d The fourth {@link object} parser to merge.
- * @param e The fifth {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the two parsers into a single object.
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>>(a: ExtractObjectTypes<TA> extends never ? never : TA, b: ExtractObjectTypes<TB> extends never ? never : TB, c: ExtractObjectTypes<TC> extends never ? never : TC, d: ExtractObjectTypes<TD> extends never ? never : TD, e: ExtractObjectTypes<TE> extends never ? never : TE): Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser
- * with a label for documentation and help text organization.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @template TD The type of the fourth parser.
- * @template TE The type of the fifth parser.
- * @param label A descriptive label for this merged group, used for
- *              documentation and help messages.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @param d The fourth {@link object} parser to merge.
- * @param e The fifth {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the two parsers into a single object.
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @template TD The type of the fourth parser.
- * @template TE The type of the fifth parser.
- * @template TF The type of the sixth parser.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @param d The fourth {@link object} parser to merge.
- * @param e The fifth {@link object} parser to merge.
- * @param f The sixth {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the parsers into a single object.
- * @since 0.4.0
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>>(a: TA, b: TB, c: TC, d: TD, e: TE, f: TF): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser
- * with a label for documentation and help text organization.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @template TD The type of the fourth parser.
- * @template TE The type of the fifth parser.
- * @template TF The type of the sixth parser.
- * @param label A descriptive label for this merged group, used for
- *              documentation and help messages.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @param d The fourth {@link object} parser to merge.
- * @param e The fifth {@link object} parser to merge.
- * @param f The sixth {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the parsers into a single object.
- * @since 0.4.0
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE, f: TF): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @template TD The type of the fourth parser.
- * @template TE The type of the fifth parser.
- * @template TF The type of the sixth parser.
- * @template TG The type of the seventh parser.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @param d The fourth {@link object} parser to merge.
- * @param e The fifth {@link object} parser to merge.
- * @param f The sixth {@link object} parser to merge.
- * @param g The seventh {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the parsers into a single object.
- * @since 0.4.0
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>>(a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser
- * with a label for documentation and help text organization.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @template TD The type of the fourth parser.
- * @template TE The type of the fifth parser.
- * @template TF The type of the sixth parser.
- * @template TG The type of the seventh parser.
- * @param label A descriptive label for this merged group, used for
- *              documentation and help messages.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @param d The fourth {@link object} parser to merge.
- * @param e The fifth {@link object} parser to merge.
- * @param f The sixth {@link object} parser to merge.
- * @param g The seventh {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the parsers into a single object.
- * @since 0.4.0
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @template TD The type of the fourth parser.
- * @template TE The type of the fifth parser.
- * @template TF The type of the sixth parser.
- * @template TG The type of the seventh parser.
- * @template TH The type of the eighth parser.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @param d The fourth {@link object} parser to merge.
- * @param e The fifth {@link object} parser to merge.
- * @param f The sixth {@link object} parser to merge.
- * @param g The seventh {@link object} parser to merge.
- * @param h The eighth {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the parsers into a single object.
- * @since 0.4.0
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>, TH extends Parser<unknown, unknown>>(a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser
- * with a label for documentation and help text organization.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @template TD The type of the fourth parser.
- * @template TE The type of the fifth parser.
- * @template TF The type of the sixth parser.
- * @template TG The type of the seventh parser.
- * @template TH The type of the eighth parser.
- * @param label A descriptive label for this merged group, used for
- *              documentation and help messages.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @param d The fourth {@link object} parser to merge.
- * @param e The fifth {@link object} parser to merge.
- * @param f The sixth {@link object} parser to merge.
- * @param g The seventh {@link object} parser to merge.
- * @param h The eighth {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the parsers into a single object.
- * @since 0.4.0
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>, TH extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @template TD The type of the fourth parser.
- * @template TE The type of the fifth parser.
- * @template TF The type of the sixth parser.
- * @template TG The type of the seventh parser.
- * @template TH The type of the eighth parser.
- * @template TI The type of the ninth parser.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @param d The fourth {@link object} parser to merge.
- * @param e The fifth {@link object} parser to merge.
- * @param f The sixth {@link object} parser to merge.
- * @param g The seventh {@link object} parser to merge.
- * @param h The eighth {@link object} parser to merge.
- * @param i The ninth {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the parsers into a single object.
- * @since 0.4.0
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>, TH extends Parser<unknown, unknown>, TI extends Parser<unknown, unknown>>(a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH, i: TI): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : ExtractObjectTypes<TI> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH> & ExtractObjectTypes<TI>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser
- * with a label for documentation and help text organization.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @template TD The type of the fourth parser.
- * @template TE The type of the fifth parser.
- * @template TF The type of the sixth parser.
- * @template TG The type of the seventh parser.
- * @template TH The type of the eighth parser.
- * @template TI The type of the ninth parser.
- * @param label A descriptive label for this merged group, used for
- *              documentation and help messages.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @param d The fourth {@link object} parser to merge.
- * @param e The fifth {@link object} parser to merge.
- * @param f The sixth {@link object} parser to merge.
- * @param g The seventh {@link object} parser to merge.
- * @param h The eighth {@link object} parser to merge.
- * @param i The ninth {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the parsers into a single object.
- * @since 0.4.0
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>, TH extends Parser<unknown, unknown>, TI extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH, i: TI): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : ExtractObjectTypes<TI> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH> & ExtractObjectTypes<TI>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @template TD The type of the fourth parser.
- * @template TE The type of the fifth parser.
- * @template TF The type of the sixth parser.
- * @template TG The type of the seventh parser.
- * @template TH The type of the eighth parser.
- * @template TI The type of the ninth parser.
- * @template TJ The type of the tenth parser.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @param d The fourth {@link object} parser to merge.
- * @param e The fifth {@link object} parser to merge.
- * @param f The sixth {@link object} parser to merge.
- * @param g The seventh {@link object} parser to merge.
- * @param h The eighth {@link object} parser to merge.
- * @param i The ninth {@link object} parser to merge.
- * @param j The tenth {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the parsers into a single object.
- * @since 0.4.0
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>, TH extends Parser<unknown, unknown>, TI extends Parser<unknown, unknown>, TJ extends Parser<unknown, unknown>>(a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH, i: TI, j: TJ): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : ExtractObjectTypes<TI> extends never ? never : ExtractObjectTypes<TJ> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH> & ExtractObjectTypes<TI> & ExtractObjectTypes<TJ>, Record<string | symbol, unknown>>;
-/**
- * Merges multiple {@link object} parsers into a single {@link object} parser
- * with a label for documentation and help text organization.
- * It is useful for combining multiple {@link object} parsers so that
- * the unified parser produces a single object containing all the values
- * from the individual parsers while separating the fields into multiple
- * groups.
- * @template TA The type of the first parser.
- * @template TB The type of the second parser.
- * @template TC The type of the third parser.
- * @template TD The type of the fourth parser.
- * @template TE The type of the fifth parser.
- * @template TF The type of the sixth parser.
- * @template TG The type of the seventh parser.
- * @template TH The type of the eighth parser.
- * @template TI The type of the ninth parser.
- * @template TJ The type of the tenth parser.
- * @param label A descriptive label for this merged group, used for
- *              documentation and help messages.
- * @param a The first {@link object} parser to merge.
- * @param b The second {@link object} parser to merge.
- * @param c The third {@link object} parser to merge.
- * @param d The fourth {@link object} parser to merge.
- * @param e The fifth {@link object} parser to merge.
- * @param f The sixth {@link object} parser to merge.
- * @param g The seventh {@link object} parser to merge.
- * @param h The eighth {@link object} parser to merge.
- * @param i The ninth {@link object} parser to merge.
- * @param j The tenth {@link object} parser to merge.
- * @return A new {@link object} parser that combines the values and states
- *         of the parsers into a single object.
- * @since 0.4.0
- */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>, TH extends Parser<unknown, unknown>, TI extends Parser<unknown, unknown>, TJ extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH, i: TI, j: TJ): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : ExtractObjectTypes<TI> extends never ? never : ExtractObjectTypes<TJ> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH> & ExtractObjectTypes<TI> & ExtractObjectTypes<TJ>, Record<string | symbol, unknown>>;
-/**
- * Concatenates two {@link tuple} parsers into a single parser that produces
- * a flattened tuple containing the values from both parsers in order.
- *
- * This is similar to {@link merge} for object parsers, but operates on tuple
- * parsers and preserves the sequential, positional nature of tuples by
- * flattening the results into a single tuple array.
- *
- * @example
- * ```typescript
- * const basicTuple = tuple([
- *   option("-v", "--verbose"),
- *   option("-p", "--port", integer()),
- * ]);
- *
- * const serverTuple = tuple([
- *   option("-h", "--host", string()),
- *   option("-d", "--debug"),
- * ]);
- *
- * const combined = concat(basicTuple, serverTuple);
- * // Type: Parser<[boolean, number, string, boolean], [BasicState, ServerState]>
- *
- * const result = parse(combined, ["-v", "-p", "8080", "-h", "localhost", "-d"]);
- * // result.value: [true, 8080, "localhost", true]
- * ```
- *
- * @template TA The value type of the first tuple parser.
- * @template TB The value type of the second tuple parser.
- * @template TStateA The state type of the first tuple parser.
- * @template TStateB The state type of the second tuple parser.
- * @param a The first {@link tuple} parser to concatenate.
- * @param b The second {@link tuple} parser to concatenate.
- * @return A new {@link tuple} parser that combines the values of both parsers
- *         into a single flattened tuple.
- * @since 0.2.0
- */
-declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TStateA, TStateB>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>): Parser<[...TA, ...TB], [TStateA, TStateB]>;
-/**
- * Concatenates three {@link tuple} parsers into a single parser that produces
- * a flattened tuple containing the values from all parsers in order.
- *
- * @template TA The value type of the first tuple parser.
- * @template TB The value type of the second tuple parser.
- * @template TC The value type of the third tuple parser.
- * @template TStateA The state type of the first tuple parser.
- * @template TStateB The state type of the second tuple parser.
- * @template TStateC The state type of the third tuple parser.
- * @param a The first {@link tuple} parser to concatenate.
- * @param b The second {@link tuple} parser to concatenate.
- * @param c The third {@link tuple} parser to concatenate.
- * @return A new {@link tuple} parser that combines the values of all parsers
- *         into a single flattened tuple.
- * @since 0.2.0
- */
-declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TC extends readonly unknown[], TStateA, TStateB, TStateC>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>): Parser<[...TA, ...TB, ...TC], [TStateA, TStateB, TStateC]>;
-/**
- * Concatenates four {@link tuple} parsers into a single parser that produces
- * a flattened tuple containing the values from all parsers in order.
- *
- * @template TA The value type of the first tuple parser.
- * @template TB The value type of the second tuple parser.
- * @template TC The value type of the third tuple parser.
- * @template TD The value type of the fourth tuple parser.
- * @template TStateA The state type of the first tuple parser.
- * @template TStateB The state type of the second tuple parser.
- * @template TStateC The state type of the third tuple parser.
- * @template TStateD The state type of the fourth tuple parser.
- * @param a The first {@link tuple} parser to concatenate.
- * @param b The second {@link tuple} parser to concatenate.
- * @param c The third {@link tuple} parser to concatenate.
- * @param d The fourth {@link tuple} parser to concatenate.
- * @return A new {@link tuple} parser that combines the values of all parsers
- *         into a single flattened tuple.
- * @since 0.2.0
- */
-declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TC extends readonly unknown[], TD extends readonly unknown[], TStateA, TStateB, TStateC, TStateD>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>): Parser<[...TA, ...TB, ...TC, ...TD], [TStateA, TStateB, TStateC, TStateD]>;
-/**
- * Concatenates five {@link tuple} parsers into a single parser that produces
- * a flattened tuple containing the values from all parsers in order.
- *
- * @template TA The value type of the first tuple parser.
- * @template TB The value type of the second tuple parser.
- * @template TC The value type of the third tuple parser.
- * @template TD The value type of the fourth tuple parser.
- * @template TE The value type of the fifth tuple parser.
- * @template TStateA The state type of the first tuple parser.
- * @template TStateB The state type of the second tuple parser.
- * @template TStateC The state type of the third tuple parser.
- * @template TStateD The state type of the fourth tuple parser.
- * @template TStateE The state type of the fifth tuple parser.
- * @param a The first {@link tuple} parser to concatenate.
- * @param b The second {@link tuple} parser to concatenate.
- * @param c The third {@link tuple} parser to concatenate.
- * @param d The fourth {@link tuple} parser to concatenate.
- * @param e The fifth {@link tuple} parser to concatenate.
- * @return A new {@link tuple} parser that combines the values of all parsers
- *         into a single flattened tuple.
- * @since 0.2.0
- */
-declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TC extends readonly unknown[], TD extends readonly unknown[], TE extends readonly unknown[], TStateA, TStateB, TStateC, TStateD, TStateE>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>): Parser<[...TA, ...TB, ...TC, ...TD, ...TE], [TStateA, TStateB, TStateC, TStateD, TStateE]>;
-/**
- * Options for the {@link command} parser.
- */
-interface CommandOptions {
-  /**
-   * A description of the command, used for documentation.
-   */
-  readonly description?: Message;
-}
-/**
- * The state type for the {@link command} parser.
- * @template TState The type of the inner parser's state.
- */
-type CommandState<TState> = undefined | ["matched", string] | ["parsing", TState];
-/**
- * Creates a parser that matches a specific subcommand name and then applies
- * an inner parser to the remaining arguments.
- * This is useful for building CLI tools with subcommands like git, npm, etc.
- * @template T The type of the value returned by the inner parser.
- * @template TState The type of the state used by the inner parser.
- * @param name The subcommand name to match (e.g., `"show"`, `"edit"`).
- * @param parser The {@link Parser} to apply after the command is matched.
- * @param options Optional configuration for the command parser, such as
- *                a description for documentation.
- * @returns A {@link Parser} that matches the command name and delegates
- *          to the inner parser for the remaining arguments.
- */
-declare function command<T, TState>(name: string, parser: Parser<T, TState>, options?: CommandOptions): Parser<T, CommandState<TState>>;
 /**
  * Infers the result value type of a {@link Parser}.
  * @template T The {@link Parser} to infer the result value type from.
@@ -1423,49 +193,6 @@ type Result<T> = {
  *          failure.
  */
 declare function parse<T>(parser: Parser<T, unknown>, args: readonly string[]): Result<T>;
-/**
- * Wraps a parser with a group label for documentation purposes.
- *
- * The `group()` function is a documentation-only wrapper that applies a label
- * to any parser for help text organization. This allows you to use clean code
- * structure with combinators like {@link merge} while maintaining well-organized
- * help text through group labeling.
- *
- * The wrapped parser has identical parsing behavior but generates documentation
- * fragments wrapped in a labeled section. This is particularly useful when
- * combining parsers using {@link merge}—you can wrap the merged result with
- * `group()` to add a section header in help output.
- *
- * @example
- * ```typescript
- * const apiOptions = merge(
- *   object({ endpoint: option("--endpoint", string()) }),
- *   object({ timeout: option("--timeout", integer()) })
- * );
- *
- * const groupedApiOptions = group("API Options", apiOptions);
- * // Now produces a labeled "API Options" section in help text
- * ```
- *
- * @example
- * ```typescript
- * // Can be used with any parser, not just merge()
- * const verboseGroup = group("Verbosity", object({
- *   verbose: option("-v", "--verbose"),
- *   quiet: option("-q", "--quiet")
- * }));
- * ```
- *
- * @template TValue The value type of the wrapped parser.
- * @template TState The state type of the wrapped parser.
- * @param label A descriptive label for this parser group, used for
- *              documentation and help text organization.
- * @param parser The parser to wrap with a group label.
- * @returns A new parser that behaves identically to the input parser
- *          but generates documentation within a labeled section.
- * @since 0.4.0
- */
-declare function group<TValue, TState>(label: string, parser: Parser<TValue, TState>): Parser<TValue, TState>;
 /**
  * Generates a documentation page for a parser based on its current state after
  * attempting to parse the provided arguments. This function is useful for
@@ -1501,4 +228,4 @@ declare function group<TValue, TState>(label: string, parser: Parser<TValue, TSt
  */
 declare function getDocPage(parser: Parser<unknown, unknown>, args?: readonly string[]): DocPage | undefined;
 //#endregion
-export { ArgumentOptions, CommandOptions, DocState, FlagOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, WithDefaultError, WithDefaultOptions, argument, command, concat, constant, flag, getDocPage, group, longestMatch, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault };
+export { ArgumentErrorOptions, ArgumentOptions, CommandErrorOptions, CommandOptions, DocState, FlagErrorOptions, FlagOptions, InferValue, LongestMatchErrorOptions, LongestMatchOptions, MultipleErrorOptions, MultipleOptions, ObjectErrorOptions, ObjectOptions, OptionErrorOptions, OptionOptions, OrErrorOptions, OrOptions, Parser, ParserContext, ParserResult, Result, WithDefaultError, WithDefaultOptions, argument, command, concat, constant, flag, getDocPage, group, longestMatch, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault };