@silvery/commander 0.19.1 → 0.21.0

package/dist/index.d.mts

@@ -0,0 +1,719 @@
+import { a as date, c as int, d as path, f as port, h as url, i as csv, l as intRange, m as uint, n as StandardSchemaV1, o as email, p as regex, r as bool, s as float, t as CLIType, u as json } from "./presets-DTzPdB8a.mjs";
+import { Argument, Command as Command$1, CommanderError, Help, InvalidArgumentError, Option, OptionValues } from "commander";
+import * as zod from "zod";
+
+//#region src/command.d.ts
+/**
+ * Broad structural type for schema objects that have a `~standard` property.
+ * Matches both our `StandardSchemaV1<T>`, Zod v4's async-capable Standard Schema,
+ * and any other library implementing Standard Schema v1.
+ *
+ * Type extraction works via the `types` property (Standard Schema v1 convention).
+ */
+interface AnyStandardSchema {
+  readonly "~standard": {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly validate: (value: unknown, ...args: any[]) => any;
+    readonly types?: {
+      readonly output: unknown;
+    } | undefined;
+  };
+}
+/** Extract the output type from a Standard Schema v1 object. */
+type SchemaOutput<S extends AnyStandardSchema> = NonNullable<S["~standard"]["types"]>["output"];
+/**
+ * Extract the long option name from a flags string.
+ *
+ * Examples:
+ *   "-v, --verbose"        → "verbose"
+ *   "--port <n>"           → "port"
+ *   "--dry-run"            → "dry-run"
+ *   "--no-color"           → "no-color"
+ *   "-o, --output [path]"  → "output"
+ */
+type ExtractLongName<S extends string> = S extends `${string}--${infer Rest}` ? Rest extends `${infer Name} ${string}` ? Name : Rest : S extends `-${infer C}, ${infer Rest}` ? Rest extends `${infer Name} ${string}` ? Name : Rest : S extends `-${infer C}` ? C : never;
+/**
+ * Convert kebab-case to camelCase (matching Commander's attributeName()).
+ *
+ * "dry-run"        → "dryRun"
+ * "terminal-name"  → "terminalName"
+ * "verbose"        → "verbose"
+ */
+type CamelCase<S extends string> = S extends `${infer A}-${infer B}${infer Rest}` ? `${A}${Uppercase<B>}${CamelCase<Rest>}` : S;
+/**
+ * Extract the argument name from a flags string.
+ *
+ * Examples:
+ *   "<service>"       → "service"
+ *   "[env]"           → "env"
+ *   "<files...>"      → "files"
+ *   "<service-name>"  → "service-name"
+ */
+type ExtractArgName<S extends string> = S extends `<${infer Name}...>` ? Name : S extends `<${infer Name}>` ? Name : S extends `[${infer Name}...]` ? Name : S extends `[${infer Name}]` ? Name : never;
+/** Is the argument required (wrapped in `<...>`)? */
+type IsArgRequired<S extends string> = S extends `<${string}>` ? true : false;
+/** Is the argument variadic (ends with `...>` or `...]`)? */
+type IsArgVariadic<S extends string> = S extends `${string}...${string}` ? true : false;
+/**
+ * Derive the property key from an argument flags string.
+ * Applies: extract name → camelCase.
+ */
+type ArgKey<S extends string> = CamelCase<ExtractArgName<S>>;
+/**
+ * Parse positional arguments embedded in a command name string.
+ *
+ * Commander.js accepts argument syntax inline with command names:
+ *   `"deploy <service>"`            → 1 required arg
+ *   `"deploy <service> [env]"`      → 1 required + 1 optional
+ *   `"deploy <files...>"`           → 1 required variadic
+ *
+ * `ParseCommandString<S>` returns `[Args tuple, ArgsRecord]` so the typed
+ * `command<S>()` overload can produce a `Command<{}, Args, ArgsRecord>` with
+ * the same type information you'd get from chaining `.argument()` calls.
+ *
+ * Limitations: only plain string types — `<svc>` is `string`, `[env]` is
+ * `string | undefined`, `<files...>` is `string[]`. Parsers, schemas, and
+ * choices still require `.argument()` because the inline string syntax can't
+ * express them. Mixing inline args with `.argument()` calls is allowed:
+ * the inline ones come first in the tuple, the `.argument()` ones append.
+ */
+/** Split a command name string at the first space. `"deploy <service>"` → `["deploy", "<service>"]` */
+type SplitCommandHead<S extends string> = S extends `${infer Name} ${infer Rest}` ? [Name, Rest] : [S, ""];
+/** Walk the tail tokens after the command name and build [Args tuple, ArgsRecord]. */
+type ParseInlineArgs<S extends string, Tuple extends any[] = [], Rec = {}> = S extends "" ? [Tuple, Rec] : S extends `${infer Tok} ${infer Rest}` ? Tok extends `<${infer Name}...>` ? ParseInlineArgs<Rest, [...Tuple, string[]], Rec & Record<CamelCase<Name>, string[]>> : Tok extends `<${infer Name}>` ? ParseInlineArgs<Rest, [...Tuple, string], Rec & Record<CamelCase<Name>, string>> : Tok extends `[${infer Name}...]` ? ParseInlineArgs<Rest, [...Tuple, string[]], Rec & Record<CamelCase<Name>, string[]>> : Tok extends `[${infer Name}]` ? ParseInlineArgs<Rest, [...Tuple, string | undefined], Rec & Record<CamelCase<Name>, string | undefined>> : ParseInlineArgs<Rest, Tuple, Rec> : S extends `<${infer Name}...>` ? [[...Tuple, string[]], Rec & Record<CamelCase<Name>, string[]>] : S extends `<${infer Name}>` ? [[...Tuple, string], Rec & Record<CamelCase<Name>, string>] : S extends `[${infer Name}...]` ? [[...Tuple, string[]], Rec & Record<CamelCase<Name>, string[]>] : S extends `[${infer Name}]` ? [[...Tuple, string | undefined], Rec & Record<CamelCase<Name>, string | undefined>] : [Tuple, Rec];
+/** Top-level: parse a `command(name)` string into [Args tuple, ArgsRecord]. */
+type ParseCommandString<S extends string> = SplitCommandHead<S> extends [infer _Name, infer Tail extends string] ? Tail extends "" ? [[], {}] : ParseInlineArgs<Tail> : [[], {}];
+/**
+ * Infer the value type for an argument based on its flags string and
+ * the optional parser/choices/schema.
+ *
+ * Rules:
+ *   <required>            → string
+ *   [optional]            → string | undefined
+ *   <variadic...>         → string[]
+ *   [variadic...]         → string[]
+ *   with parser fn        → ReturnType<parser> (+ | undefined if optional)
+ *   with CLIType<T>       → T (+ | undefined if optional)
+ *   with StandardSchema   → T (+ | undefined if optional)
+ *   with choices[]        → choices[number] (+ | undefined if optional)
+ */
+type InferArgType<Flags extends string, ParseArg = undefined> = IsArgVariadic<Flags> extends true ? ParseArg extends readonly (infer C)[] ? C[] : ParseArg extends CLIType<infer T> ? T[] : ParseArg extends StandardSchemaV1<infer T> ? T[] : ParseArg extends ((value: string, ...args: any[]) => infer R) ? R[] : string[] : IsArgRequired<Flags> extends true ? ParseArg extends readonly (infer C)[] ? C : ParseArg extends CLIType<infer T> ? T : ParseArg extends StandardSchemaV1<infer T> ? T : ParseArg extends ((value: string, ...args: any[]) => infer R) ? R : string : ParseArg extends readonly (infer C)[] ? C | undefined : ParseArg extends CLIType<infer T> ? T | undefined : ParseArg extends StandardSchemaV1<infer T> ? T | undefined : ParseArg extends ((value: string, ...args: any[]) => infer R) ? R | undefined : string | undefined;
+/**
+ * Strip "no-" prefix from negated flags.
+ * "--no-color" → long name "no-color" → stripped to "color"
+ */
+type StripNo<S extends string> = S extends `no-${infer Rest}` ? Rest : S;
+/**
+ * Derive the property key from a flags string.
+ * Applies: extract long name → strip "no-" → camelCase.
+ */
+type FlagKey<S extends string> = CamelCase<StripNo<ExtractLongName<S>>>;
+/**
+ * Does the flags string contain a required value argument `<...>`?
+ */
+type HasRequiredArg<S extends string> = S extends `${string}<${string}>${string}` ? true : false;
+/**
+ * Does the flags string contain an optional value argument `[...]`?
+ */
+type HasOptionalArg<S extends string> = S extends `${string}[${string}]${string}` ? true : false;
+/**
+ * Does the flags string start with `--no-`?
+ */
+type IsNegated<S extends string> = ExtractLongName<S> extends `no-${string}` ? true : false;
+/**
+ * Infer the value type for a flag based on the flags string and the
+ * optional third argument (parser function, Standard Schema, choices array).
+ *
+ * Rules (mirroring Commander runtime behavior):
+ *   --flag                    → boolean | undefined
+ *   --no-flag                 → boolean
+ *   --flag <value>            → string | undefined  (or parser return type)
+ *   --flag [value]            → string | boolean | undefined (or parser return type | boolean)
+ *   --flag <value>, parser fn → ReturnType<parser> | undefined
+ *   --flag <value>, CLIType<T> / StandardSchemaV1<T> → T | undefined
+ *   --flag <value>, choices[] → choices[number] | undefined
+ */
+type InferOptionType<Flags extends string, ParseArg = undefined> = IsNegated<Flags> extends true ? boolean : HasRequiredArg<Flags> extends true ? ParseArg extends readonly (infer C)[] ? C | undefined : ParseArg extends CLIType<infer T> ? T | undefined : ParseArg extends StandardSchemaV1<infer T> ? T | undefined : ParseArg extends ((value: string, ...args: any[]) => infer R) ? R | undefined : string | undefined : HasOptionalArg<Flags> extends true ? ParseArg extends readonly (infer C)[] ? C | boolean | undefined : ParseArg extends CLIType<infer T> ? T | boolean | undefined : ParseArg extends StandardSchemaV1<infer T> ? T | boolean | undefined : ParseArg extends ((value: string, ...args: any[]) => infer R) ? R | boolean | undefined : string | boolean | undefined : boolean | undefined;
+/** Position for help sections — mirrors Commander's addHelpText positions. */
+type HelpSectionPosition = "beforeAll" | "before" | "after" | "afterAll";
+/** Content for a help section: rows of [term, description] pairs, or free-form text. */
+type HelpSectionContent = [string, string][] | string;
+declare class _CommandBase extends Command$1 {
+  private _helpSectionList;
+  private _helpSectionsInstalled;
+  /** Argument names registered via typed .argument() — used by .action() to merge into opts. */
+  _typedArgNames: string[];
+  constructor(name?: string);
+  /**
+   * Add an option with smart third-argument detection.
+   *
+   * The third argument is detected in order:
+   * 1. **Array** -- treated as choices (Commander `.choices()`)
+   * 2. **Standard Schema v1** -- wrapped as a parser function
+   * 3. **Legacy Zod** (pre-3.24, has `_def` + `parse`) -- wrapped as a parser
+   * 4. **Function** -- passed through as Commander's parser function
+   * 5. **Anything else** -- passed through as a default value
+   */
+  option(flags: string, description?: string, parseArgOrDefault?: any, defaultValue?: any): this;
+  /**
+   * Add an argument with smart third-argument detection.
+   *
+   * Same detection as `.option()`: array → choices, Standard Schema → parser,
+   * legacy Zod → parser, function → parser, anything else → default value.
+   * Tracks argument names for `.action()` merging.
+   */
+  argument(flags: string, description?: string, parseArgOrDefault?: any, defaultValue?: any): this;
+  /**
+   * Register an action callback with a named-parameter object instead of positional args.
+   *
+   * The handler receives a single object containing all positional arguments
+   * (merged by name) and all options, plus the Command instance as a second arg.
+   * Argument names come from the typed `.argument()` calls, camelCased.
+   *
+   * This is a convenience wrapper over `.action()` — `.action()` itself remains
+   * Commander-native `(...args, opts, command) => ...`. Prefer `.action()` for
+   * single-arg commands (where positional is more ergonomic) and `.actionMerged()`
+   * for multi-arg commands (where a flat named object is nicer).
+   *
+   * @example
+   * ```ts
+   * new Command("deploy")
+   *   .argument("<service>")
+   *   .argument("[env]")
+   *   .option("-p, --port <n>", port)
+   *   .actionMerged(({ service, env, port }, cmd) => {
+   *     // service, env, port are all typed
+   *     // cmd is the Command instance
+   *   })
+   * ```
+   */
+  actionMerged(fn: (params: any, cmd: any) => any): this;
+  /**
+   * Add a styled help section — like Commander's `addHelpText` but with
+   * structured content that participates in global column alignment.
+   *
+   * @example
+   * ```ts
+   * // Rows with aligned descriptions (default position: "after")
+   * program.addHelpSection("Getting Started:", [
+   *   ["myapp init", "Initialize a new project"],
+   *   ["myapp serve", "Start the dev server"],
+   * ])
+   *
+   * // Free-form text
+   * program.addHelpSection("Note:", "Requires Node.js 23+")
+   *
+   * // Explicit position
+   * program.addHelpSection("before", "Prerequisites:", [
+   *   ["node >= 23", "Required runtime"],
+   * ])
+   * ```
+   */
+  addHelpSection(title: string, content: HelpSectionContent): this;
+  addHelpSection(position: HelpSectionPosition, title: string, content: HelpSectionContent): this;
+  createCommand(name?: string): _CommandBase;
+  /**
+   * Override Commander's `command()` to mirror inline-arg names (from
+   * `command("deploy <service>")`) into our `_typedArgNames`. This keeps
+   * `.actionMerged()` working on subcommands declared with the inline form,
+   * since the merged dispatch reads from `_typedArgNames` to know which
+   * positional indices map to which key.
+   *
+   * Both forms now coexist:
+   *   .command("deploy <service>")               // inline — names from string
+   *   .command("deploy").argument("<service>")   // explicit — names from .argument()
+   * Both produce equivalent runtime + type behavior.
+   */
+  command(...args: any[]): any;
+  /**
+   * Auto-detect capitalization from user-provided descriptions and match it
+   * for built-in options (-V/--version, -h/--help).
+   */
+  private _capitalizeBuiltinDescriptions;
+  /**
+   * Render sections for a given position using the help formatter.
+   *
+   * Handles multi-line term entries (terms containing `\n`) by emitting one
+   * row per line. The description column is **top-aligned**: it appears only
+   * on the first line of a multi-line term, with subsequent lines holding
+   * just the styled term and an empty description column.
+   */
+  private _renderSections;
+  /** Install hooks once — merges with existing configureHelp, adds addHelpText for before/afterAll. */
+  private _installHelpSectionHooks;
+}
+interface Command<Opts extends Record<string, unknown> = {}, Args extends any[] = [], ArgsRecord extends Record<string, unknown> = {}> extends _CommandBase {
+  /** Return option values with full type inference. */
+  opts(): Opts;
+  /** Accept any `Command<...>` variant as a subcommand. */
+  addCommand(cmd: Command<any, any, any>, opts?: {
+    isDefault?: boolean;
+    hidden?: boolean;
+    noHelp?: boolean;
+  }): this;
+  /** Factory for subcommands — returns a fresh `Command<{}>`. */
+  createCommand(name?: string): Command<{}, [], {}>;
+  /** Set command description (preserves typed chain). */
+  description(str: string): this;
+  /** Get command description. */
+  description(): string;
+  /** Set command alias (preserves typed chain). */
+  alias(alias: string): this;
+  /** Get command alias. */
+  alias(): string;
+  /** Set command version (preserves typed chain). */
+  version(str: string, flags?: string, description?: string): this;
+  /** Add a choices option: `--env <e>`, `["dev", "staging", "prod"]` */
+  option<F extends string, const C extends readonly string[]>(flags: F, description: string, choices: C): Command<Opts & Record<FlagKey<F>, C[number] | undefined>, Args, ArgsRecord>;
+  /** Add an option with a CLIType preset (port, csv, uint, etc.) */
+  option<F extends string, T>(flags: F, description: string, schema: CLIType<T>, defaultValue?: T): Command<Opts & Record<FlagKey<F>, T | undefined>, Args, ArgsRecord>;
+  /** Add an option with a Standard Schema v1 validator (Zod, Valibot, ArkType) */
+  option<F extends string, S extends AnyStandardSchema>(flags: F, description: string, schema: S, defaultValue?: SchemaOutput<S>): Command<Opts & Record<FlagKey<F>, SchemaOutput<S> | undefined>, Args, ArgsRecord>;
+  /** Add an option with a parser function */
+  option<F extends string, T>(flags: F, description: string, parseArg: (value: string, previous: T) => T, defaultValue?: T): Command<Opts & Record<FlagKey<F>, T | undefined>, Args, ArgsRecord>;
+  /** Add a boolean flag or string-value option (no parser) */
+  option<F extends string>(flags: F, description?: string, defaultValue?: string | boolean): Command<Opts & Record<FlagKey<F>, InferOptionType<F>>, Args, ArgsRecord>;
+  /**
+   * Fallback: accepts any third argument (legacy Zod, unknown schemas, etc.)
+   * that doesn't match the more specific overloads above.
+   */
+  option<F extends string>(flags: F, description: string, parseArgOrDefault: any, defaultValue?: any): Command<Opts, Args, ArgsRecord>;
+  /** Add a choices argument: `<env>`, `["dev", "staging", "prod"]` */
+  argument<F extends string, const C extends readonly string[]>(flags: F, description: string, choices: C): Command<Opts, [...Args, IsArgVariadic<F> extends true ? C[number][] : IsArgRequired<F> extends true ? C[number] : C[number] | undefined], ArgsRecord & Record<ArgKey<F>, IsArgVariadic<F> extends true ? C[number][] : IsArgRequired<F> extends true ? C[number] : C[number] | undefined>>;
+  /** Add an argument with a CLIType preset (port, csv, uint, etc.) */
+  argument<F extends string, T>(flags: F, description: string, schema: CLIType<T>, defaultValue?: T): Command<Opts, [...Args, InferArgType<F, CLIType<T>>], ArgsRecord & Record<ArgKey<F>, InferArgType<F, CLIType<T>>>>;
+  /** Add an argument with a Standard Schema v1 validator (Zod, Valibot, ArkType) */
+  argument<F extends string, S extends AnyStandardSchema>(flags: F, description: string, schema: S, defaultValue?: SchemaOutput<S>): Command<Opts, [...Args, InferArgType<F, StandardSchemaV1<SchemaOutput<S>>>], ArgsRecord & Record<ArgKey<F>, InferArgType<F, StandardSchemaV1<SchemaOutput<S>>>>>;
+  /** Add an argument with a parser function */
+  argument<F extends string, T>(flags: F, description: string, parseArg: (value: string, previous: T) => T, defaultValue?: T): Command<Opts, [...Args, InferArgType<F, (value: string, previous: T) => T>], ArgsRecord & Record<ArgKey<F>, InferArgType<F, (value: string, previous: T) => T>>>;
+  /** Add a string argument (no parser) — required, optional, or variadic */
+  argument<F extends string>(flags: F, description?: string, defaultValue?: string): Command<Opts, [...Args, InferArgType<F>], ArgsRecord & Record<ArgKey<F>, InferArgType<F>>>;
+  /** Fallback: accepts any third argument */
+  argument<F extends string>(flags: F, description: string, parseArgOrDefault: any, defaultValue?: any): Command<Opts, Args, ArgsRecord>;
+  /**
+   * Register an action handler — Commander-native positional form.
+   * Receives `(...positionalArgs, opts, command)`. The command instance is
+   * appended last so it can be safely ignored by handlers that don't need it.
+   */
+  action(fn: (...args: [...Args, Opts, Command<Opts, Args, ArgsRecord>]) => void | Promise<void>): this;
+  /**
+   * Register an action handler — merged named-object form.
+   * Receives `(params, command)` where `params` is a flat object of
+   * args merged with options, keyed by argument/option name.
+   *
+   * Use this when you prefer a single destructured object to multiple positional
+   * parameters — especially for commands with 2+ arguments.
+   */
+  actionMerged(fn: (params: Opts & ArgsRecord, cmd: Command<Opts, Args, ArgsRecord>) => void | Promise<void>): this;
+  /**
+   * Create a subcommand. Returns a fresh `Command<{}, ParsedArgs, ParsedArgsRecord>`.
+   *
+   * Positional arguments embedded in the command name string (`"deploy <service>"`)
+   * are parsed at the type level and contribute to the returned `Args` tuple and
+   * `ArgsRecord`. The same shape as if you'd chained `.argument("<service>")`.
+   *
+   * For typed parsers, schemas, or choices, use `.argument()` on the returned
+   * command — the inline string syntax can only express plain string args.
+   * Mixing both forms is allowed: inline args come first in the tuple, then
+   * `.argument()` calls append.
+   */
+  command<S extends string>(nameAndArgs: S, opts?: {
+    isDefault?: boolean;
+    hidden?: boolean;
+    noHelp?: boolean;
+  }): ParseCommandString<S> extends [infer A extends any[], infer R extends Record<string, unknown>] ? Command<{}, A, R> : Command<{}, [], {}>;
+  /** Overload for command with description (attached-action subcommand, returns parent). */
+  command<S extends string>(nameAndArgs: S, description: string, opts?: {
+    isDefault?: boolean;
+    hidden?: boolean;
+    noHelp?: boolean;
+    executableFile?: string;
+  }): this;
+}
+/**
+ * Type-safe Commander Command with auto-colorized help, Standard Schema support,
+ * array-as-choices detection, and inferred option types.
+ *
+ * Use `.action()` for Commander-native positional form — `(arg1, arg2, opts, cmd) => ...`.
+ * Use `.actionMerged()` for a flat destructured form — `({ arg1, arg2, opt1 }, cmd) => ...`.
+ *
+ * @example
+ * ```ts
+ * new Command("deploy")
+ *   .argument("<service>", "Service to deploy")
+ *   .argument("[env]", "Environment", ["dev", "staging", "prod"] as const)
+ *   .option("--verbose", "Verbose output")
+ *   .action((service, env, opts) => { ... })
+ *   // or: .actionMerged(({ service, env, verbose }) => { ... })
+ * ```
+ */
+declare const Command: {
+  new (name?: string): Command<{}, [], {}>;
+};
+//#endregion
+//#region src/colorize.d.ts
+/**
+ * Commander.js help colorization using @silvery/ansi.
+ *
+ * Uses Commander's built-in style hooks (styleTitle, styleOptionText, etc.)
+ * rather than regex post-processing.
+ *
+ * @example
+ * ```ts
+ * import { Command } from "@silvery/commander"
+ * // Command auto-colorizes in its constructor — no manual call needed.
+ * // For plain Commander:
+ * import { colorizeHelp } from "@silvery/commander"
+ * colorizeHelp(program)
+ * ```
+ */
+/**
+ * Check if color output should be enabled.
+ * Delegates to @silvery/ansi's auto-detection (NO_COLOR, FORCE_COLOR, TERM).
+ */
+declare function shouldColorize(): boolean;
+/**
+ * Minimal interface for Commander's Command — avoids requiring Commander
+ * as a direct dependency. Works with both `commander` and
+ * `@silvery/commander`.
+ */
+interface CommandLike {
+  configureHelp(...args: any[]): any;
+  configureOutput(...args: any[]): any;
+  readonly commands: readonly any[];
+}
+/** Color scheme for help output. Each value is a styling function (text → styled text). */
+interface ColorizeHelpOptions {
+  /** Style for command/subcommand names. Default: primary (yellow without theme) */
+  commands?: (text: string) => string;
+  /** Style for --flags and -short options. Default: secondary (cyan without theme) */
+  flags?: (text: string) => string;
+  /** Style for description text. Default: unstyled (normal foreground) */
+  description?: (text: string) => string;
+  /** Style for section headings (Usage:, Options:, etc.). Default: bold */
+  heading?: (text: string) => string;
+  /** Style for <required> and [optional] argument brackets. Default: accent (magenta without theme) */
+  brackets?: (text: string) => string;
+}
+/**
+ * Apply colorized help output to a Commander.js program and all its subcommands.
+ *
+ * Uses Commander's built-in `configureHelp()` style hooks rather than
+ * post-processing the formatted string.
+ *
+ * @param program - A Commander Command instance (or compatible object)
+ * @param options - Override default style functions for each element
+ */
+declare function colorizeHelp(program: CommandLike, options?: ColorizeHelpOptions): void;
+//#endregion
+//#region src/z.d.ts
+declare const z: {
+  port: zod.z.ZodCoercedNumber<unknown>;
+  int: zod.z.ZodCoercedNumber<unknown>;
+  uint: zod.z.ZodCoercedNumber<unknown>;
+  float: zod.z.ZodCoercedNumber<unknown>;
+  csv: zod.ZodPipe<zod.ZodString, zod.ZodTransform<string[], string>>;
+  url: zod.ZodString;
+  path: zod.ZodString;
+  email: zod.ZodString;
+  date: zod.z.ZodCoercedDate<unknown>;
+  json: zod.ZodPipe<zod.ZodString, zod.ZodTransform<any, string>>;
+  bool: zod.ZodPipe<zod.ZodEnum<{
+    true: "true";
+    0: "0";
+    false: "false";
+    1: "1";
+    yes: "yes";
+    no: "no";
+    y: "y";
+    n: "n";
+  }>, zod.ZodTransform<boolean, "true" | "0" | "false" | "1" | "yes" | "no" | "y" | "n">>;
+  intRange: (min: number, max: number) => zod.z.ZodCoercedNumber<unknown>;
+  z: typeof zod.z;
+  default: typeof zod.z;
+  core: typeof zod.core;
+  globalRegistry: zod.z.core.$ZodRegistry<zod.z.core.GlobalMeta, zod.z.core.$ZodType<unknown, unknown, zod.z.core.$ZodTypeInternals<unknown, unknown>>>;
+  registry: typeof zod.core.registry;
+  config: typeof zod.core.config;
+  $output: typeof zod.core.$output;
+  $input: typeof zod.core.$input;
+  $brand: typeof zod.core.$brand;
+  clone: typeof zod.core.util.clone;
+  regexes: typeof zod.core.regexes;
+  treeifyError: typeof zod.core.treeifyError;
+  prettifyError: typeof zod.core.prettifyError;
+  formatError: typeof zod.core.formatError;
+  flattenError: typeof zod.core.flattenError;
+  TimePrecision: {
+    readonly Any: null;
+    readonly Minute: -1;
+    readonly Second: 0;
+    readonly Millisecond: 3;
+    readonly Microsecond: 6;
+  };
+  util: typeof zod.core.util;
+  NEVER: never;
+  toJSONSchema: typeof zod.core.toJSONSchema;
+  fromJSONSchema: typeof zod.fromJSONSchema;
+  locales: typeof zod.core.locales;
+  ZodISODateTime: zod.z.core.$constructor<zod.z.ZodISODateTime, zod.z.core.$ZodISODateTimeDef>;
+  ZodISODate: zod.z.core.$constructor<zod.z.ZodISODate, zod.z.core.$ZodStringFormatDef<"date">>;
+  ZodISOTime: zod.z.core.$constructor<zod.z.ZodISOTime, zod.z.core.$ZodISOTimeDef>;
+  ZodISODuration: zod.z.core.$constructor<zod.z.ZodISODuration, zod.z.core.$ZodStringFormatDef<"duration">>;
+  iso: typeof zod.iso;
+  coerce: typeof zod.coerce;
+  string(params?: string | zod.z.core.$ZodStringParams): zod.ZodString;
+  string<T extends string>(params?: string | zod.z.core.$ZodStringParams): zod.z.core.$ZodType<T, T>;
+  guid(params?: string | zod.z.core.$ZodGUIDParams): zod.ZodGUID;
+  uuid(params?: string | zod.z.core.$ZodUUIDParams): zod.ZodUUID;
+  uuidv4(params?: string | zod.z.core.$ZodUUIDv4Params): zod.ZodUUID;
+  uuidv6(params?: string | zod.z.core.$ZodUUIDv6Params): zod.ZodUUID;
+  uuidv7(params?: string | zod.z.core.$ZodUUIDv7Params): zod.ZodUUID;
+  httpUrl(params?: string | Omit<zod.z.core.$ZodURLParams, "protocol" | "hostname">): zod.ZodURL;
+  emoji(params?: string | zod.z.core.$ZodEmojiParams): zod.ZodEmoji;
+  nanoid(params?: string | zod.z.core.$ZodNanoIDParams): zod.ZodNanoID;
+  cuid(params?: string | zod.z.core.$ZodCUIDParams): zod.ZodCUID;
+  cuid2(params?: string | zod.z.core.$ZodCUID2Params): zod.ZodCUID2;
+  ulid(params?: string | zod.z.core.$ZodULIDParams): zod.ZodULID;
+  xid(params?: string | zod.z.core.$ZodXIDParams): zod.ZodXID;
+  ksuid(params?: string | zod.z.core.$ZodKSUIDParams): zod.ZodKSUID;
+  ipv4(params?: string | zod.z.core.$ZodIPv4Params): zod.ZodIPv4;
+  mac(params?: string | zod.z.core.$ZodMACParams): zod.ZodMAC;
+  ipv6(params?: string | zod.z.core.$ZodIPv6Params): zod.ZodIPv6;
+  cidrv4(params?: string | zod.z.core.$ZodCIDRv4Params): zod.ZodCIDRv4;
+  cidrv6(params?: string | zod.z.core.$ZodCIDRv6Params): zod.ZodCIDRv6;
+  base64(params?: string | zod.z.core.$ZodBase64Params): zod.ZodBase64;
+  base64url(params?: string | zod.z.core.$ZodBase64URLParams): zod.ZodBase64URL;
+  e164(params?: string | zod.z.core.$ZodE164Params): zod.ZodE164;
+  jwt(params?: string | zod.z.core.$ZodJWTParams): zod.ZodJWT;
+  stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => zod.z.core.util.MaybeAsync<unknown>) | RegExp, _params?: string | zod.z.core.$ZodStringFormatParams): zod.ZodCustomStringFormat<Format>;
+  hostname(_params?: string | zod.z.core.$ZodStringFormatParams): zod.ZodCustomStringFormat<"hostname">;
+  hex(_params?: string | zod.z.core.$ZodStringFormatParams): zod.ZodCustomStringFormat<"hex">;
+  hash<Alg extends zod.z.core.util.HashAlgorithm, Enc extends zod.z.core.util.HashEncoding = "hex">(alg: Alg, params?: {
+    enc?: Enc;
+  } & zod.z.core.$ZodStringFormatParams): zod.ZodCustomStringFormat<`${Alg}_${Enc}`>;
+  number(params?: string | zod.z.core.$ZodNumberParams): zod.ZodNumber;
+  float32(params?: string | zod.z.core.$ZodCheckNumberFormatParams): zod.ZodFloat32;
+  float64(params?: string | zod.z.core.$ZodCheckNumberFormatParams): zod.ZodFloat64;
+  int32(params?: string | zod.z.core.$ZodCheckNumberFormatParams): zod.ZodInt32;
+  uint32(params?: string | zod.z.core.$ZodCheckNumberFormatParams): zod.ZodUInt32;
+  boolean(params?: string | zod.z.core.$ZodBooleanParams): zod.ZodBoolean;
+  bigint(params?: string | zod.z.core.$ZodBigIntParams): zod.ZodBigInt;
+  int64(params?: string | zod.z.core.$ZodBigIntFormatParams): zod.ZodBigIntFormat;
+  uint64(params?: string | zod.z.core.$ZodBigIntFormatParams): zod.ZodBigIntFormat;
+  symbol(params?: string | zod.z.core.$ZodSymbolParams): zod.ZodSymbol;
+  any(): zod.ZodAny;
+  unknown(): zod.ZodUnknown;
+  never(params?: string | zod.z.core.$ZodNeverParams): zod.ZodNever;
+  array<T extends zod.z.core.SomeType>(element: T, params?: string | zod.z.core.$ZodArrayParams): zod.ZodArray<T>;
+  keyof<T extends zod.ZodObject>(schema: T): zod.ZodEnum<zod.z.core.util.KeysEnum<T["_zod"]["output"]>>;
+  object<T extends zod.z.core.$ZodLooseShape = Partial<Record<never, zod.z.core.SomeType>>>(shape?: T, params?: string | zod.z.core.$ZodObjectParams): zod.ZodObject<zod.z.core.util.Writeable<T>, zod.z.core.$strip>;
+  strictObject<T extends zod.z.core.$ZodLooseShape>(shape: T, params?: string | zod.z.core.$ZodObjectParams): zod.ZodObject<T, zod.z.core.$strict>;
+  looseObject<T extends zod.z.core.$ZodLooseShape>(shape: T, params?: string | zod.z.core.$ZodObjectParams): zod.ZodObject<T, zod.z.core.$loose>;
+  union<const T extends readonly zod.z.core.SomeType[]>(options: T, params?: string | zod.z.core.$ZodUnionParams): zod.ZodUnion<T>;
+  xor<const T extends readonly zod.z.core.SomeType[]>(options: T, params?: string | zod.z.core.$ZodXorParams): zod.ZodXor<T>;
+  discriminatedUnion<Types extends readonly [zod.z.core.$ZodTypeDiscriminable, ...zod.z.core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | zod.z.core.$ZodDiscriminatedUnionParams): zod.ZodDiscriminatedUnion<Types, Disc>;
+  intersection<T extends zod.z.core.SomeType, U extends zod.z.core.SomeType>(left: T, right: U): zod.ZodIntersection<T, U>;
+  tuple<T extends readonly [zod.z.core.SomeType, ...zod.z.core.SomeType[]]>(items: T, params?: string | zod.z.core.$ZodTupleParams): zod.ZodTuple<T, null>;
+  tuple<T extends readonly [zod.z.core.SomeType, ...zod.z.core.SomeType[]], Rest extends zod.z.core.SomeType>(items: T, rest: Rest, params?: string | zod.z.core.$ZodTupleParams): zod.ZodTuple<T, Rest>;
+  tuple(items: [], params?: string | zod.z.core.$ZodTupleParams): zod.ZodTuple<[], null>;
+  record<Key extends zod.z.core.$ZodRecordKey, Value extends zod.z.core.SomeType>(keyType: Key, valueType: Value, params?: string | zod.z.core.$ZodRecordParams): zod.ZodRecord<Key, Value>;
+  partialRecord<Key extends zod.z.core.$ZodRecordKey, Value extends zod.z.core.SomeType>(keyType: Key, valueType: Value, params?: string | zod.z.core.$ZodRecordParams): zod.ZodRecord<Key & zod.z.core.$partial, Value>;
+  looseRecord<Key extends zod.z.core.$ZodRecordKey, Value extends zod.z.core.SomeType>(keyType: Key, valueType: Value, params?: string | zod.z.core.$ZodRecordParams): zod.ZodRecord<Key, Value>;
+  map<Key extends zod.z.core.SomeType, Value extends zod.z.core.SomeType>(keyType: Key, valueType: Value, params?: string | zod.z.core.$ZodMapParams): zod.ZodMap<Key, Value>;
+  set<Value extends zod.z.core.SomeType>(valueType: Value, params?: string | zod.z.core.$ZodSetParams): zod.ZodSet<Value>;
+  nativeEnum<T extends zod.z.core.util.EnumLike>(entries: T, params?: string | zod.z.core.$ZodEnumParams): zod.ZodEnum<T>;
+  literal<const T extends ReadonlyArray<zod.z.core.util.Literal>>(value: T, params?: string | zod.z.core.$ZodLiteralParams): zod.ZodLiteral<T[number]>;
+  literal<const T extends zod.z.core.util.Literal>(value: T, params?: string | zod.z.core.$ZodLiteralParams): zod.ZodLiteral<T>;
+  file(params?: string | zod.z.core.$ZodFileParams): zod.ZodFile;
+  transform<I = unknown, O = I>(fn: (input: I, ctx: zod.z.core.ParsePayload) => O): zod.ZodTransform<Awaited<O>, I>;
+  optional<T extends zod.z.core.SomeType>(innerType: T): zod.ZodOptional<T>;
+  exactOptional<T extends zod.z.core.SomeType>(innerType: T): zod.ZodExactOptional<T>;
+  nullable<T extends zod.z.core.SomeType>(innerType: T): zod.ZodNullable<T>;
+  nullish<T extends zod.z.core.SomeType>(innerType: T): zod.ZodOptional<zod.ZodNullable<T>>;
+  _default<T extends zod.z.core.SomeType>(innerType: T, defaultValue: zod.z.core.util.NoUndefined<zod.z.core.output<T>> | (() => zod.z.core.util.NoUndefined<zod.z.core.output<T>>)): zod.ZodDefault<T>;
+  prefault<T extends zod.z.core.SomeType>(innerType: T, defaultValue: zod.z.core.input<T> | (() => zod.z.core.input<T>)): zod.ZodPrefault<T>;
+  nonoptional<T extends zod.z.core.SomeType>(innerType: T, params?: string | zod.z.core.$ZodNonOptionalParams): zod.ZodNonOptional<T>;
+  success<T extends zod.z.core.SomeType>(innerType: T): zod.ZodSuccess<T>;
+  nan(params?: string | zod.z.core.$ZodNaNParams): zod.ZodNaN;
+  pipe<const A extends zod.z.core.SomeType, B extends zod.z.core.$ZodType<unknown, zod.z.core.output<A>> = zod.z.core.$ZodType<unknown, zod.z.core.output<A>, zod.z.core.$ZodTypeInternals<unknown, zod.z.core.output<A>>>>(in_: A, out: B | zod.z.core.$ZodType<unknown, zod.z.core.output<A>>): zod.ZodPipe<A, B>;
+  codec<const A extends zod.z.core.SomeType, B extends zod.z.core.SomeType = zod.z.core.$ZodType<unknown, unknown, zod.z.core.$ZodTypeInternals<unknown, unknown>>>(in_: A, out: B, params: {
+    decode: (value: zod.z.core.output<A>, payload: zod.z.core.ParsePayload<zod.z.core.output<A>>) => zod.z.core.util.MaybeAsync<zod.z.core.input<B>>;
+    encode: (value: zod.z.core.input<B>, payload: zod.z.core.ParsePayload<zod.z.core.input<B>>) => zod.z.core.util.MaybeAsync<zod.z.core.output<A>>;
+  }): zod.ZodCodec<A, B>;
+  readonly<T extends zod.z.core.SomeType>(innerType: T): zod.ZodReadonly<T>;
+  templateLiteral<const Parts extends zod.z.core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | zod.z.core.$ZodTemplateLiteralParams): zod.ZodTemplateLiteral<zod.z.core.$PartsToTemplateLiteral<Parts>>;
+  lazy<T extends zod.z.core.SomeType>(getter: () => T): zod.ZodLazy<T>;
+  promise<T extends zod.z.core.SomeType>(innerType: T): zod.ZodPromise<T>;
+  _function(): zod.ZodFunction;
+  _function<const In extends ReadonlyArray<zod.z.core.$ZodType>>(params: {
+    input: In;
+  }): zod.ZodFunction<zod.ZodTuple<In, null>, zod.z.core.$ZodFunctionOut>;
+  _function<const In extends ReadonlyArray<zod.z.core.$ZodType>, const Out extends zod.z.core.$ZodFunctionOut = zod.z.core.$ZodFunctionOut>(params: {
+    input: In;
+    output: Out;
+  }): zod.ZodFunction<zod.ZodTuple<In, null>, Out>;
+  _function<const In extends zod.z.core.$ZodFunctionIn = zod.z.core.$ZodFunctionArgs>(params: {
+    input: In;
+  }): zod.ZodFunction<In, zod.z.core.$ZodFunctionOut>;
+  _function<const Out extends zod.z.core.$ZodFunctionOut = zod.z.core.$ZodFunctionOut>(params: {
+    output: Out;
+  }): zod.ZodFunction<zod.z.core.$ZodFunctionIn, Out>;
+  _function<In extends zod.z.core.$ZodFunctionIn = zod.z.core.$ZodFunctionArgs, Out extends zod.z.core.$ZodType = zod.z.core.$ZodType<unknown, unknown, zod.z.core.$ZodTypeInternals<unknown, unknown>>>(params?: {
+    input: In;
+    output: Out;
+  }): zod.ZodFunction<In, Out>;
+  check<O = unknown>(fn: zod.z.core.CheckFn<O>): zod.z.core.$ZodCheck<O>;
+  custom<O>(fn?: (data: unknown) => unknown, _params?: string | zod.z.core.$ZodCustomParams | undefined): zod.ZodCustom<O, O>;
+  refine<T>(fn: (arg: NoInfer<T>) => zod.z.core.util.MaybeAsync<unknown>, _params?: string | zod.z.core.$ZodCustomParams): zod.z.core.$ZodCheck<T>;
+  superRefine<T>(fn: (arg: T, payload: zod.z.core.$RefinementCtx<T>) => void | Promise<void>): zod.z.core.$ZodCheck<T>;
+  preprocess<A, U extends zod.z.core.SomeType, B = unknown>(fn: (arg: B, ctx: zod.z.core.$RefinementCtx) => A, schema: U): zod.ZodPipe<zod.ZodTransform<A, B>, U>;
+  ZodType: zod.z.core.$constructor<zod.ZodType>;
+  _ZodString: zod.z.core.$constructor<zod._ZodString>;
+  ZodString: zod.z.core.$constructor<zod.ZodString>;
+  ZodStringFormat: zod.z.core.$constructor<zod.ZodStringFormat>;
+  ZodEmail: zod.z.core.$constructor<zod.ZodEmail>;
+  ZodGUID: zod.z.core.$constructor<zod.ZodGUID>;
+  ZodUUID: zod.z.core.$constructor<zod.ZodUUID>;
+  ZodURL: zod.z.core.$constructor<zod.ZodURL>;
+  ZodEmoji: zod.z.core.$constructor<zod.ZodEmoji>;
+  ZodNanoID: zod.z.core.$constructor<zod.ZodNanoID>;
+  ZodCUID: zod.z.core.$constructor<zod.ZodCUID>;
+  ZodCUID2: zod.z.core.$constructor<zod.ZodCUID2>;
+  ZodULID: zod.z.core.$constructor<zod.ZodULID>;
+  ZodXID: zod.z.core.$constructor<zod.ZodXID>;
+  ZodKSUID: zod.z.core.$constructor<zod.ZodKSUID>;
+  ZodIPv4: zod.z.core.$constructor<zod.ZodIPv4>;
+  ZodMAC: zod.z.core.$constructor<zod.ZodMAC>;
+  ZodIPv6: zod.z.core.$constructor<zod.ZodIPv6>;
+  ZodCIDRv4: zod.z.core.$constructor<zod.ZodCIDRv4>;
+  ZodCIDRv6: zod.z.core.$constructor<zod.ZodCIDRv6>;
+  ZodBase64: zod.z.core.$constructor<zod.ZodBase64>;
+  ZodBase64URL: zod.z.core.$constructor<zod.ZodBase64URL>;
+  ZodE164: zod.z.core.$constructor<zod.ZodE164>;
+  ZodJWT: zod.z.core.$constructor<zod.ZodJWT>;
+  ZodCustomStringFormat: zod.z.core.$constructor<zod.ZodCustomStringFormat>;
+  ZodNumber: zod.z.core.$constructor<zod.ZodNumber>;
+  ZodNumberFormat: zod.z.core.$constructor<zod.ZodNumberFormat>;
+  ZodBoolean: zod.z.core.$constructor<zod.ZodBoolean>;
+  ZodBigInt: zod.z.core.$constructor<zod.ZodBigInt>;
+  ZodBigIntFormat: zod.z.core.$constructor<zod.ZodBigIntFormat>;
+  ZodSymbol: zod.z.core.$constructor<zod.ZodSymbol>;
+  ZodUndefined: zod.z.core.$constructor<zod.ZodUndefined>;
+  undefined: typeof zod.undefined;
+  ZodNull: zod.z.core.$constructor<zod.ZodNull>;
+  null: typeof zod.null;
+  ZodAny: zod.z.core.$constructor<zod.ZodAny>;
+  ZodUnknown: zod.z.core.$constructor<zod.ZodUnknown>;
+  ZodNever: zod.z.core.$constructor<zod.ZodNever>;
+  ZodVoid: zod.z.core.$constructor<zod.ZodVoid>;
+  void: typeof zod.void;
+  ZodDate: zod.z.core.$constructor<zod.ZodDate>;
+  ZodArray: zod.z.core.$constructor<zod.ZodArray>;
+  ZodObject: zod.z.core.$constructor<zod.ZodObject>;
+  ZodUnion: zod.z.core.$constructor<zod.ZodUnion>;
+  ZodXor: zod.z.core.$constructor<zod.ZodXor>;
+  ZodDiscriminatedUnion: zod.z.core.$constructor<zod.ZodDiscriminatedUnion>;
+  ZodIntersection: zod.z.core.$constructor<zod.ZodIntersection>;
+  ZodTuple: zod.z.core.$constructor<zod.ZodTuple>;
+  ZodRecord: zod.z.core.$constructor<zod.ZodRecord>;
+  ZodMap: zod.z.core.$constructor<zod.ZodMap>;
+  ZodSet: zod.z.core.$constructor<zod.ZodSet>;
+  ZodEnum: zod.z.core.$constructor<zod.ZodEnum>;
+  enum: typeof zod.enum;
+  ZodLiteral: zod.z.core.$constructor<zod.ZodLiteral>;
+  ZodFile: zod.z.core.$constructor<zod.ZodFile>;
+  ZodTransform: zod.z.core.$constructor<zod.ZodTransform>;
+  ZodOptional: zod.z.core.$constructor<zod.ZodOptional>;
+  ZodExactOptional: zod.z.core.$constructor<zod.ZodExactOptional>;
+  ZodNullable: zod.z.core.$constructor<zod.ZodNullable>;
+  ZodDefault: zod.z.core.$constructor<zod.ZodDefault>;
+  ZodPrefault: zod.z.core.$constructor<zod.ZodPrefault>;
+  ZodNonOptional: zod.z.core.$constructor<zod.ZodNonOptional>;
+  ZodSuccess: zod.z.core.$constructor<zod.ZodSuccess>;
+  ZodCatch: zod.z.core.$constructor<zod.ZodCatch>;
+  catch: typeof zod.catch;
+  ZodNaN: zod.z.core.$constructor<zod.ZodNaN>;
+  ZodPipe: zod.z.core.$constructor<zod.ZodPipe>;
+  ZodCodec: zod.z.core.$constructor<zod.ZodCodec>;
+  ZodReadonly: zod.z.core.$constructor<zod.ZodReadonly>;
+  ZodTemplateLiteral: zod.z.core.$constructor<zod.ZodTemplateLiteral>;
+  ZodLazy: zod.z.core.$constructor<zod.ZodLazy>;
+  ZodPromise: zod.z.core.$constructor<zod.ZodPromise>;
+  ZodFunction: zod.z.core.$constructor<zod.ZodFunction>;
+  function: typeof zod._function;
+  ZodCustom: zod.z.core.$constructor<zod.ZodCustom>;
+  describe: typeof zod.core.describe;
+  meta: typeof zod.core.meta;
+  instanceof: typeof zod.instanceof;
+  stringbool: (_params?: string | zod.z.core.$ZodStringBoolParams) => zod.ZodCodec<zod.ZodString, zod.ZodBoolean>;
+  lt: typeof zod.core._lt;
+  lte: typeof zod.core._lte;
+  gt: typeof zod.core._gt;
+  gte: typeof zod.core._gte;
+  positive: typeof zod.core._positive;
+  negative: typeof zod.core._negative;
+  nonpositive: typeof zod.core._nonpositive;
+  nonnegative: typeof zod.core._nonnegative;
+  multipleOf: typeof zod.core._multipleOf;
+  maxSize: typeof zod.core._maxSize;
+  minSize: typeof zod.core._minSize;
+  size: typeof zod.core._size;
+  maxLength: typeof zod.core._maxLength;
+  minLength: typeof zod.core._minLength;
+  length: typeof zod.core._length;
+  regex: typeof zod.core._regex;
+  lowercase: typeof zod.core._lowercase;
+  uppercase: typeof zod.core._uppercase;
+  includes: typeof zod.core._includes;
+  startsWith: typeof zod.core._startsWith;
+  endsWith: typeof zod.core._endsWith;
+  property: typeof zod.core._property;
+  mime: typeof zod.core._mime;
+  overwrite: typeof zod.core._overwrite;
+  normalize: typeof zod.core._normalize;
+  trim: typeof zod.core._trim;
+  toLowerCase: typeof zod.core._toLowerCase;
+  toUpperCase: typeof zod.core._toUpperCase;
+  slugify: typeof zod.core._slugify;
+  ZodError: zod.z.core.$constructor<zod.ZodError>;
+  ZodRealError: zod.z.core.$constructor<zod.ZodError>;
+  parse: <T extends zod.z.core.$ZodType>(schema: T, value: unknown, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>, _params?: {
+    callee?: zod.z.core.util.AnyFunc;
+    Err?: zod.z.core.$ZodErrorClass;
+  }) => zod.z.core.output<T>;
+  parseAsync: <T extends zod.z.core.$ZodType>(schema: T, value: unknown, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>, _params?: {
+    callee?: zod.z.core.util.AnyFunc;
+    Err?: zod.z.core.$ZodErrorClass;
+  }) => Promise<zod.z.core.output<T>>;
+  safeParse: <T extends zod.z.core.$ZodType>(schema: T, value: unknown, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => zod.ZodSafeParseResult<zod.z.core.output<T>>;
+  safeParseAsync: <T extends zod.z.core.$ZodType>(schema: T, value: unknown, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => Promise<zod.ZodSafeParseResult<zod.z.core.output<T>>>;
+  encode: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.output<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => zod.z.core.input<T>;
+  decode: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.input<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => zod.z.core.output<T>;
+  encodeAsync: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.output<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => Promise<zod.z.core.input<T>>;
+  decodeAsync: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.input<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => Promise<zod.z.core.output<T>>;
+  safeEncode: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.output<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => zod.ZodSafeParseResult<zod.z.core.input<T>>;
+  safeDecode: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.input<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => zod.ZodSafeParseResult<zod.z.core.output<T>>;
+  safeEncodeAsync: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.output<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => Promise<zod.ZodSafeParseResult<zod.z.core.input<T>>>;
+  safeDecodeAsync: <T extends zod.z.core.$ZodType>(schema: T, value: zod.z.core.input<T>, _ctx?: zod.z.core.ParseContext<zod.z.core.$ZodIssue>) => Promise<zod.ZodSafeParseResult<zod.z.core.output<T>>>;
+  setErrorMap(map: zod.z.core.$ZodErrorMap): void;
+  getErrorMap(): zod.z.core.$ZodErrorMap<zod.z.core.$ZodIssue> | undefined;
+  ZodIssueCode: {
+    readonly invalid_type: "invalid_type";
+    readonly too_big: "too_big";
+    readonly too_small: "too_small";
+    readonly invalid_format: "invalid_format";
+    readonly not_multiple_of: "not_multiple_of";
+    readonly unrecognized_keys: "unrecognized_keys";
+    readonly invalid_union: "invalid_union";
+    readonly invalid_key: "invalid_key";
+    readonly invalid_element: "invalid_element";
+    readonly invalid_value: "invalid_value";
+    readonly custom: "custom";
+  };
+  ZodFirstPartyTypeKind: typeof zod.ZodFirstPartyTypeKind;
+};
+//#endregion
+export { Argument, type CLIType, type ColorizeHelpOptions, Command, type CommandLike, CommanderError, Help, type HelpSectionContent, type HelpSectionPosition, InvalidArgumentError, Option, type OptionValues, type StandardSchemaV1, bool, colorizeHelp, csv, date, email, float, int, intRange, json, path, port, regex, shouldColorize, uint, url, z };
+//# sourceMappingURL=index.d.mts.map