@optique/core 1.0.0-dev.908 → 1.0.0

package/dist/valueparser.d.ts

@@ -1,6 +1,6 @@
 import { NonEmptyString, ensureNonEmptyString, isNonEmptyString } from "./nonempty.js";
 import { Message } from "./message.js";
-import { Mode, ModeIterable, ModeValue, Suggestion } from "./parser.js";
+import { Mode, ModeIterable, ModeValue, Suggestion } from "./internal/parser.js";
 
 //#region src/valueparser.d.ts
 
@@ -23,7 +23,7 @@ interface ValueParser<M extends Mode = "sync", T = unknown> {
    *
    * @since 0.9.0
    */
-  readonly $mode: M;
+  readonly mode: M;
   /**
    * The metavariable name for this parser.  Used in help messages
    * to indicate what kind of value this parser expects.  Usually
@@ -49,6 +49,33 @@ interface ValueParser<M extends Mode = "sync", T = unknown> {
    * @returns A string representation of the value.
    */
   format(value: T): string;
+  /**
+   * Normalizes a value of type {@link T} according to this parser's
+   * configuration.  This applies the same canonicalization that
+   * {@link parse} would apply (e.g., case conversion, separator
+   * normalization).  Built-in implementations delegate to {@link parse}
+   * internally, so values that would fail validation are returned
+   * unchanged rather than being canonicalized.
+   *
+   * When present, combinators like `withDefault()` call this method on
+   * default values so that runtime defaults match the representation
+   * that {@link parse} would produce.
+   *
+   * Parsers that do not apply any normalization during parsing do not
+   * need to implement this method.
+   *
+   * **Limitation:** For dependency-derived value parsers (created via
+   * `deriveFrom()` or `dependency().derive()`), this method uses the
+   * default dependency value to build the inner parser, not the
+   * dependency value resolved during the current parse.  This is the
+   * same trade-off that {@link format} makes.  As a result, defaults
+   * may not be normalized according to a non-default dependency value.
+   *
+   * @param value The value to normalize.
+   * @returns The normalized value.
+   * @since 1.0.0
+   */
+  normalize?(value: T): T;
   /**
    * Provides completion suggestions for values of this type.
    * This is optional and used for shell completion functionality.
@@ -69,6 +96,21 @@ interface ValueParser<M extends Mode = "sync", T = unknown> {
    * @since 0.10.0
    */
   readonly choices?: readonly T[];
+  /**
+   * A type-appropriate default value used as a stand-in during deferred
+   * prompt resolution.  When an interactive prompt is deferred during
+   * two-phase parsing, this value is used instead of an internal sentinel
+   * so that `map()` transforms and two-pass contexts always receive a valid
+   * value of type {@link T}.
+   *
+   * The placeholder does not need to be meaningful; it only needs to be
+   * a valid inhabitant of the result type that will not crash downstream
+   * transforms.  For example, `string()` uses `""`, `integer()` uses `0`,
+   * and `choice(["a", "b", "c"])` uses `"a"`.
+   *
+   * @since 1.0.0
+   */
+  readonly placeholder: T;
 }
 /**
  * Result type returned by {@link ValueParser#parse}.
@@ -83,12 +125,48 @@ type ValueParserResult<T> = {
   readonly success: true;
   /** The successfully parsed value of type {@link T}. */
   readonly value: T;
