@paragrav/rhf-utils 0.76.0 → 0.78.0

package/dist/tsdown/types-DGFncyYT.d.ts

@@ -0,0 +1,1674 @@
+import { i as RhfUtilsFormOptions, r as SafeFieldValues, t as RhfUtilsContext } from "./RhfUtilsContextType-DBOvBnPF.js";
+import React$1 from "react";
+import { ControllerProps, FieldError, FieldPath, UseFormProps, UseFormReturn } from "react-hook-form";
+//#region src/errors/output/types.d.ts
+/**
+ * Config object for error output.
+ */
+type RhfUtilsErrorsOutputConsoleConfig = {
+  type?: 'debug' | 'error';
+  message?: string;
+};
+//#endregion
+//#region src/errors/flat/types.d.ts
+/**
+ * Flattened field errors object.
+ *
+ * @example
+ * ```ts
+ * {
+ *   'address.street': FieldError
+ * }
+ * ```
+ */
+type FlatFieldErrors = Record<string, FieldError>;
+//#endregion
+//#region src/errors/flat/context/useFlatFieldErrorsContext.d.ts
+type FlatFieldErrorsContext = {
+  all: FlatFieldErrors;
+  fields: FlatFieldErrors;
+  roots: FlatFieldErrors;
+  orphans: FlatFieldErrors;
+  hasErrors: boolean;
+  hasOrphans: boolean;
+};
+declare const _FormErrorsFlatContextProvider: import("react").Provider<FlatFieldErrorsContext | undefined>, useFlatFieldErrorsContext: () => FlatFieldErrorsContext;
+//#endregion
+//#region src/errors/flat/context/FlatFieldErrorsOutputConfig.d.ts
+type FlatFieldErrorsOutputConfig = {
+  /**
+   * Configure how/if errors should be outputted to console.
+   *
+   * Example use cases:
+   * - console.debug errors in development environment.
+   * - console.error certain errors in production environment.
+   */
+  console?: (context: FlatFieldErrorsContext) => RhfUtilsErrorsOutputConsoleConfig | null | false | undefined;
+  /**
+   * Configure how/if errors should be thrown.
+   *
+   * Example use case:
+   * - bring attention to certain errors in development environment.
+   */
+  throw?: (context: FlatFieldErrorsContext) => true | string | false | undefined;
+};
+//#endregion
+//#region src/form/rhf/UseFormPropsType.d.ts
+type RhfUseFormGlobalProps = Pick<UseFormProps, 'mode' | 'reValidateMode' | 'resetOptions' | 'context' | 'shouldFocusError' | 'shouldUnregister' | 'shouldUseNativeValidation' | 'progressive' | 'criteriaMode' | 'delayError'>;
+type RhfUseFormInstanceProps<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues> = Omit<UseFormProps<TFieldValues, unknown, TTransformedValues>, 'defaultValues' | 'resolver'>;
+//#endregion
+//#region src/form/defaults/UseRhfUtilsFormGlobalDefaults.d.ts
+/**
+ * Globally-relevant subset of defaults.
+ */
+type UseRhfUtilsFormGlobalDefaults = {
+  /**
+   * Default RHF `useForm` settings.
+   *
+   * (Exposes only non-local props.)
+   */
+  rhf?: RhfUseFormGlobalProps;
+  /**
+   * Global settings and defaults.
+   *
+   * (Extend this type via `Register` type to inject custom options/functionality via `Children` component.)
+   */
+  options?: RhfUtilsFormOptions;
+  /**
+   * Default props for form element.
+   */
+  form?: Pick<React$1.PropsWithoutRef<React$1.JSX.IntrinsicElements['form']>, 'className' | 'noValidate' | 'role'>;
+};
+//#endregion
+//#region src/submit/error/FormSubmitFieldErrors.d.ts
+/**
+ * Field errors structure based on RHF's `FieldErrors`.
+ *
+ * - Uses {@link SafeFieldValues} instead of more permissive `FieldValues`.
+ * - `root.<string>` keys allowed.
+ *   - `root` is reserved for special use cases.
+ * - simplified `ErrorOption` value.
+ */
+type FormSubmitFieldErrors<TFieldValues extends SafeFieldValues = SafeFieldValues, TApiValues extends undefined | SafeFieldValues = undefined, TAllValues extends SafeFieldValues = TApiValues extends undefined ? TFieldValues : TFieldValues & TApiValues> = Record<FieldPath<TAllValues> | `root.${string}`, {
+  message: string;
+  type?: string;
+}>;
+//#endregion
+//#region src/submit/error/FormSubmitError.d.ts
+declare class FormSubmitError<TFieldValues extends SafeFieldValues = SafeFieldValues, TApiValues extends undefined | SafeFieldValues = undefined> extends Error {
+  errors: FormSubmitFieldErrors<TFieldValues, TApiValues>;
+  constructor(errors: FormSubmitFieldErrors<TFieldValues, TApiValues>, message?: string);
+}
+//#endregion
+//#region src/submit/last/error/LastSubmitErrorType.d.ts
+type LastSubmitError = {
+  error: unknown;
+  event: React.BaseSyntheticEvent;
+};
+//#endregion
+//#region src/submit/last/status/LastSubmitStatusType.d.ts
+/** Last submit state. */
+type LastSubmitStatus = null | 'submitting' | 'success' | 'error';
+//#endregion
+//#region src/submit/last/context/LastSubmitContextType.d.ts
+type LastSubmitContext = {
+  status: {
+    ref: React.RefObject<LastSubmitStatus | null>;
+  };
+  error: {
+    /** Last submit error (with event). */
+    state: LastSubmitError | undefined;
+    set: (error: unknown, event: React.BaseSyntheticEvent) => void;
+    reset: () => void;
+  };
+};
+type LastSubmitContextRead = {
+  statusRef: LastSubmitContext['status']['ref'];
+  error: LastSubmitContext['error']['state'];
+};
+//#endregion
+//#region src/submit/UseRhfUtilsFormOnSubmitContextType.d.ts
+/**
+ * Props for onSubmit other than `data` and `event`.
+ *
+ * Consider keeping shape in line with `UseRhfUtilsFormChildrenProps` and `UseRhfUtilsFormReturn`.
+ */
+type UseRhfUtilsFormOnSubmitContext<TFieldValues extends SafeFieldValues = SafeFieldValues, TTransformedValues extends SafeFieldValues = TFieldValues, TApiValues extends undefined | SafeFieldValues = undefined> = {
+  utils: RhfUtilsContext;
+  lastSubmit: LastSubmitContextRead;
+  rhf: UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+  FormSubmitError: typeof FormSubmitError<TFieldValues, TApiValues>;
+};
+/**
+ * Props for onSubmitError other than `error` and `event`.
+ */
+type UseRhfUtilsFormOnSubmitErrorContext<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues> = {
+  utils: RhfUtilsContext;
+  lastSubmit: LastSubmitContextRead;
+  rhf: UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+  errors?: FormSubmitFieldErrors;
+};
+//#endregion
+//#region src/utils/types.d.ts
+type MaybePromise<T> = T | Promise<T>;
+/** Merge {@link C} into {@link B} into {@link A} (last taking highest precedence). */
+type Merge<A, B, C = unknown, D = unknown> = D & Omit<C, keyof D> & Omit<Omit<B, keyof C>, keyof D> & Omit<Omit<Omit<A, keyof B>, keyof C>, keyof D>;
+//#endregion
+//#region src/form/_Controller.d.ts
+type _ControllerProps<TFieldValues extends SafeFieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Omit<ControllerProps<TFieldValues, TName>, 'control'>;
+declare const _Controller: <TFieldValues extends SafeFieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(props: _ControllerProps<TFieldValues, TName>) => import("react").JSX.Element;
+//#endregion
+//#region src/client/config/RhfUtilsClientConfigUseFormHooksProps.d.ts
+/**
+ * RhfUtilsClientConfig's `useFormHooks` props.
+ */
+type RhfUtilsClientConfigUseFormHooksProps<TFieldValues extends SafeFieldValues = SafeFieldValues, TTransformedValues extends SafeFieldValues = TFieldValues> = Merge<RhfUtilsContext, {
+  lastSubmit: LastSubmitContextRead;
+  rhf: UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+}>;
+//#endregion
+//#region src/client/config/RhfUtilsClientConfigFormOutletProps.d.ts
+/**
+ * RhfUtilsClientConfig's FormComponent props.
+ */
+type RhfUtilsClientConfigFormOutletProps<TFieldValues extends SafeFieldValues = SafeFieldValues, TTransformedValues extends SafeFieldValues = TFieldValues> = Merge<RhfUtilsClientConfigUseFormHooksProps<TFieldValues, TTransformedValues>, {
+  /** Form instance children (`RhfUtilsZodForm.Children`) to output amid globally-injected code. */
+  Outlet: React.FC;
+  /** RHF Controller (SafeFieldValues-typed; no schema at this level). */
+  Controller: typeof _Controller<TFieldValues>;
+  /** Error class (SafeFieldValues-typed; no schema at this level). */
+  FormSubmitError: typeof FormSubmitError<TFieldValues>;
+}>;
+//#endregion
+//#region src/client/config/RhfUtilsClientConfigType.d.ts
+/**
+ * Client configuration object.
+ *
+ * Options under `defaults` can be overridden at form level.
+ */
+type RhfUtilsClientConfig = {
+  /**
+   * Default options for all forms. (Are overridden by form-specific options.)
+   */
+  defaults?: UseRhfUtilsFormGlobalDefaults;
+  /**
+   * Supply your own `<form>` component.
+   *
+   * (By default, a native {@link HTMLFormElement} is used.)
+   */
+  FormComponent?: React.FC<React.PropsWithChildren<React.HTMLAttributes<HTMLFormElement>>>;
+  /**
+   * Inject your own hooks across all form instances.
+   *
+   * @description
+   *
+   * (NOTE: context params are not schema-typed as not possible at this level.)
+   *
+   * @example
+   *
+   * See README.
+   */
+  useFormHooks?: (props: RhfUtilsClientConfigUseFormHooksProps) => void;
+  /**
+   * Inject your components across all form instances.
+   *
+   * @description
+   *
+   * (NOTE: context params are not schema-typed as not possible at this level.)
+   *
+   * @example
+   *
+   * See README.
+   */
+  FormOutlet?: React.FC<RhfUtilsClientConfigFormOutletProps>;
+  /**
+   * A hook that returns a callback that determines whether form can be cancelled at event-time.
+   *
+   * @description
+   *
+   * Cancellation of forms often doesn't involve navigation, making it more challenging to centrally handle.
+   * Your hook's returned callback should internally prompt user and return response as `boolean`
+   * indicating whether cancellation should be blocked. See `README.md` for example.
+   *
+   * @returns Callback that, given {@link RhfUtilsFormContext} at event-time, returns `boolean` value indicating whether form can be cancelled.
+   *
+   * Callback should return:
+   * `true`: if form can be cancelled (e.g., form not dirty or user confirmed via prompt); {@link UseRhfUtilsFormProps.onCancel} is called.
+   * `false`: form cannot be cancelled (e.g., user denied); {@link UseRhfUtilsFormProps.onCancel} is not called.
+   */
+  useCanFormBeCancelled?: () => (props: UseRhfUtilsFormOnSubmitContext) => MaybePromise<boolean>;
+  /**
+   * Global submit error handler when/if submit handler throws an error other than {@link FormSubmitError}.
+   *
+   * Example use case:
+   * - transform API errors to {@link FormSubmitFieldErrors}.
+   *
+   * @returns
+   * - if {@link FormSubmitFieldErrors}: merge into context errors.
+   * - if `undefined`: do nothing.
+   */
+  onSubmitErrorUnknown?: (error: unknown) => FormSubmitFieldErrors | undefined;
+  /**
+   * Configuration regarding RHF form state errors (`useFormContext().formState.errors`).
+   */
+  fieldErrors?: {
+    /**
+     * Configure how/if errors should be outputted for debugging/reporting (i.e., console and/or throwing).
+     */
+    output?: FlatFieldErrorsOutputConfig;
+  };
+};
+//#endregion
+//#region node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/typeAliases.d.cts
+type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+type Scalars = Primitive | Primitive[];
+//#endregion
+//#region node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/util.d.cts
+declare namespace util {
+  type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends (<V>() => V extends U ? 1 : 2) ? true : false;
+  export type isAny<T> = 0 extends 1 & T ? true : false;
+  export const assertEqual: <A, B>(_: AssertEqual<A, B>) => void;
+  export function assertIs<T>(_arg: T): void;
+  export function assertNever(_x: never): never;
+  export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+  export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
+  export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+  export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
+  export type InexactPartial<T> = { [k in keyof T]?: T[k] | undefined; };
+  export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
+  export const getValidEnumValues: (obj: any) => any[];
+  export const objectValues: (obj: any) => any[];
+  export const objectKeys: ObjectConstructor["keys"];
+  export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
+  export type identity<T> = objectUtil.identity<T>;
+  export type flatten<T> = objectUtil.flatten<T>;
+  export type noUndefined<T> = T extends undefined ? never : T;
+  export const isInteger: NumberConstructor["isInteger"];
+  export function joinValues<T extends any[]>(array: T, separator?: string): string;
+  export const jsonStringifyReplacer: (_: string, value: any) => any;
+  export {};
+}
+declare namespace objectUtil {
+  export type MergeShapes<U, V> = keyof U & keyof V extends never ? U & V : { [k in Exclude<keyof U, keyof V>]: U[k]; } & V;
+  type optionalKeys<T extends object> = { [k in keyof T]: undefined extends T[k] ? k : never; }[keyof T];
+  type requiredKeys<T extends object> = { [k in keyof T]: undefined extends T[k] ? never : k; }[keyof T];
+  export type addQuestionMarks<T extends object, _O = any> = { [K in requiredKeys<T>]: T[K]; } & { [K in optionalKeys<T>]?: T[K]; } & { [k in keyof T]?: unknown; };
+  export type identity<T> = T;
+  export type flatten<T> = identity<{ [k in keyof T]: T[k]; }>;
+  export type noNeverKeys<T> = { [k in keyof T]: [T[k]] extends [never] ? never : k; }[keyof T];
+  export type noNever<T> = identity<{ [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never; }>;
+  export const mergeShapes: <U, T>(first: U, second: T) => T & U;
+  export type extendShape<A extends object, B extends object> = keyof A & keyof B extends never ? A & B : { [K in keyof A as K extends keyof B ? never : K]: A[K]; } & { [K in keyof B]: B[K]; };
+  export {};
+}
+declare const ZodParsedType: {
+  string: "string";
+  nan: "nan";
+  number: "number";
+  integer: "integer";
+  float: "float";
+  boolean: "boolean";
+  date: "date";
+  bigint: "bigint";
+  symbol: "symbol";
+  function: "function";
+  undefined: "undefined";
+  null: "null";
+  array: "array";
+  object: "object";
+  unknown: "unknown";
+  promise: "promise";
+  void: "void";
+  never: "never";
+  map: "map";
+  set: "set";
+};
+type ZodParsedType = keyof typeof ZodParsedType;
+declare const getParsedType: (data: any) => ZodParsedType;
+//#endregion
+//#region node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/ZodError.d.cts
+type allKeys<T> = T extends any ? keyof T : never;
+type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
+type typeToFlattenedError<T, U = string> = {
+  formErrors: U[];
+  fieldErrors: { [P in allKeys<T>]?: U[]; };
+};
+declare const ZodIssueCode: {
+  invalid_type: "invalid_type";
+  invalid_literal: "invalid_literal";
+  custom: "custom";
+  invalid_union: "invalid_union";
+  invalid_union_discriminator: "invalid_union_discriminator";
+  invalid_enum_value: "invalid_enum_value";
+  unrecognized_keys: "unrecognized_keys";
+  invalid_arguments: "invalid_arguments";
+  invalid_return_type: "invalid_return_type";
+  invalid_date: "invalid_date";
+  invalid_string: "invalid_string";
+  too_small: "too_small";
+  too_big: "too_big";
+  invalid_intersection_types: "invalid_intersection_types";
+  not_multiple_of: "not_multiple_of";
+  not_finite: "not_finite";
+};
+type ZodIssueCode = keyof typeof ZodIssueCode;
+type ZodIssueBase = {
+  path: (string | number)[];
+  message?: string | undefined;
+};
+interface ZodInvalidTypeIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_type;
+  expected: ZodParsedType;
+  received: ZodParsedType;
+}
+interface ZodInvalidLiteralIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_literal;
+  expected: unknown;
+  received: unknown;
+}
+interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.unrecognized_keys;
+  keys: string[];
+}
+interface ZodInvalidUnionIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_union;
+  unionErrors: ZodError[];
+}
+interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_union_discriminator;
+  options: Primitive[];
+}
+interface ZodInvalidEnumValueIssue extends ZodIssueBase {
+  received: string | number;
+  code: typeof ZodIssueCode.invalid_enum_value;
+  options: (string | number)[];
+}
+interface ZodInvalidArgumentsIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_arguments;
+  argumentsError: ZodError;
+}
+interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_return_type;
+  returnTypeError: ZodError;
+}
+interface ZodInvalidDateIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_date;
+}
+type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
+  includes: string;
+  position?: number | undefined;
+} | {
+  startsWith: string;
+} | {
+  endsWith: string;
+};
+interface ZodInvalidStringIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_string;
+  validation: StringValidation;
+}
+interface ZodTooSmallIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.too_small;
+  minimum: number | bigint;
+  inclusive: boolean;
+  exact?: boolean;
+  type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+interface ZodTooBigIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.too_big;
+  maximum: number | bigint;
+  inclusive: boolean;
+  exact?: boolean;
+  type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_intersection_types;
+}
+interface ZodNotMultipleOfIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.not_multiple_of;
+  multipleOf: number | bigint;
+}
+interface ZodNotFiniteIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.not_finite;
+}
+interface ZodCustomIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.custom;
+  params?: {
+    [k: string]: any;
+  };
+}
+type DenormalizedError = {
+  [k: string]: DenormalizedError | string[];
+};
+type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
+type ZodIssue = ZodIssueOptionalMessage & {
+  fatal?: boolean | undefined;
+  message: string;
+};
+declare const quotelessJson: (obj: any) => string;
+type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? { [K in keyof T]?: ZodFormattedError<T[K]>; } : T extends any[] ? {
+  [k: number]: ZodFormattedError<T[number]>;
+} : T extends object ? { [K in keyof T]?: ZodFormattedError<T[K]>; } : unknown;
+type ZodFormattedError<T, U = string> = {
+  _errors: U[];
+} & recursiveZodFormattedError<NonNullable<T>>;
+type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;
+declare class ZodError<T = any> extends Error {
+  issues: ZodIssue[];
+  get errors(): ZodIssue[];
+  constructor(issues: ZodIssue[]);
+  format(): ZodFormattedError<T>;
+  format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
+  static create: (issues: ZodIssue[]) => ZodError<any>;
+  static assert(value: unknown): asserts value is ZodError;
+  toString(): string;
+  get message(): string;
+  get isEmpty(): boolean;
+  addIssue: (sub: ZodIssue) => void;
+  addIssues: (subs?: ZodIssue[]) => void;
+  flatten(): typeToFlattenedError<T>;
+  flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
+  get formErrors(): typeToFlattenedError<T, string>;
+}
+type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
+type IssueData = stripPath<ZodIssueOptionalMessage> & {
+  path?: (string | number)[];
+  fatal?: boolean | undefined;
+};
+type ErrorMapCtx = {
+  defaultError: string;
+  data: any;
+};
+type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+  message: string;
+};
+//#endregion
+//#region node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.d.cts
+declare const makeIssue: (params: {
+  data: any;
+  path: (string | number)[];
+  errorMaps: ZodErrorMap[];
+  issueData: IssueData;
+}) => ZodIssue;
+type ParseParams = {
+  path: (string | number)[];
+  errorMap: ZodErrorMap;
+  async: boolean;
+};
+type ParsePathComponent = string | number;
+type ParsePath = ParsePathComponent[];
+declare const EMPTY_PATH: ParsePath;
+interface ParseContext {
+  readonly common: {
+    readonly issues: ZodIssue[];
+    readonly contextualErrorMap?: ZodErrorMap | undefined;
+    readonly async: boolean;
+  };
+  readonly path: ParsePath;
+  readonly schemaErrorMap?: ZodErrorMap | undefined;
+  readonly parent: ParseContext | null;
+  readonly data: any;
+  readonly parsedType: ZodParsedType;
+}
+type ParseInput = {
+  data: any;
+  path: (string | number)[];
+  parent: ParseContext;
+};
+declare function addIssueToContext(ctx: ParseContext, issueData: IssueData): void;
+type ObjectPair = {
+  key: SyncParseReturnType<any>;
+  value: SyncParseReturnType<any>;
+};
+declare class ParseStatus {
+  value: "aborted" | "dirty" | "valid";
+  dirty(): void;
+  abort(): void;
+  static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;
+  static mergeObjectAsync(status: ParseStatus, pairs: {
+    key: ParseReturnType<any>;
+    value: ParseReturnType<any>;
+  }[]): Promise<SyncParseReturnType<any>>;
+  static mergeObjectSync(status: ParseStatus, pairs: {
+    key: SyncParseReturnType<any>;
+    value: SyncParseReturnType<any>;
+    alwaysSet?: boolean;
+  }[]): SyncParseReturnType;
+}
+interface ParseResult {
+  status: "aborted" | "dirty" | "valid";
+  data: any;
+}
+type INVALID = {
+  status: "aborted";
+};
+declare const INVALID: INVALID;
+type DIRTY<T> = {
+  status: "dirty";
+  value: T;
+};
+declare const DIRTY: <T>(value: T) => DIRTY<T>;
+type OK<T> = {
+  status: "valid";
+  value: T;
+};
+declare const OK: <T>(value: T) => OK<T>;
+type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
+type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
+type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
+declare const isAborted: (x: ParseReturnType<any>) => x is INVALID;
+declare const isDirty: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
+declare const isValid: <T>(x: ParseReturnType<T>) => x is OK<T>;
+declare const isAsync: <T>(x: ParseReturnType<T>) => x is AsyncParseReturnType<T>;
+//#endregion
+//#region node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/enumUtil.d.cts
+declare namespace enumUtil {
+  type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends ((k: infer Intersection) => void) ? Intersection : never;
+  type GetUnionLast<T> = UnionToIntersectionFn<T> extends (() => infer Last) ? Last : never;
+  type UnionToTuple<T, Tuple extends unknown[] = []> = [T] extends [never] ? Tuple : UnionToTuple<Exclude<T, GetUnionLast<T>>, [GetUnionLast<T>, ...Tuple]>;
+  type CastToStringTuple<T> = T extends [string, ...string[]] ? T : never;
+  export type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>;
+  export {};
+}
+//#endregion
+//#region node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/errorUtil.d.cts
+declare namespace errorUtil {
+  type ErrMessage = string | {
+    message?: string | undefined;
+  };
+  const errToObj: (message?: ErrMessage) => {
+    message?: string | undefined;
+  };
+  const toString: (message?: ErrMessage) => string | undefined;
+}
+//#endregion
+//#region node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/partialUtil.d.cts
+declare namespace partialUtil {
+  type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{ [k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>>; }, T["_def"]["unknownKeys"], T["_def"]["catchall"]> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? { [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never; } extends (infer PI) ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
+}
+//#endregion
+//#region node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/standard-schema.d.cts
+/**
+ * The Standard Schema interface.
+ */
+type StandardSchemaV1<Input = unknown, Output = Input> = {
+  /**
+   * The Standard Schema properties.
+   */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+};
+declare namespace StandardSchemaV1 {
+  /**
+   * The Standard Schema properties interface.
+   */
+  export interface Props<Input = unknown, Output = Input> {
+    /**
+     * The version number of the standard.
+     */
+    readonly version: 1;
+    /**
+     * The vendor name of the schema library.
+     */
+    readonly vendor: string;
+    /**
+     * Validates unknown input values.
+     */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /**
+     * Inferred types associated with the schema.
+     */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /**
+   * The result interface of the validate function.
+   */
+  export type Result<Output> = SuccessResult<Output> | FailureResult;
+  /**
+   * The result interface if validation succeeds.
+   */
+  export interface SuccessResult<Output> {
+    /**
+     * The typed output value.
+     */
+    readonly value: Output;
+    /**
+     * The non-existent issues.
+     */
+    readonly issues?: undefined;
+  }
+  /**
+   * The result interface if validation fails.
+   */
+  export interface FailureResult {
+    /**
+     * The issues of failed validation.
+     */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /**
+   * The issue interface of the failure output.
+   */
+  export interface Issue {
+    /**
+     * The error message of the issue.
+     */
+    readonly message: string;
+    /**
+     * The path of the issue, if any.
+     */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /**
+   * The path segment interface of the issue.
+   */
+  export interface PathSegment {
+    /**
+     * The key representing a path segment.
+     */
+    readonly key: PropertyKey;
+  }
+  /**
+   * The Standard Schema types interface.
+   */
+  export interface Types<Input = unknown, Output = Input> {
+    /**
+     * The input type of the schema.
+     */
+    readonly input: Input;
+    /**
+     * The output type of the schema.
+     */
+    readonly output: Output;
+  }
+  /**
+   * Infers the input type of a Standard Schema.
+   */
+  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /**
+   * Infers the output type of a Standard Schema.
+   */
+  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+  export {};
+}
+//#endregion
+//#region node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.d.cts
+interface RefinementCtx {
+  addIssue: (arg: IssueData) => void;
+  path: (string | number)[];
+}
+type ZodRawShape = {
+  [k: string]: ZodTypeAny;
+};
+type ZodTypeAny = ZodType<any, any, any>;
+type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
+type input<T extends ZodType<any, any, any>> = T["_input"];
+type output<T extends ZodType<any, any, any>> = T["_output"];
+type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
+interface ZodTypeDef {
+  errorMap?: ZodErrorMap | undefined;
+  description?: string | undefined;
+}
+type RawCreateParams = {
+  errorMap?: ZodErrorMap | undefined;
+  invalid_type_error?: string | undefined;
+  required_error?: string | undefined;
+  message?: string | undefined;
+  description?: string | undefined;
+} | undefined;
+type ProcessedCreateParams = {
+  errorMap?: ZodErrorMap | undefined;
+  description?: string | undefined;
+};
+type SafeParseSuccess<Output> = {
+  success: true;
+  data: Output;
+  error?: never;
+};
+type SafeParseError<Input> = {
+  success: false;
+  error: ZodError<Input>;
+  data?: never;
+};
+type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
+declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
+  readonly _type: Output;
+  readonly _output: Output;
+  readonly _input: Input;
+  readonly _def: Def;
+  get description(): string | undefined;
+  "~standard": StandardSchemaV1.Props<Input, Output>;
+  abstract _parse(input: ParseInput): ParseReturnType<Output>;
+  _getType(input: ParseInput): string;
+  _getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;
+  _processInputParams(input: ParseInput): {
+    status: ParseStatus;
+    ctx: ParseContext;
+  };
+  _parseSync(input: ParseInput): SyncParseReturnType<Output>;
+  _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
+  parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;
+  safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;
+  "~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;
+  parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;
+  safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
+  /** Alias of safeParseAsync */
+  spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
+  refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
+  refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
+  refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
+  refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;
+  _refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;
+  superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): ZodEffects<this, RefinedOutput, Input>;
+  superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<this, Output, Input>;
+  superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<this, Output, Input>;
+  constructor(def: Def);
+  optional(): ZodOptional<this>;
+  nullable(): ZodNullable<this>;
+  nullish(): ZodOptional<ZodNullable<this>>;
+  array(): ZodArray<this>;
+  promise(): ZodPromise<this>;
+  or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;
+  and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;
+  transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
+  default(def: util.noUndefined<Input>): ZodDefault<this>;
+  default(def: () => util.noUndefined<Input>): ZodDefault<this>;
+  brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;
+  catch(def: Output): ZodCatch<this>;
+  catch(def: (ctx: {
+    error: ZodError;
+    input: Input;
+  }) => Output): ZodCatch<this>;
+  describe(description: string): this;
+  pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;
+  readonly(): ZodReadonly<this>;
+  isOptional(): boolean;
+  isNullable(): boolean;
+}
+type IpVersion = "v4" | "v6";
+type ZodStringCheck = {
+  kind: "min";
+  value: number;
+  message?: string | undefined;
+} | {
+  kind: "max";
+  value: number;
+  message?: string | undefined;
+} | {
+  kind: "length";
+  value: number;
+  message?: string | undefined;
+} | {
+  kind: "email";
+  message?: string | undefined;
+} | {
+  kind: "url";
+  message?: string | undefined;
+} | {
+  kind: "emoji";
+  message?: string | undefined;
+} | {
+  kind: "uuid";
+  message?: string | undefined;
+} | {
+  kind: "nanoid";
+  message?: string | undefined;
+} | {
+  kind: "cuid";
+  message?: string | undefined;
+} | {
+  kind: "includes";
+  value: string;
+  position?: number | undefined;
+  message?: string | undefined;
+} | {
+  kind: "cuid2";
+  message?: string | undefined;
+} | {
+  kind: "ulid";
+  message?: string | undefined;
+} | {
+  kind: "startsWith";
+  value: string;
+  message?: string | undefined;
+} | {
+  kind: "endsWith";
+  value: string;
+  message?: string | undefined;
+} | {
+  kind: "regex";
+  regex: RegExp;
+  message?: string | undefined;
+} | {
+  kind: "trim";
+  message?: string | undefined;
+} | {
+  kind: "toLowerCase";
+  message?: string | undefined;
+} | {
+  kind: "toUpperCase";
+  message?: string | undefined;
+} | {
+  kind: "jwt";
+  alg?: string;
+  message?: string | undefined;
+} | {
+  kind: "datetime";
+  offset: boolean;
+  local: boolean;
+  precision: number | null;
+  message?: string | undefined;
+} | {
+  kind: "date";
+  message?: string | undefined;
+} | {
+  kind: "time";
+  precision: number | null;
+  message?: string | undefined;
+} | {
+  kind: "duration";
+  message?: string | undefined;
+} | {
+  kind: "ip";
+  version?: IpVersion | undefined;
+  message?: string | undefined;
+} | {
+  kind: "cidr";
+  version?: IpVersion | undefined;
+  message?: string | undefined;
+} | {
+  kind: "base64";
+  message?: string | undefined;
+} | {
+  kind: "base64url";
+  message?: string | undefined;
+};
+interface ZodStringDef extends ZodTypeDef {
+  checks: ZodStringCheck[];
+  typeName: ZodFirstPartyTypeKind.ZodString;
+  coerce: boolean;
+}
+declare function datetimeRegex(args: {
+  precision?: number | null;
+  offset?: boolean;
+  local?: boolean;
+}): RegExp;
+declare class ZodString extends ZodType<string, ZodStringDef, string> {
+  _parse(input: ParseInput): ParseReturnType<string>;
+  protected _regex(regex: RegExp, validation: StringValidation, message?: errorUtil.ErrMessage): ZodEffects<this, string, string>;
+  _addCheck(check: ZodStringCheck): ZodString;
+  email(message?: errorUtil.ErrMessage): ZodString;
+  url(message?: errorUtil.ErrMessage): ZodString;
+  emoji(message?: errorUtil.ErrMessage): ZodString;
+  uuid(message?: errorUtil.ErrMessage): ZodString;
+  nanoid(message?: errorUtil.ErrMessage): ZodString;
+  cuid(message?: errorUtil.ErrMessage): ZodString;
+  cuid2(message?: errorUtil.ErrMessage): ZodString;
+  ulid(message?: errorUtil.ErrMessage): ZodString;
+  base64(message?: errorUtil.ErrMessage): ZodString;
+  base64url(message?: errorUtil.ErrMessage): ZodString;
+  jwt(options?: {
+    alg?: string;
+    message?: string | undefined;
+  }): ZodString;
+  ip(options?: string | {
+    version?: IpVersion;
+    message?: string | undefined;
+  }): ZodString;
+  cidr(options?: string | {
+    version?: IpVersion;
+    message?: string | undefined;
+  }): ZodString;
+  datetime(options?: string | {
+    message?: string | undefined;
+    precision?: number | null;
+    offset?: boolean;
+    local?: boolean;
+  }): ZodString;
+  date(message?: string): ZodString;
+  time(options?: string | {
+    message?: string | undefined;
+    precision?: number | null;
+  }): ZodString;
+  duration(message?: errorUtil.ErrMessage): ZodString;
+  regex(regex: RegExp, message?: errorUtil.ErrMessage): ZodString;
+  includes(value: string, options?: {
+    message?: string;
+    position?: number;
+  }): ZodString;
+  startsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
+  endsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
+  min(minLength: number, message?: errorUtil.ErrMessage): ZodString;
+  max(maxLength: number, message?: errorUtil.ErrMessage): ZodString;
+  length(len: number, message?: errorUtil.ErrMessage): ZodString;
+  /**
+   * Equivalent to `.min(1)`
+   */
+  nonempty(message?: errorUtil.ErrMessage): ZodString;
+  trim(): ZodString;
+  toLowerCase(): ZodString;
+  toUpperCase(): ZodString;
+  get isDatetime(): boolean;
+  get isDate(): boolean;
+  get isTime(): boolean;
+  get isDuration(): boolean;
+  get isEmail(): boolean;
+  get isURL(): boolean;
+  get isEmoji(): boolean;
+  get isUUID(): boolean;
+  get isNANOID(): boolean;
+  get isCUID(): boolean;
+  get isCUID2(): boolean;
+  get isULID(): boolean;
+  get isIP(): boolean;
+  get isCIDR(): boolean;
+  get isBase64(): boolean;
+  get isBase64url(): boolean;
+  get minLength(): number | null;
+  get maxLength(): number | null;
+  static create: (params?: RawCreateParams & {
+    coerce?: true;
+  }) => ZodString;
+}
+type ZodNumberCheck = {
+  kind: "min";
+  value: number;
+  inclusive: boolean;
+  message?: string | undefined;
+} | {
+  kind: "max";
+  value: number;
+  inclusive: boolean;
+  message?: string | undefined;
+} | {
+  kind: "int";
+  message?: string | undefined;
+} | {
+  kind: "multipleOf";
+  value: number;
+  message?: string | undefined;
+} | {
+  kind: "finite";
+  message?: string | undefined;
+};
+interface ZodNumberDef extends ZodTypeDef {
+  checks: ZodNumberCheck[];
+  typeName: ZodFirstPartyTypeKind.ZodNumber;
+  coerce: boolean;
+}
+declare class ZodNumber extends ZodType<number, ZodNumberDef, number> {
+  _parse(input: ParseInput): ParseReturnType<number>;
+  static create: (params?: RawCreateParams & {
+    coerce?: boolean;
+  }) => ZodNumber;
+  gte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  min: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
+  gt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  lte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  max: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
+  lt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  protected setLimit(kind: "min" | "max", value: number, inclusive: boolean, message?: string): ZodNumber;
+  _addCheck(check: ZodNumberCheck): ZodNumber;
+  int(message?: errorUtil.ErrMessage): ZodNumber;
+  positive(message?: errorUtil.ErrMessage): ZodNumber;
+  negative(message?: errorUtil.ErrMessage): ZodNumber;
+  nonpositive(message?: errorUtil.ErrMessage): ZodNumber;
+  nonnegative(message?: errorUtil.ErrMessage): ZodNumber;
+  multipleOf(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  step: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
+  finite(message?: errorUtil.ErrMessage): ZodNumber;
+  safe(message?: errorUtil.ErrMessage): ZodNumber;
+  get minValue(): number | null;
+  get maxValue(): number | null;
+  get isInt(): boolean;
+  get isFinite(): boolean;
+}
+type ZodBigIntCheck = {
+  kind: "min";
+  value: bigint;
+  inclusive: boolean;
+  message?: string | undefined;
+} | {
+  kind: "max";
+  value: bigint;
+  inclusive: boolean;
+  message?: string | undefined;
+} | {
+  kind: "multipleOf";
+  value: bigint;
+  message?: string | undefined;
+};
+interface ZodBigIntDef extends ZodTypeDef {
+  checks: ZodBigIntCheck[];
+  typeName: ZodFirstPartyTypeKind.ZodBigInt;
+  coerce: boolean;
+}
+declare class ZodBigInt extends ZodType<bigint, ZodBigIntDef, bigint> {
+  _parse(input: ParseInput): ParseReturnType<bigint>;
+  _getInvalidInput(input: ParseInput): INVALID;
+  static create: (params?: RawCreateParams & {
+    coerce?: boolean;
+  }) => ZodBigInt;
+  gte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  min: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
+  gt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  lte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  max: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
+  lt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  protected setLimit(kind: "min" | "max", value: bigint, inclusive: boolean, message?: string): ZodBigInt;
+  _addCheck(check: ZodBigIntCheck): ZodBigInt;
+  positive(message?: errorUtil.ErrMessage): ZodBigInt;
+  negative(message?: errorUtil.ErrMessage): ZodBigInt;
+  nonpositive(message?: errorUtil.ErrMessage): ZodBigInt;
+  nonnegative(message?: errorUtil.ErrMessage): ZodBigInt;
+  multipleOf(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  get minValue(): bigint | null;
+  get maxValue(): bigint | null;
+}
+interface ZodBooleanDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodBoolean;
+  coerce: boolean;
+}
+declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef, boolean> {
+  _parse(input: ParseInput): ParseReturnType<boolean>;
+  static create: (params?: RawCreateParams & {
+    coerce?: boolean;
+  }) => ZodBoolean;
+}
+type ZodDateCheck = {
+  kind: "min";
+  value: number;
+  message?: string | undefined;
+} | {
+  kind: "max";
+  value: number;
+  message?: string | undefined;
+};
+interface ZodDateDef extends ZodTypeDef {
+  checks: ZodDateCheck[];
+  coerce: boolean;
+  typeName: ZodFirstPartyTypeKind.ZodDate;
+}
+declare class ZodDate extends ZodType<Date, ZodDateDef, Date> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  _addCheck(check: ZodDateCheck): ZodDate;
+  min(minDate: Date, message?: errorUtil.ErrMessage): ZodDate;
+  max(maxDate: Date, message?: errorUtil.ErrMessage): ZodDate;
+  get minDate(): Date | null;
+  get maxDate(): Date | null;
+  static create: (params?: RawCreateParams & {
+    coerce?: boolean;
+  }) => ZodDate;
+}
+interface ZodSymbolDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodSymbol;
+}
+declare class ZodSymbol extends ZodType<symbol, ZodSymbolDef, symbol> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodSymbol;
+}
+interface ZodUndefinedDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodUndefined;
+}
+declare class ZodUndefined extends ZodType<undefined, ZodUndefinedDef, undefined> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  params?: RawCreateParams;
+  static create: (params?: RawCreateParams) => ZodUndefined;
+}
+interface ZodNullDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodNull;
+}
+declare class ZodNull extends ZodType<null, ZodNullDef, null> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodNull;
+}
+interface ZodAnyDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodAny;
+}
+declare class ZodAny extends ZodType<any, ZodAnyDef, any> {
+  _any: true;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodAny;
+}
+interface ZodUnknownDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodUnknown;
+}
+declare class ZodUnknown extends ZodType<unknown, ZodUnknownDef, unknown> {
+  _unknown: true;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodUnknown;
+}
+interface ZodNeverDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodNever;
+}
+declare class ZodNever extends ZodType<never, ZodNeverDef, never> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodNever;
+}
+interface ZodVoidDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodVoid;
+}
+declare class ZodVoid extends ZodType<void, ZodVoidDef, void> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodVoid;
+}
+interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  type: T;
+  typeName: ZodFirstPartyTypeKind.ZodArray;
+  exactLength: {
+    value: number;
+    message?: string | undefined;
+  } | null;
+  minLength: {
+    value: number;
+    message?: string | undefined;
+  } | null;
+  maxLength: {
+    value: number;
+    message?: string | undefined;
+  } | null;
+}
+type ArrayCardinality = "many" | "atleastone";
+type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];
+declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> extends ZodType<arrayOutputType<T, Cardinality>, ZodArrayDef<T>, Cardinality extends "atleastone" ? [T["_input"], ...T["_input"][]] : T["_input"][]> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get element(): T;
+  min(minLength: number, message?: errorUtil.ErrMessage): this;
+  max(maxLength: number, message?: errorUtil.ErrMessage): this;
+  length(len: number, message?: errorUtil.ErrMessage): this;
+  nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
+  static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
+}
+type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
+type UnknownKeysParam = "passthrough" | "strict" | "strip";
+interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodObject;
+  shape: () => T;
+  catchall: Catchall;
+  unknownKeys: UnknownKeys;
+}
+type mergeTypes<A, B> = { [k in keyof A | keyof B]: k extends keyof B ? B[k] : k extends keyof A ? A[k] : never; };
+type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
+type baseObjectOutputType<Shape extends ZodRawShape> = { [k in keyof Shape]: Shape[k]["_output"]; };
+type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
+type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{ [k in keyof Shape]: Shape[k]["_input"]; }>;
+type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {
+  [k: string]: T["_output"];
+};
+type CatchallInput<T extends ZodType> = ZodType extends T ? unknown : {
+  [k: string]: T["_input"];
+};
+type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
+  [k: string]: unknown;
+} : unknown;
+type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
+type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+type noUnrecognized<Obj extends object, Shape extends object> = { [k in keyof Obj]: k extends keyof Shape ? Obj[k] : never; };
+declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
+  private _cached;
+  _getCached(): {
+    shape: T;
+    keys: string[];
+  };
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get shape(): T;
+  strict(message?: errorUtil.ErrMessage): ZodObject<T, "strict", Catchall>;
+  strip(): ZodObject<T, "strip", Catchall>;
+  passthrough(): ZodObject<T, "passthrough", Catchall>;
+  /**
+   * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
+   * If you want to pass through unknown properties, use `.passthrough()` instead.
+   */
+  nonstrict: () => ZodObject<T, "passthrough", Catchall>;
+  extend<Augmentation extends ZodRawShape>(augmentation: Augmentation): ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
+  /**
+   * @deprecated Use `.extend` instead
+   *  */
+  augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
+  /**
+   * Prior to zod@1.0.12 there was a bug in the
+   * inferred type of merged objects. Please
+   * upgrade if you are experiencing issues.
+   */
+  merge<Incoming extends AnyZodObject, Augmentation extends Incoming["shape"]>(merging: Incoming): ZodObject<objectUtil.extendShape<T, Augmentation>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;
+  setKey<Key extends string, Schema extends ZodTypeAny>(key: Key, schema: Schema): ZodObject<T & { [k in Key]: Schema; }, UnknownKeys, Catchall>;
+  catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
+  pick<Mask extends util.Exactly<{ [k in keyof T]?: true; }, Mask>>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
+  omit<Mask extends util.Exactly<{ [k in keyof T]?: true; }, Mask>>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
+  /**
+   * @deprecated
+   */
+  deepPartial(): partialUtil.DeepPartial<this>;
+  partial(): ZodObject<{ [k in keyof T]: ZodOptional<T[k]>; }, UnknownKeys, Catchall>;
+  partial<Mask extends util.Exactly<{ [k in keyof T]?: true; }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{ [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k]; }>, UnknownKeys, Catchall>;
+  required(): ZodObject<{ [k in keyof T]: deoptional<T[k]>; }, UnknownKeys, Catchall>;
+  required<Mask extends util.Exactly<{ [k in keyof T]?: true; }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{ [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k]; }>, UnknownKeys, Catchall>;
+  keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
+  static create: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
+  static strictCreate: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
+  static lazycreate: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
+}
+type AnyZodObject = ZodObject<any, any, any>;
+type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
+interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>> extends ZodTypeDef {
+  options: T;
+  typeName: ZodFirstPartyTypeKind.ZodUnion;
+}
+declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get options(): T;
+  static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
+}
+type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{ [key in Discriminator]: ZodTypeAny; } & ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+interface ZodDiscriminatedUnionDef<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> extends ZodTypeDef {
+  discriminator: Discriminator;
+  options: Options;
+  optionsMap: Map<Primitive, ZodDiscriminatedUnionOption<any>>;
+  typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
+}
+declare class ZodDiscriminatedUnion<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<Discriminator>[]> extends ZodType<output<Options[number]>, ZodDiscriminatedUnionDef<Discriminator, Options>, input<Options[number]>> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get discriminator(): Discriminator;
+  get options(): Options;
+  get optionsMap(): Map<Primitive, ZodDiscriminatedUnionOption<any>>;
+  /**
+   * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
+   * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
+   * have a different value for each object in the union.
+   * @param discriminator the name of the discriminator property
+   * @param types an array of object schemas
+   * @param params
+   */
+  static create<Discriminator extends string, Types extends readonly [ZodDiscriminatedUnionOption<Discriminator>, ...ZodDiscriminatedUnionOption<Discriminator>[]]>(discriminator: Discriminator, options: Types, params?: RawCreateParams): ZodDiscriminatedUnion<Discriminator, Types>;
+}
+interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  left: T;
+  right: U;
+  typeName: ZodFirstPartyTypeKind.ZodIntersection;
+}
+declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
+}
+type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
+type AssertArray<T> = T extends any[] ? T : never;
+type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_output"] : never; }>;
+type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
+type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_input"] : never; }>;
+type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;
+interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodTypeDef {
+  items: T;
+  rest: Rest;
+  typeName: ZodFirstPartyTypeKind.ZodTuple;
+}
+type AnyZodTuple = ZodTuple<[ZodTypeAny, ...ZodTypeAny[]] | [], ZodTypeAny | null>;
+declare class ZodTuple<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get items(): T;
+  rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema>;
+  static create: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
+}
+interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  valueType: Value;
+  keyType: Key;
+  typeName: ZodFirstPartyTypeKind.ZodRecord;
+}
+type KeySchema = ZodType<string | number | symbol, any, any>;
+type RecordType<K extends string | number | symbol, V> = [string] extends [K] ? Record<K, V> : [number] extends [K] ? Record<K, V> : [symbol] extends [K] ? Record<K, V> : [BRAND<string | number | symbol>] extends [K] ? Record<K, V> : Partial<Record<K, V>>;
+declare class ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<RecordType<Key["_output"], Value["_output"]>, ZodRecordDef<Key, Value>, RecordType<Key["_input"], Value["_input"]>> {
+  get keySchema(): Key;
+  get valueSchema(): Value;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get element(): Value;
+  static create<Value extends ZodTypeAny>(valueType: Value, params?: RawCreateParams): ZodRecord<ZodString, Value>;
+  static create<Keys extends KeySchema, Value extends ZodTypeAny>(keySchema: Keys, valueType: Value, params?: RawCreateParams): ZodRecord<Keys, Value>;
+}
+interface ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  valueType: Value;
+  keyType: Key;
+  typeName: ZodFirstPartyTypeKind.ZodMap;
+}
+declare class ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Map<Key["_output"], Value["_output"]>, ZodMapDef<Key, Value>, Map<Key["_input"], Value["_input"]>> {
+  get keySchema(): Key;
+  get valueSchema(): Value;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
+}
+interface ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  valueType: Value;
+  typeName: ZodFirstPartyTypeKind.ZodSet;
+  minSize: {
+    value: number;
+    message?: string | undefined;
+  } | null;
+  maxSize: {
+    value: number;
+    message?: string | undefined;
+  } | null;
+}
+declare class ZodSet<Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Set<Value["_output"]>, ZodSetDef<Value>, Set<Value["_input"]>> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  min(minSize: number, message?: errorUtil.ErrMessage): this;
+  max(maxSize: number, message?: errorUtil.ErrMessage): this;
+  size(size: number, message?: errorUtil.ErrMessage): this;
+  nonempty(message?: errorUtil.ErrMessage): ZodSet<Value>;
+  static create: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
+}
+interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  args: Args;
+  returns: Returns;
+  typeName: ZodFirstPartyTypeKind.ZodFunction;
+}
+type OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_input"] extends Array<any> ? (...args: Args["_input"]) => Returns["_output"] : never;
+type InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_output"] extends Array<any> ? (...args: Args["_output"]) => Returns["_input"] : never;
+declare class ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> extends ZodType<OuterTypeOfFunction<Args, Returns>, ZodFunctionDef<Args, Returns>, InnerTypeOfFunction<Args, Returns>> {
+  _parse(input: ParseInput): ParseReturnType<any>;
+  parameters(): Args;
+  returnType(): Returns;
+  args<Items extends Parameters<(typeof ZodTuple)["create"]>[0]>(...items: Items): ZodFunction<ZodTuple<Items, ZodUnknown>, Returns>;
+  returns<NewReturnType extends ZodType<any, any, any>>(returnType: NewReturnType): ZodFunction<Args, NewReturnType>;
+  implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
+  strictImplement(func: InnerTypeOfFunction<Args, Returns>): InnerTypeOfFunction<Args, Returns>;
+  validate: <F extends InnerTypeOfFunction<Args, Returns>>(func: F) => ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
+  static create(): ZodFunction<ZodTuple<[], ZodUnknown>, ZodUnknown>;
+  static create<T extends AnyZodTuple = ZodTuple<[], ZodUnknown>>(args: T): ZodFunction<T, ZodUnknown>;
+  static create<T extends AnyZodTuple, U extends ZodTypeAny>(args: T, returns: U): ZodFunction<T, U>;
+  static create<T extends AnyZodTuple = ZodTuple<[], ZodUnknown>, U extends ZodTypeAny = ZodUnknown>(args: T, returns: U, params?: RawCreateParams): ZodFunction<T, U>;
+}
+interface ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  getter: () => T;
+  typeName: ZodFirstPartyTypeKind.ZodLazy;
+}
+declare class ZodLazy<T extends ZodTypeAny> extends ZodType<output<T>, ZodLazyDef<T>, input<T>> {
+  get schema(): T;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
+}
+interface ZodLiteralDef<T = any> extends ZodTypeDef {
+  value: T;
+  typeName: ZodFirstPartyTypeKind.ZodLiteral;
+}
+declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get value(): T;
+  static create: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
+}
+type ArrayKeys = keyof any[];
+type Indices<T> = Exclude<keyof T, ArrayKeys>;
+type EnumValues<T extends string = string> = readonly [T, ...T[]];
+type Values<T extends EnumValues> = { [k in T[number]]: k; };
+interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
+  values: T;
+  typeName: ZodFirstPartyTypeKind.ZodEnum;
+}
+type Writeable<T> = { -readonly [P in keyof T]: T[P]; };
+type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
+type typecast<A, T> = A extends T ? A : never;
+declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
+declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;
+declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {
+  _cache: Set<T[number]> | undefined;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get options(): T;
+  get enum(): Values<T>;
+  get Values(): Values<T>;
+  get Enum(): Values<T>;
+  extract<ToExtract extends readonly [T[number], ...T[number][]]>(values: ToExtract, newDef?: RawCreateParams): ZodEnum<Writeable<ToExtract>>;
+  exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude, newDef?: RawCreateParams): ZodEnum<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>>;
+  static create: typeof createZodEnum;
+}
+interface ZodNativeEnumDef<T extends EnumLike = EnumLike> extends ZodTypeDef {
+  values: T;
+  typeName: ZodFirstPartyTypeKind.ZodNativeEnum;
+}
+type EnumLike = {
+  [k: string]: string | number;
+  [nu: number]: string;
+};
+declare class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T], ZodNativeEnumDef<T>, T[keyof T]> {
+  _cache: Set<T[keyof T]> | undefined;
+  _parse(input: ParseInput): ParseReturnType<T[keyof T]>;
+  get enum(): T;
+  static create: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
+}
+interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  type: T;
+  typeName: ZodFirstPartyTypeKind.ZodPromise;
+}
+declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
+  unwrap(): T;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
+}
+type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
+type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;
+type RefinementEffect<T> = {
+  type: "refinement";
+  refinement: (arg: T, ctx: RefinementCtx) => any;
+};
+type TransformEffect<T> = {
+  type: "transform";
+  transform: (arg: T, ctx: RefinementCtx) => any;
+};
+type PreprocessEffect<T> = {
+  type: "preprocess";
+  transform: (arg: T, ctx: RefinementCtx) => any;
+};
+type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
+interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  schema: T;
+  typeName: ZodFirstPartyTypeKind.ZodEffects;
+  effect: Effect<any>;
+}
+declare class ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> extends ZodType<Output, ZodEffectsDef<T>, Input> {
+  innerType(): T;
+  sourceType(): T;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
+  static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
+}
+interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  typeName: ZodFirstPartyTypeKind.ZodOptional;
+}
+type ZodOptionalType<T extends ZodTypeAny> = ZodOptional<T>;
+declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  unwrap(): T;
+  static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
+}
+interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  typeName: ZodFirstPartyTypeKind.ZodNullable;
+}
+type ZodNullableType<T extends ZodTypeAny> = ZodNullable<T>;
+declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  unwrap(): T;
+  static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
+}
+interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  defaultValue: () => util.noUndefined<T["_input"]>;
+  typeName: ZodFirstPartyTypeKind.ZodDefault;
+}
+declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  removeDefault(): T;
+  static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+    default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
+  }) => ZodDefault<Inner>;
+}
+interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  catchValue: (ctx: {
+    error: ZodError;
+    input: unknown;
+  }) => T["_input"];
+  typeName: ZodFirstPartyTypeKind.ZodCatch;
+}
+declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  removeCatch(): T;
+  static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+    catch: Inner["_output"] | (() => Inner["_output"]);
+  }) => ZodCatch<Inner>;
+}
+interface ZodNaNDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodNaN;
+}
+declare class ZodNaN extends ZodType<number, ZodNaNDef, number> {
+  _parse(input: ParseInput): ParseReturnType<any>;
+  static create: (params?: RawCreateParams) => ZodNaN;
+}
+interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
+  type: T;
+  typeName: ZodFirstPartyTypeKind.ZodBranded;
+}
+declare const BRAND: unique symbol;
+type BRAND<T extends string | number | symbol> = {
+  [BRAND]: { [k in T]: true; };
+};
+declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<any>;
+  unwrap(): T;
+}
+interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodTypeDef {
+  in: A;
+  out: B;
+  typeName: ZodFirstPartyTypeKind.ZodPipeline;
+}
+declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<any>;
+  static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;
+}
+type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+  readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  typeName: ZodFirstPartyTypeKind.ZodReadonly;
+}
+declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;
+  unwrap(): T;
+}
+type CustomParams = CustomErrorParams & {
+  fatal?: boolean;
+};
+declare function custom<T>(check?: (data: any) => any, _params?: string | CustomParams | ((input: any) => CustomParams),
+/**
+ * @deprecated
+ *
+ * Pass `fatal` into the params object instead:
+ *
+ * ```ts
+ * z.string().custom((val) => val.length > 5, { fatal: false })
+ * ```
+ *
+ */
+fatal?: boolean): ZodType<T, ZodTypeDef, T>;
+declare const late: {
+  object: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
+};
+declare enum ZodFirstPartyTypeKind {
+  ZodString = "ZodString",
+  ZodNumber = "ZodNumber",
+  ZodNaN = "ZodNaN",
+  ZodBigInt = "ZodBigInt",
+  ZodBoolean = "ZodBoolean",
+  ZodDate = "ZodDate",
+  ZodSymbol = "ZodSymbol",
+  ZodUndefined = "ZodUndefined",
+  ZodNull = "ZodNull",
+  ZodAny = "ZodAny",
+  ZodUnknown = "ZodUnknown",
+  ZodNever = "ZodNever",
+  ZodVoid = "ZodVoid",
+  ZodArray = "ZodArray",
+  ZodObject = "ZodObject",
+  ZodUnion = "ZodUnion",
+  ZodDiscriminatedUnion = "ZodDiscriminatedUnion",
+  ZodIntersection = "ZodIntersection",
+  ZodTuple = "ZodTuple",
+  ZodRecord = "ZodRecord",
+  ZodMap = "ZodMap",
+  ZodSet = "ZodSet",
+  ZodFunction = "ZodFunction",
+  ZodLazy = "ZodLazy",
+  ZodLiteral = "ZodLiteral",
+  ZodEnum = "ZodEnum",
+  ZodEffects = "ZodEffects",
+  ZodNativeEnum = "ZodNativeEnum",
+  ZodOptional = "ZodOptional",
+  ZodNullable = "ZodNullable",
+  ZodDefault = "ZodDefault",
+  ZodCatch = "ZodCatch",
+  ZodPromise = "ZodPromise",
+  ZodBranded = "ZodBranded",
+  ZodPipeline = "ZodPipeline",
+  ZodReadonly = "ZodReadonly"
+}
+type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any> | ZodUnion<any> | ZodDiscriminatedUnion<any, any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodCatch<any> | ZodPromise<any> | ZodBranded<any, any> | ZodPipeline<any, any> | ZodReadonly<any> | ZodSymbol;
+declare abstract class Class {
+  constructor(..._: any[]);
+}
+declare const instanceOfType: <T extends typeof Class>(cls: T, params?: CustomParams) => ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>;
+declare const stringType: (params?: RawCreateParams & {
+  coerce?: true;
+}) => ZodString;
+declare const numberType: (params?: RawCreateParams & {
+  coerce?: boolean;
+}) => ZodNumber;
+declare const nanType: (params?: RawCreateParams) => ZodNaN;
+declare const bigIntType: (params?: RawCreateParams & {
+  coerce?: boolean;
+}) => ZodBigInt;
+declare const booleanType: (params?: RawCreateParams & {
+  coerce?: boolean;
+}) => ZodBoolean;
+declare const dateType: (params?: RawCreateParams & {
+  coerce?: boolean;
+}) => ZodDate;
+declare const symbolType: (params?: RawCreateParams) => ZodSymbol;
+declare const undefinedType: (params?: RawCreateParams) => ZodUndefined;
+declare const nullType: (params?: RawCreateParams) => ZodNull;
+declare const anyType: (params?: RawCreateParams) => ZodAny;
+declare const unknownType: (params?: RawCreateParams) => ZodUnknown;
+declare const neverType: (params?: RawCreateParams) => ZodNever;
+declare const voidType: (params?: RawCreateParams) => ZodVoid;
+declare const arrayType: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
+declare const objectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
+declare const strictObjectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
+declare const unionType: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
+declare const discriminatedUnionType: typeof ZodDiscriminatedUnion.create;
+declare const intersectionType: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
+declare const tupleType: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
+declare const recordType: typeof ZodRecord.create;
+declare const mapType: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
+declare const setType: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
+declare const functionType: typeof ZodFunction.create;
+declare const lazyType: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
+declare const literalType: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
+declare const enumType: typeof createZodEnum;
+declare const nativeEnumType: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
+declare const promiseType: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
+declare const effectsType: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
+declare const optionalType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
+declare const nullableType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
+declare const preprocessType: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
+declare const pipelineType: typeof ZodPipeline.create;
+declare const ostring: () => ZodOptional<ZodString>;
+declare const onumber: () => ZodOptional<ZodNumber>;
+declare const oboolean: () => ZodOptional<ZodBoolean>;
+declare const coerce: {
+  string: (typeof ZodString)["create"];
+  number: (typeof ZodNumber)["create"];
+  boolean: (typeof ZodBoolean)["create"];
+  bigint: (typeof ZodBigInt)["create"];
+  date: (typeof ZodDate)["create"];
+};
+declare const NEVER: never;
+//#endregion
+export { ZodCatch as $, objectInputType as $n, ZodInvalidIntersectionTypesIssue as $r, ZodRecordDef as $t, RefinementCtx as A, UseRhfUtilsFormOnSubmitErrorContext as Ai, custom as An, ParsePath as Ar, ZodNeverDef as At, Values as B, intersectionType as Bn, isValid as Br, ZodObject as Bt, OutputTypeOfTupleWithRest as C, Primitive as Ci, arrayOutputType as Cn, EMPTY_PATH as Cr, ZodMap as Ct, RawCreateParams as D, _Controller as Di, bigIntType as Dn, ParseContext as Dr, ZodNativeEnum as Dt, ProcessedCreateParams as E, RhfUtilsClientConfigFormOutletProps as Ei, baseObjectOutputType as En, ObjectPair as Er, ZodNaNDef as Et, SomeZodObject as F, FormSubmitFieldErrors as Fi, effectsType as Fn, SyncParseReturnType as Fr, ZodNullableDef as Ft, ZodArrayDef as G, mergeTypes as Gn, StringValidation as Gr, ZodPipeline as Gt, ZodAny as H, lazyType as Hn, DenormalizedError as Hr, ZodOptional as Ht, SuperRefinement as I, RhfUseFormInstanceProps as Ii, enumType as In, addIssueToContext as Ir, ZodNullableType as It, ZodBigIntDef as J, neverType as Jn, ZodErrorMap as Jr, ZodPromiseDef as Jt, ZodBigInt as K, nanType as Kn, ZodCustomIssue as Kr, ZodPipelineDef as Kt, TransformEffect as L, useFlatFieldErrorsContext as Li, functionType as Ln, isAborted as Lr, ZodNumber as Lt, SafeParseError as M, LastSubmitStatus as Mi, datetimeRegex as Mn, ParseResult as Mr, ZodNull as Mt, SafeParseReturnType as N, LastSubmitError as Ni, deoptional as Nn, ParseReturnType as Nr, ZodNullDef as Nt, RecordType as O, MaybePromise as Oi, booleanType as On, ParseInput as Or, ZodNativeEnumDef as Ot, SafeParseSuccess as P, FormSubmitError as Pi, discriminatedUnionType as Pn, ParseStatus as Pr, ZodNullable as Pt, ZodBrandedDef as Q, numberType as Qn, ZodInvalidEnumValueIssue as Qr, ZodRecord as Qt, TypeOf as R, input as Rn, isAsync as Rr, ZodNumberCheck as Rt, OutputTypeOfTuple as S, util as Si, anyType as Sn, DIRTY as Sr, ZodLiteralDef as St, PreprocessEffect as T, RhfUtilsClientConfig as Ti, baseObjectInputType as Tn, OK as Tr, ZodNaN as Tt, ZodAnyDef as U, literalType as Un, ErrorMapCtx as Ur, ZodOptionalDef as Ut, Writeable as V, late as Vn, makeIssue as Vr, ZodObjectDef as Vt, ZodArray as W, mapType as Wn, IssueData as Wr, ZodOptionalType as Wt, ZodBooleanDef as X, nullType as Xn, ZodInvalidArgumentsIssue as Xr, ZodReadonly as Xt, ZodBoolean as Y, noUnrecognized as Yn, ZodFormattedError as Yr, ZodRawShape as Yt, ZodBranded as Z, nullableType as Zn, ZodInvalidDateIssue as Zr, ZodReadonlyDef as Zt, InputTypeOfTupleWithRest as _, quotelessJson as _i, ZodUnionOptions as _n, undefinedType as _r, ZodIntersection as _t, AssertArray as a, ZodInvalidUnionIssue as ai, ZodSymbol as an, ostring as ar, ZodDefaultDef as at, NEVER as b, getParsedType as bi, ZodVoid as bn, voidType as br, ZodLazyDef as bt, CatchallOutput as c, ZodIssueCode as ci, ZodTupleDef as cn, preprocessType as cr, ZodDiscriminatedUnionOption as ct, EnumLike as d, ZodNotMultipleOfIssue as di, ZodTypeAny as dn, setType as dr, ZodEnum as dt, ZodInvalidLiteralIssue as ei, ZodSet as en, objectOutputType as er, ZodCatchDef as et, EnumValues as f, ZodTooBigIssue as fi, ZodTypeDef as fn, strictObjectType as fr, ZodEnumDef as ft, InputTypeOfTuple as g, inferFormattedError as gi, ZodUnionDef as gn, typecast as gr, ZodFunctionDef as gt, InnerTypeOfFunction as h, inferFlattenedErrors as hi, ZodUnion as hn, tupleType as hr, ZodFunction as ht, ArrayKeys as i, ZodInvalidUnionDiscriminatorIssue as ii, ZodStringDef as in, optionalType as ir, ZodDefault as it, RefinementEffect as j, LastSubmitContextRead as ji, dateType as jn, ParsePathComponent as jr, ZodNonEmptyArray as jt, Refinement as k, UseRhfUtilsFormOnSubmitContext as ki, coerce as kn, ParseParams as kr, ZodNever as kt, CustomErrorParams as l, ZodIssueOptionalMessage as li, ZodTupleItems as ln, promiseType as lr, ZodEffects as lt, Indices as m, ZodUnrecognizedKeysIssue as mi, ZodUndefinedDef as mn, symbolType as mr, ZodFirstPartyTypeKind as mt, AnyZodTuple as n, ZodInvalidStringIssue as ni, ZodString as nn, oboolean as nr, ZodDateCheck as nt, BRAND as o, ZodIssue as oi, ZodSymbolDef as on, output as or, ZodDiscriminatedUnion as ot, FilterEnum as p, ZodTooSmallIssue as pi, ZodUndefined as pn, stringType as pr, ZodFirstPartySchemaTypes as pt, ZodBigIntCheck as q, nativeEnumType as qn, ZodError as qr, ZodPromise as qt, ArrayCardinality as r, ZodInvalidTypeIssue as ri, ZodStringCheck as rn, onumber as rr, ZodDateDef as rt, CatchallInput as s, ZodIssueBase as si, ZodTuple as sn, pipelineType as sr, ZodDiscriminatedUnionDef as st, AnyZodObject as t, ZodInvalidReturnTypeIssue as ti, ZodSetDef as tn, objectType as tr, ZodDate as tt, Effect as u, ZodNotFiniteIssue as ui, ZodType as un, recordType as ur, ZodEffectsDef as ut, IpVersion as v, typeToFlattenedError as vi, ZodUnknown as vn, unionType as vr, ZodIntersectionDef as vt, PassthroughType as w, Scalars as wi, arrayType as wn, INVALID as wr, ZodMapDef as wt, OuterTypeOfFunction as x, objectUtil as xi, ZodVoidDef as xn, AsyncParseReturnType as xr, ZodLiteral as xt, KeySchema as y, ZodParsedType as yi, ZodUnknownDef as yn, unknownType as yr, ZodLazy as yt, UnknownKeysParam as z, instanceOfType as zn, isDirty as zr, ZodNumberDef as zt };
+//# sourceMappingURL=types-DGFncyYT.d.ts.map