+  /**
+   * When `true`, indicates that the value is a placeholder stand-in for
+   * a deferred interactive prompt, not a real user-provided value.
+   * Combinators propagate this flag so that the two-phase parsing
+   * facade can strip deferred values before passing them to phase-two
+   * contexts.
+   *
+   * @since 1.0.0
+   */
+  readonly deferred?: true;
+  /**
+   * A recursive map describing which property keys in {@link value} hold
+   * deferred placeholder values.  Set by `object()`, `tuple()`, `merge()`,
+   * and other combinators.  Intentionally not propagated by `map()` because
+   * opaque transforms invalidate the inner key set.  Used by the two-phase
+   * facade to selectively replace only deferred fields with `undefined`
+   * while preserving non-deferred fields for phase-two context annotation
+   * collection.
+   *
+   * Each entry maps a property key to either `null` (the entire field is
+   * deferred) or another `DeferredMap` (the field is an object whose own
+   * sub-fields are partially deferred).
+   *
+   * @since 1.0.0
+   */
+  readonly deferredKeys?: DeferredMap;
 } | {
   /** Indicates that the parsing operation failed. */
   readonly success: false;
   /** The error message describing why the parsing failed. */
   readonly error: Message;
 };
+/**
+ * A recursive map that tracks which fields in a parsed object hold deferred
+ * placeholder values.  Each entry maps a property key to either `null`
+ * (the field is fully deferred and should be replaced with `undefined`)
+ * or another `DeferredMap` (the field is partially deferred — recurse into
+ * its sub-fields).
+ *
+ * @since 1.0.0
+ */
+type DeferredMap = ReadonlyMap<PropertyKey, DeferredMap | null>;
 /**
  * Options for creating a string parser.
  */
@@ -112,6 +190,14 @@ interface StringOptions {
    * to validate patterns before use.
    */
   readonly pattern?: RegExp;
+  /**
+   * A custom placeholder value used during deferred prompt resolution.
+   * Override the default `""` when a `pattern` constraint or downstream
+   * `map()` transform requires a non-empty or specially shaped string.
+   *
+   * @since 1.0.0
+   */
+  readonly placeholder?: string;
   /**
    * Custom error messages for various string parsing failures.
    * @since 0.5.0
@@ -193,6 +279,9 @@ type ChoiceOptions = ChoiceOptionsString;
  * A predicate function that checks if an object is a {@link ValueParser}.
  * @param object The object to check.
  * @return `true` if the object is a {@link ValueParser}, `false` otherwise.
+ * @throws {TypeError} If the object looks like a value parser (has `mode`,
+ *   `metavar`, `parse`, and `format`) but is missing the required
+ *   `placeholder` property.
  */
 declare function isValueParser<M extends Mode, T>(object: unknown): object is ValueParser<M, T>;
 /**
@@ -233,6 +322,31 @@ declare function choice<const T extends string>(choices: readonly T[], options?:
  * @since 0.9.0
  */
 declare function choice<const T extends number>(choices: readonly T[], options?: ChoiceOptionsNumber): ValueParser<"sync", T>;
+/**
+ * Validates that an option value, if present, is a boolean.
+ * Throws a {@link TypeError} if the value is defined but not a boolean.
+ *
+ * @template T The type of the options object.
+ * @param options The options object to check.
+ * @param key The key of the option to validate.
+ * @throws {TypeError} If the option value is defined but not a boolean.
+ * @since 1.0.0
+ */
+declare function checkBooleanOption<T extends object>(options: T | undefined, key: keyof T): void;
+/**
+ * Validates that an option value, if present, is one of the allowed values.
+ * Throws a {@link TypeError} if the value is defined but not in the allowed
+ * list.
+ *
+ * @template T The type of the options object.
+ * @param options The options object to check.
+ * @param key The key of the option to validate.
+ * @param allowed The list of allowed values.
+ * @throws {TypeError} If the option value is defined but not in the allowed
+ *   list.
+ * @since 1.0.0
+ */
+declare function checkEnumOption<T extends object>(options: T | undefined, key: keyof T, allowed: readonly string[]): void;
 /**
  * Creates a {@link ValueParser} for strings.
  *
@@ -279,6 +393,14 @@ interface IntegerOptionsNumber {
    * no maximum is enforced.
    */
   readonly max?: number;
+  /**
+   * A custom placeholder value used during deferred prompt resolution.
+   * Override the default `0` when `min`/`max` constraints or downstream
+   * `map()` transforms require a specific value.
+   *
+   * @since 1.0.0
+   */
+  readonly placeholder?: number;
   /**
    * Custom error messages for integer parsing failures.
    * @since 0.5.0
@@ -337,6 +459,14 @@ interface IntegerOptionsBigInt {
    * no maximum is enforced.
    */
   readonly max?: bigint;
+  /**
+   * A custom placeholder value used during deferred prompt resolution.
+   * Override the default `0n` when `min`/`max` constraints or downstream
+   * `map()` transforms require a specific value.
+   *
+   * @since 1.0.0
+   */
+  readonly placeholder?: bigint;
   /**
    * Custom error messages for bigint integer parsing failures.
    * @since 0.5.0
@@ -411,6 +541,14 @@ interface FloatOptions {
    * @default `false`
    */
   readonly allowInfinity?: boolean;
+  /**
+   * A custom placeholder value used during deferred prompt resolution.
+   * Override the default `0` when `min`/`max` constraints or downstream
+   * `map()` transforms require a specific value.
+   *
+   * @since 1.0.0
+   */
+  readonly placeholder?: number;
   /**
    * Custom error messages for float parsing failures.
    * @since 0.5.0
@@ -491,6 +629,8 @@ interface UrlOptions {
  * object.
  * @param options Configuration options for the URL parser.
  * @returns A {@link ValueParser} that converts string input to `URL` objects.
+ * @throws {TypeError} If any `allowedProtocols` entry is not a valid protocol
+ *   string ending with a colon (e.g., `"https:"`).
  */
 declare function url(options?: UrlOptions): ValueParser<"sync", URL>;
 /**
@@ -549,10 +689,38 @@ interface UuidOptions {
   readonly metavar?: NonEmptyString;
   /**
    * List of allowed UUID versions (e.g., `[4, 5]` for UUIDs version 4 and 5).
+   * Each version must be an integer between 1 and 8 (the standardized
+   * [RFC 9562] versions).  Duplicate entries are automatically removed.
    * If specified, the parser will validate that the UUID matches one of the
-   * allowed versions. If not specified, any valid UUID format is accepted.
+   * allowed versions.  If not specified, the accepted versions depend on
+   * the {@link strict} option.
+   *
+   * [RFC 9562]: https://www.rfc-editor.org/rfc/rfc9562
    */
   readonly allowedVersions?: readonly number[];
+  /**
+   * Whether to enforce strict [RFC 9562] validation.  When `true` (the
+   * default), the parser validates that the version digit is one of the
+   * currently standardized versions (1 through 8) and that the variant bits
+   * follow the RFC 9562 layout (`10xx`, i.e., hex digits `8`, `9`, `a`,
+   * or `b` at position 20 of the UUID string).
+   *
+   * The nil UUID (`00000000-0000-0000-0000-000000000000`) and max UUID
+   * (`ffffffff-ffff-ffff-ffff-ffffffffffff`) are accepted as special
+   * standard values regardless of this setting.
+   *
+   * When `false`, the parser only validates the UUID format without
+   * checking version or variant fields.
+   *
+   * When {@link allowedVersions} is provided, it takes precedence over the
+   * strict version check, but variant bit validation still applies if
+   * `strict` is `true`.
+   *
+   * [RFC 9562]: https://www.rfc-editor.org/rfc/rfc9562
+   * @default true
+   * @since 1.0.0
+   */
+  readonly strict?: boolean;
   /**
    * Custom error messages for UUID parsing failures.
    * @since 0.5.0
@@ -570,6 +738,12 @@ interface UuidOptions {
      * @since 0.5.0
      */
     disallowedVersion?: Message | ((version: number, allowedVersions: readonly number[]) => Message);
+    /**
+     * Custom error message when UUID variant bits are not RFC 9562 compliant.
+     * Can be a static message or a function that receives the input.
+     * @since 1.0.0
+     */
+    invalidVariant?: Message | ((input: string) => Message);
   };
 }
 /**
@@ -577,12 +751,23 @@ interface UuidOptions {
  *
  * This parser validates that the input is a well-formed UUID string in the
  * standard format: `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` where each `x`
- * is a hexadecimal digit.  The parser can optionally restrict to specific
- * UUID versions.
+ * is a hexadecimal digit.
+ *
+ * By default, the parser enforces strict [RFC 9562] validation: it requires
+ * a standardized version digit (1 through 8) and the RFC 9562 variant bits
+ * (`10xx`).  The nil and max UUIDs are accepted as special standard values.
+ * Set `strict: false` to disable the default RFC 9562 version/variant
+ * checks.  An explicit {@link UuidOptions.allowedVersions} list still
+ * constrains the version nibble even in lenient mode.
  *
+ * [RFC 9562]: https://www.rfc-editor.org/rfc/rfc9562
  * @param options Configuration options for the UUID parser.
  * @returns A {@link ValueParser} that converts string input to {@link Uuid}
  *          strings.
+ * @throws {TypeError} If any element of
+ *   {@link UuidOptions.allowedVersions} is not an integer.
+ * @throws {RangeError} If any element of
+ *   {@link UuidOptions.allowedVersions} is outside the range 1 to 8.
  */
 declare function uuid(options?: UuidOptions): ValueParser<"sync", Uuid>;
 /**
@@ -617,6 +802,13 @@ interface PortOptionsNumber {
    * @default `false`
    */
   readonly disallowWellKnown?: boolean;
+  /**
+   * A custom placeholder value used during deferred prompt resolution.
+   * Defaults to `min` (which itself defaults to `1`).
+   *
+   * @since 1.0.0
+   */
+  readonly placeholder?: number;
   /**
    * Custom error messages for port parsing failures.
    * @since 0.10.0
@@ -679,6 +871,13 @@ interface PortOptionsBigInt {
    * @default `false`
    */
   readonly disallowWellKnown?: boolean;
+  /**
+   * A custom placeholder value used during deferred prompt resolution.
+   * Defaults to `min` (which itself defaults to `1n`).
+   *
+   * @since 1.0.0
+   */
+  readonly placeholder?: bigint;
   /**
    * Custom error messages for port parsing failures.
    * @since 0.10.0
@@ -877,6 +1076,13 @@ interface HostnameOptions {
    * @default true
    */
   readonly allowLocalhost?: boolean;
+  /**
+   * A custom placeholder value used during deferred prompt resolution.
+   * Override when `allowLocalhost` or other constraints reject the default.
+   *
+   * @since 1.0.0
+   */
+  readonly placeholder?: string;
   /**
    * Maximum hostname length in characters.
    * @default 253
@@ -922,9 +1128,14 @@ interface HostnameOptions {
  * - Labels can contain alphanumeric characters and hyphens
  * - Labels cannot start or end with a hyphen
  * - Total length ≤ 253 characters (default)
+ * - Dotted all-numeric strings (e.g., `192.168.0.1`) are rejected as they
+ *   resemble IPv4 addresses rather than DNS hostnames
  *
  * @param options - Options for hostname validation.
  * @returns A value parser for hostnames.
+ * @throws {TypeError} If `allowWildcard`, `allowUnderscore`, or
+ *   `allowLocalhost` is not a boolean.
+ * @throws {RangeError} If `maxLength` is not a positive integer.
  * @since 0.10.0
  *
  * @example
@@ -966,7 +1177,9 @@ interface EmailOptions {
    */
   readonly allowDisplayName?: boolean;
   /**
-   * If `true`, converts email to lowercase.
+   * If `true`, converts the domain part of the email to lowercase.
+   * The local part is preserved as-is, since it is technically
+   * case-sensitive per RFC 5321.
    * @default false
    */
   readonly lowercase?: boolean;
@@ -975,6 +1188,13 @@ interface EmailOptions {
    * If specified, only emails from these domains are accepted.
    */
   readonly allowedDomains?: readonly string[];
+  /**
+   * Override the default placeholder value used for deferred parsing.
+   * When not specified, the placeholder is derived from the first entry in
+   * {@link allowedDomains} (or `"example.com"` when no domains are set).
+   * @since 1.0.0
+   */
+  readonly placeholder?: string | readonly string[];
   /**
    * Custom error messages for email parsing failures.
    */
@@ -1004,6 +1224,11 @@ interface EmailOptions {
  *
  * @param options - Options for email validation.
  * @returns A value parser for email addresses.
+ * @throws {TypeError} If any `allowedDomains` entry is not a string, has
+ *   leading/trailing whitespace, starts with `"@"`, is empty, lacks a dot,
+ *   has invalid hostname label syntax, or is an IPv4-like dotted-quad.
+ * @throws {TypeError} If `placeholder` type does not match `allowMultiple`
+ *   mode (string for single, array for multiple).
  * @since 0.10.0
  *
  * @example
@@ -1049,8 +1274,8 @@ interface SocketAddressValue {
  */
 interface SocketAddressOptions {
   /**
-   * The metavariable name for this parser.
-   * @default "HOST:PORT"
+   * The metavariable name for this parser.  If not specified, it is derived
+   * from the {@link separator} (e.g., `"HOST:PORT"` for `":"`).
    */
   readonly metavar?: NonEmptyString;
   /**
@@ -1123,6 +1348,9 @@ interface SocketAddressOptions {
  *
  * @param options - Options for socket address validation.
  * @returns A value parser for socket addresses.
+ * @throws {TypeError} If `separator` is an empty string.
+ * @throws {TypeError} If `separator` contains digit characters, since digits
+ *   in the separator would cause ambiguous splitting of port input.
  * @since 0.10.0
  *
  * @example
@@ -1185,8 +1413,8 @@ interface PortRangeOptionsNumber {
    */
   readonly type?: "number";
   /**
-   * The metavariable name for this parser.
-   * @default "PORT-PORT"
+   * The metavariable name for this parser.  If not specified, it is derived
+   * from the {@link separator} (e.g., `"PORT-PORT"` for `"-"`).
    */
   readonly metavar?: NonEmptyString;
   /**
@@ -1265,8 +1493,8 @@ interface PortRangeOptionsBigInt {
    */
   readonly type: "bigint";
   /**
-   * The metavariable name for this parser.
-   * @default "PORT-PORT"
+   * The metavariable name for this parser.  If not specified, it is derived
+   * from the {@link separator} (e.g., `"PORT-PORT"` for `"-"`).
    */
   readonly metavar?: NonEmptyString;
   /**
@@ -1346,6 +1574,11 @@ interface PortRangeOptionsBigInt {
  *
  * @param options - Options for port range validation.
  * @returns A value parser for port ranges.
+ * @throws {TypeError} If `options.type` is provided but is neither `"number"`
+ *   nor `"bigint"`.
+ * @throws {TypeError} If `separator` is an empty string.
+ * @throws {TypeError} If `separator` contains digit characters, since digits
+ *   in the separator would cause ambiguous splitting of numeric port input.
  * @since 0.10.0
  *
  * @example
@@ -1417,10 +1650,14 @@ interface MacAddressOptions {
  * Creates a value parser for MAC (Media Access Control) addresses.
  *
  * Validates MAC-48 addresses (6 octets, 12 hex digits) in various formats:
- * - Colon-separated: `00:1A:2B:3C:4D:5E`
- * - Hyphen-separated: `00-1A-2B-3C-4D-5E`
- * - Dot-separated (Cisco): `001A.2B3C.4D5E`
- * - No separator: `001A2B3C4D5E`
+ * - Colon-separated: `00:1A:2B:3C:4D:5E` (1–2 hex digits per octet)
+ * - Hyphen-separated: `00-1A-2B-3C-4D-5E` (1–2 hex digits per octet)
+ * - Dot-separated (Cisco): `001A.2B3C.4D5E` (exactly 4 hex digits per group)
+ * - No separator: `001A2B3C4D5E` (exactly 12 hex digits)
+ *
+ * Colon-separated and hyphen-separated formats accept single-digit octets
+ * (e.g., `0:1:2:3:4:5`), which are automatically zero-padded to canonical
+ * two-digit form (e.g., `00:01:02:03:04:05`).
  *
  * Returns the MAC address as a formatted string according to `case` and
  * `outputSeparator` options.
@@ -1467,13 +1704,27 @@ interface DomainOptions {
    * List of allowed top-level domains (e.g., ["com", "org", "net"]).
    * If specified, only domains with these TLDs are accepted.
    */
-  readonly allowedTLDs?: readonly string[];
+  readonly allowedTlds?: readonly string[];
   /**
    * Minimum number of domain labels (parts separated by dots).
    *
    * @default 2
    */
   readonly minLabels?: number;
+  /**
+   * Maximum domain length in characters.
+   * @default 253
+   * @since 1.0.0
+   */
+  readonly maxLength?: number;
+  /**
+   * A custom placeholder value used during deferred prompt resolution.
+   * Override when `allowedTlds`, `minLabels`, or other constraints
+   * reject the default `"example.com"`.
+   *
+   * @since 1.0.0
+   */
+  readonly placeholder?: string;
   /**
    * If `true`, converts domain to lowercase.
    *
@@ -1499,13 +1750,20 @@ interface DomainOptions {
      * Can be a static message or a function that receives the TLD
      * and allowed TLDs.
      */
-    tldNotAllowed?: Message | ((tld: string, allowedTLDs: readonly string[]) => Message);
+    tldNotAllowed?: Message | ((tld: string, allowedTlds: readonly string[]) => Message);
     /**
      * Custom error message when domain has too few labels.
      * Can be a static message or a function that receives the domain
      * and minimum labels.
      */
     tooFewLabels?: Message | ((domain: string, minLabels: number) => Message);
+    /**
+     * Custom error message when domain is too long.
+     * Can be a static message or a function that receives the domain
+     * and max length.
+     * @since 1.0.0
+     */
+    tooLong?: Message | ((domain: string, maxLength: number) => Message);
   };
 }
 /**
@@ -1517,6 +1775,14 @@ interface DomainOptions {
  *
  * @param options Parser options for domain validation.
  * @returns A parser that accepts valid domain names as strings.
+ * @throws {RangeError} If `maxLength` is not a positive integer.
+ * @throws {RangeError} If `minLabels` is not a positive integer.
+ * @throws {TypeError} If `allowSubdomains` or `lowercase` is not a boolean.
+ * @throws {TypeError} If any `allowedTlds` entry is not a string, is empty,
+ *   contains dots, has leading/trailing whitespace, or is not a valid DNS
+ *   label.
+ * @throws {TypeError} If `allowSubdomains` is `false` and `minLabels` is
+ *   greater than 2, since non-subdomain domains have exactly 2 labels.
  *
  * @example
  * ``` typescript
@@ -1530,7 +1796,7 @@ interface DomainOptions {
  * option("--root", domain({ allowSubdomains: false }))
  *
  * // Restrict to specific TLDs
- * option("--domain", domain({ allowedTLDs: ["com", "org", "net"] }))
+ * option("--domain", domain({ allowedTlds: ["com", "org", "net"] }))
  *
  * // Normalize to lowercase
  * option("--domain", domain({ lowercase: true }))
@@ -1827,6 +2093,50 @@ interface CidrOptions {
      * Can be a static message or a function that receives the prefix and maximum.
      */
     prefixAboveMaximum?: Message | ((prefix: number, max: number) => Message);
+    /**
+     * Custom error message when a private IPv4 address is used but disallowed.
+     * Can be a static message or a function that receives the IP.
+     * @since 1.0.0
+     */
+    privateNotAllowed?: Message | ((ip: string) => Message);
+    /**
+     * Custom error message when a loopback address is used but disallowed.
+     * Can be a static message or a function that receives the IP.
+     * @since 1.0.0
+     */
+    loopbackNotAllowed?: Message | ((ip: string) => Message);
+    /**
+     * Custom error message when a link-local address is used but disallowed.
+     * Can be a static message or a function that receives the IP.
+     * @since 1.0.0
+     */
+    linkLocalNotAllowed?: Message | ((ip: string) => Message);
+    /**
+     * Custom error message when a multicast address is used but disallowed.
+     * Can be a static message or a function that receives the IP.
+     * @since 1.0.0
+     */
+    multicastNotAllowed?: Message | ((ip: string) => Message);
+    /**
+     * Custom error message when the broadcast address is used but disallowed
+     * (IPv4 only).
+     * Can be a static message or a function that receives the IP.
+     * @since 1.0.0
+     */
+    broadcastNotAllowed?: Message | ((ip: string) => Message);
+    /**
+     * Custom error message when the zero address is used but disallowed.
+     * Can be a static message or a function that receives the IP.
+     * @since 1.0.0
+     */
+    zeroNotAllowed?: Message | ((ip: string) => Message);
+    /**
+     * Custom error message when a unique local address is used but disallowed
+     * (IPv6 only).
+     * Can be a static message or a function that receives the IP.
+     * @since 1.0.0
+     */
+    uniqueLocalNotAllowed?: Message | ((ip: string) => Message);
   };
 }
 /**
@@ -1856,4 +2166,4 @@ interface CidrOptions {
  */
 declare function cidr(options?: CidrOptions): ValueParser<"sync", CidrValue>;
 //#endregion
-export { ChoiceOptions, ChoiceOptionsBase, ChoiceOptionsNumber, ChoiceOptionsString, CidrOptions, CidrValue, DomainOptions, EmailOptions, FloatOptions, HostnameOptions, IntegerOptionsBigInt, IntegerOptionsNumber, IpOptions, Ipv4Options, Ipv6Options, LocaleOptions, MacAddressOptions, type Mode, type ModeIterable, type ModeValue, type NonEmptyString, PortOptionsBigInt, PortOptionsNumber, PortRangeOptionsBigInt, PortRangeOptionsNumber, PortRangeValueBigInt, PortRangeValueNumber, SocketAddressOptions, SocketAddressValue, StringOptions, UrlOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, choice, cidr, domain, email, ensureNonEmptyString, float, hostname, integer, ip, ipv4, ipv6, isNonEmptyString, isValueParser, locale, macAddress, port, portRange, socketAddress, string, url, uuid };
+export { ChoiceOptions, ChoiceOptionsBase, ChoiceOptionsNumber, ChoiceOptionsString, CidrOptions, CidrValue, DeferredMap, DomainOptions, EmailOptions, FloatOptions, HostnameOptions, IntegerOptionsBigInt, IntegerOptionsNumber, IpOptions, Ipv4Options, Ipv6Options, LocaleOptions, MacAddressOptions, type Mode, type ModeIterable, type ModeValue, type NonEmptyString, PortOptionsBigInt, PortOptionsNumber, PortRangeOptionsBigInt, PortRangeOptionsNumber, PortRangeValueBigInt, PortRangeValueNumber, SocketAddressOptions, SocketAddressValue, StringOptions, UrlOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, checkBooleanOption, checkEnumOption, choice, cidr, domain, email, ensureNonEmptyString, float, hostname, integer, ip, ipv4, ipv6, isNonEmptyString, isValueParser, locale, macAddress, port, portRange, socketAddress, string, url, uuid };