diff --git a/packages/jdm-editor/package.json b/packages/jdm-editor/package.json
index e0e552a4..0816cb1d 100644
--- a/packages/jdm-editor/package.json
+++ b/packages/jdm-editor/package.json
@@ -46,7 +46,7 @@
     "fast-deep-equal": "^3.1.3",
     "immer": "10.1.1",
     "json5": "^2.2.3",
-    "monaco-editor": "^0.48.0",
+    "monaco-editor": "^0.50.0",
     "react-ace": "^11.0.1",
     "react-dnd": "^16.0.1",
     "react-dnd-html5-backend": "16.0.1",
diff --git a/packages/jdm-editor/src/components/decision-graph/context/dg-store.context.tsx b/packages/jdm-editor/src/components/decision-graph/context/dg-store.context.tsx
index 87bc6ecb..606d2b32 100644
--- a/packages/jdm-editor/src/components/decision-graph/context/dg-store.context.tsx
+++ b/packages/jdm-editor/src/components/decision-graph/context/dg-store.context.tsx
@@ -1,3 +1,4 @@
+import type { Monaco } from '@monaco-editor/react';
 import equal from 'fast-deep-equal/es6/react';
 import { produce } from 'immer';
 import type { WritableDraft } from 'immer/src/types/types-external';
@@ -109,6 +110,7 @@ export type DecisionGraphStoreType = {
     onPanelsChange?: (val?: string) => void;
     onReactFlowInit?: (instance: ReactFlowInstance) => void;
     onCodeExtension?: CodeEditorProps['extension'];
+    onFunctionReady?: (monaco: Monaco) => void;
   };
 };
 
diff --git a/packages/jdm-editor/src/components/decision-graph/dg-empty.tsx b/packages/jdm-editor/src/components/decision-graph/dg-empty.tsx
index 2cb8e381..884c5eb7 100644
--- a/packages/jdm-editor/src/components/decision-graph/dg-empty.tsx
+++ b/packages/jdm-editor/src/components/decision-graph/dg-empty.tsx
@@ -32,6 +32,7 @@ export type DecisionGraphEmptyType = {
   onReactFlowInit?: DecisionGraphStoreType['listeners']['onReactFlowInit'];
 
   onCodeExtension?: DecisionGraphStoreType['listeners']['onCodeExtension'];
+  onFunctionReady?: DecisionGraphStoreType['listeners']['onFunctionReady'];
 };
 
 export const DecisionGraphEmpty: React.FC<DecisionGraphEmptyType> = ({
@@ -49,6 +50,7 @@ export const DecisionGraphEmpty: React.FC<DecisionGraphEmptyType> = ({
   onPanelsChange,
   onReactFlowInit,
   onCodeExtension,
+  onFunctionReady,
 }) => {
   const mountedRef = useRef(false);
   const graphActions = useDecisionGraphActions();
@@ -83,8 +85,9 @@ export const DecisionGraphEmpty: React.FC<DecisionGraphEmptyType> = ({
       onReactFlowInit,
       onPanelsChange,
       onCodeExtension,
+      onFunctionReady,
     });
-  }, [onReactFlowInit, onPanelsChange, onCodeExtension]);
+  }, [onReactFlowInit, onPanelsChange, onCodeExtension, onFunctionReady]);
 
   useEffect(() => {
     listenerStore.setState({ onChange: innerChange });
diff --git a/packages/jdm-editor/src/components/decision-graph/graph/tab-function.tsx b/packages/jdm-editor/src/components/decision-graph/graph/tab-function.tsx
index aa920c7c..9963f36a 100644
--- a/packages/jdm-editor/src/components/decision-graph/graph/tab-function.tsx
+++ b/packages/jdm-editor/src/components/decision-graph/graph/tab-function.tsx
@@ -1,8 +1,9 @@
+import type { Monaco } from '@monaco-editor/react';
 import { Spin } from 'antd';
-import React, { Suspense } from 'react';
+import React, { Suspense, useEffect, useState } from 'react';
 import { P, match } from 'ts-pattern';
 
-import { useDecisionGraphActions, useDecisionGraphState } from '../context/dg-store.context';
+import { useDecisionGraphActions, useDecisionGraphListeners, useDecisionGraphState } from '../context/dg-store.context';
 import type { SimulationTrace, SimulationTraceDataFunction } from '../types/simulation.types';
 
 const Function = React.lazy(async () => {
@@ -16,7 +17,9 @@ export type TabFunctionProps = {
 
 export const TabFunction: React.FC<TabFunctionProps> = ({ id }) => {
   const graphActions = useDecisionGraphActions();
-  const { nodeTrace, disabled, content } = useDecisionGraphState(
+  const onFunctionReady = useDecisionGraphListeners((s) => s.onFunctionReady);
+  const [monaco, setMonaco] = useState<Monaco>();
+  const { nodeTrace, disabled, content, additionalModules } = useDecisionGraphState(
     ({ simulate, disabled, configurable, decisionGraph }) => ({
       nodeTrace: match(simulate)
         .with({ result: P._ }, ({ result }) => result?.trace?.[id])
@@ -24,12 +27,44 @@ export const TabFunction: React.FC<TabFunctionProps> = ({ id }) => {
       disabled,
       configurable,
       content: (decisionGraph?.nodes ?? []).find((node) => node.id === id)?.content,
+      additionalModules: (decisionGraph?.nodes ?? [])
+        .filter((node) => node.type === 'functionNode')
+        .map((node) => ({
+          id: node.id,
+          name: node.name,
+          content: node.content,
+        })),
     }),
   );
 
+  useEffect(() => {
+    if (!monaco) {
+      return;
+    }
+
+    const extraLibs = monaco.languages.typescript.javascriptDefaults.getExtraLibs();
+    const newExtraLibs = Object.entries(extraLibs)
+      .map(([key, value]) => ({
+        filePath: key,
+        content: value.content,
+      }))
+      .filter((i) => !i.filePath.startsWith('node:'));
+
+    additionalModules.forEach((module) => {
+      newExtraLibs.push({
+        filePath: `node:${module.name}`,
+        content: `declare module 'node:${module.name}' { ${module.content} }`,
+      });
+    });
+
+    monaco.languages.typescript.javascriptDefaults.setExtraLibs(newExtraLibs);
+    onFunctionReady?.(monaco);
+  }, [JSON.stringify(additionalModules), monaco, onFunctionReady]);
+
   return (
     <Suspense fallback={<Spin />}>
       <Function
+        onMonacoReady={(monaco) => setMonaco(monaco)}
         value={typeof content === 'string' ? content : ''}
         onChange={(val) => {
           graphActions.updateNode(id, (draft) => {
diff --git a/packages/jdm-editor/src/components/function/function.tsx b/packages/jdm-editor/src/components/function/function.tsx
index b6d1ff94..7e9887d7 100644
--- a/packages/jdm-editor/src/components/function/function.tsx
+++ b/packages/jdm-editor/src/components/function/function.tsx
@@ -1,5 +1,5 @@
 import { FormatPainterOutlined } from '@ant-design/icons';
-import { Editor, useMonaco } from '@monaco-editor/react';
+import { Editor, type Monaco, useMonaco } from '@monaco-editor/react';
 import { Button, Spin, theme } from 'antd';
 import type { editor } from 'monaco-editor';
 import React, { useEffect, useRef, useState } from 'react';
@@ -20,6 +20,7 @@ export type FunctionProps = {
   value?: string;
   onChange?: (value: string) => void;
   trace?: SimulationTrace<SimulationTraceDataFunction>;
+  onMonacoReady?: (monaco: Monaco) => void;
 };
 
 export const Function: React.FC<FunctionProps> = ({
@@ -30,6 +31,7 @@ export const Function: React.FC<FunctionProps> = ({
   value,
   onChange,
   trace,
+  onMonacoReady,
 }) => {
   const monaco = useMonaco();
   const mountedRef = useRef(false);
@@ -51,14 +53,32 @@ export const Function: React.FC<FunctionProps> = ({
   useEffect(() => {
     if (!monaco) return;
 
-    const extraLibs = Object.keys(functionDefinitions).map(
-      (pkg: keyof typeof functionDefinitions) => ({
-        content: `declare module '${pkg}' { ${functionDefinitions[pkg]} }`,
-      }),
-      {},
-    );
+    monaco.languages.typescript.javascriptDefaults.setCompilerOptions({
+      target: monaco.languages.typescript.ScriptTarget.ES2020,
+      module: monaco.languages.typescript.ModuleKind.ESNext,
+      moduleResolution: monaco.languages.typescript.ModuleResolutionKind.NodeJs,
+      allowSyntheticDefaultImports: true,
+      allowNonTsExtensions: true,
+      allowJs: true,
+      checkJs: true,
+    });
 
-    monaco.languages.typescript.javascriptDefaults.setExtraLibs(extraLibs);
+    monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions({
+      noSyntaxValidation: false,
+      noSemanticValidation: false,
+      noSuggestionDiagnostics: false,
+      onlyVisible: false,
+    });
+
+    Object.entries(functionDefinitions.libs).forEach(([pkg, types]) => {
+      monaco.languages.typescript.javascriptDefaults.addExtraLib(`declare module '${pkg}' { ${types} }`, pkg);
+    });
+
+    Object.entries(functionDefinitions.globals).forEach(([pkg, types]) => {
+      monaco.languages.typescript.javascriptDefaults.addExtraLib(types, `ts:${pkg}`);
+    });
+
+    onMonacoReady?.(monaco);
   }, [monaco]);
 
   useEffect(() => {
diff --git a/packages/jdm-editor/src/components/function/helpers/default-function.js b/packages/jdm-editor/src/components/function/helpers/default-function.js
index cad7d9f1..4eea9882 100644
--- a/packages/jdm-editor/src/components/function/helpers/default-function.js
+++ b/packages/jdm-editor/src/components/function/helpers/default-function.js
@@ -1,10 +1,7 @@
-/**
- * @param input
- * @param {{
- *  dayjs: import('dayjs')
- *  Big: import('big.js').BigConstructor
- * }} helpers
- */
-const handler = (input, { dayjs, Big }) => {
+import http from 'http';
+import zen from 'zen';
+
+export const handler = async (input) => {
+  const a = zen.evaluate();
   return input;
 };
diff --git a/packages/jdm-editor/src/components/function/helpers/global.d.ts b/packages/jdm-editor/src/components/function/helpers/global.d.ts
new file mode 100644
index 00000000..8205af24
--- /dev/null
+++ b/packages/jdm-editor/src/components/function/helpers/global.d.ts
@@ -0,0 +1,11 @@
+declare namespace console {
+  function log(...args: any[]): void;
+}
+
+interface Config {
+  readonly maxDepth: number;
+  readonly iteration: number;
+  readonly trace: boolean;
+}
+
+declare const config: Config;
diff --git a/packages/jdm-editor/src/components/function/helpers/http.d.ts b/packages/jdm-editor/src/components/function/helpers/http.d.ts
new file mode 100644
index 00000000..b93bda81
--- /dev/null
+++ b/packages/jdm-editor/src/components/function/helpers/http.d.ts
@@ -0,0 +1,28 @@
+declare class HttpResponse {
+  readonly data: any;
+  readonly headers: Record<string, string>;
+  readonly status: number;
+}
+
+interface HttpConfig {
+  headers: Record<string, string>;
+  params: Record<string, string>;
+  data: any;
+}
+
+export class Http {
+  head(url: string, config?: HttpConfig): Promise<HttpResponse>;
+
+  get(url: string, config?: HttpConfig): Promise<HttpResponse>;
+
+  delete(url: string, config?: HttpConfig): Promise<HttpResponse>;
+
+  post(url: string, data: any, config?: HttpConfig): Promise<HttpResponse>;
+
+  patch(url: string, data: any, config?: HttpConfig): Promise<HttpResponse>;
+
+  put(url: string, data: any, config?: HttpConfig): Promise<HttpResponse>;
+}
+
+declare const http: Http;
+export default http;
diff --git a/packages/jdm-editor/src/components/function/helpers/libs.ts b/packages/jdm-editor/src/components/function/helpers/libs.ts
index 8a752c39..56e8086e 100644
--- a/packages/jdm-editor/src/components/function/helpers/libs.ts
+++ b/packages/jdm-editor/src/components/function/helpers/libs.ts
@@ -6,10 +6,26 @@ import dayjs from 'dayjs/index.d.ts?raw';
 
 // @ts-ignore
 import defaultFn from './default-function.js?raw';
+// @ts-ignore
+import globalDts from './global.d.ts?raw';
+// @ts-ignore
+import http from './http.d.ts?raw';
+// @ts-ignore
+import zen from './zen.d.ts?raw';
+// @ts-ignore
+import zod from './zod.d.ts?raw';
 
 export const functionDefinitions = {
-  dayjs,
-  'big.js': bigJs,
+  libs: {
+    dayjs,
+    'big.js': bigJs,
+    zod,
+    http,
+    zen,
+  },
+  globals: {
+    'global.d.ts': globalDts,
+  },
 };
 
 export const defaultFunctionValue = defaultFn;
diff --git a/packages/jdm-editor/src/components/function/helpers/zen.d.ts b/packages/jdm-editor/src/components/function/helpers/zen.d.ts
new file mode 100644
index 00000000..bd22ecb5
--- /dev/null
+++ b/packages/jdm-editor/src/components/function/helpers/zen.d.ts
@@ -0,0 +1,48 @@
+interface EvaluateOptions {
+  trace?: boolean;
+}
+
+interface EvaluateResponse {
+  performance: string;
+  result: any;
+  trace?: any;
+}
+
+interface ZenModule {
+  /**
+   * Evaluates ZEN expression
+   * @param expression
+   * @param context Must contain '$' key
+   */
+  evaluateExpression(expression: string, context: any): any;
+
+  /**
+   * Evaluates ZEN unary expression
+   * @param expression
+   * @param context Must contain '$' key
+   */
+  evaluateUnaryExpression(expression: string, context: any): boolean;
+
+  /**
+   * Evaluates ZEN unary expression
+   * @param file File to be evaluated via DecisionLoader
+   * @param context
+   * @param opts
+   */
+  evaluate(file: string, context: any, opts?: EvaluateOptions): Promise<EvaluateResponse>;
+
+  /**
+   * Get Content from the DecisionLoader
+   * @param file
+   */
+  get(file: string): Promise<any>;
+}
+
+export const evaluateExpression: ZenModule['evaluateExpression'];
+export const evaluateUnaryExpression: ZenModule['evaluateUnaryExpression'];
+export const evaluate: ZenModule['evaluate'];
+export const get: ZenModule['get'];
+
+declare const zenModule: ZenModule;
+
+export default zenModule;
diff --git a/packages/jdm-editor/src/components/function/helpers/zod.d.ts b/packages/jdm-editor/src/components/function/helpers/zod.d.ts
new file mode 100644
index 00000000..02616fdb
--- /dev/null
+++ b/packages/jdm-editor/src/components/function/helpers/zod.d.ts
@@ -0,0 +1,2895 @@
+declare type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+declare type Scalars = Primitive | Primitive[];
+
+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>(val: AssertEqual<A, B>) => AssertEqual<A, B>;
+  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 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> = {
+    [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> = {
+    [K in keyof A as K extends keyof B ? never : K]: A[K];
+  } & {
+    [K in keyof B]: B[K];
+  };
+  export {};
+}
+declare const ZodParsedType: {
+  function: 'function';
+  number: 'number';
+  string: 'string';
+  nan: 'nan';
+  integer: 'integer';
+  float: 'float';
+  boolean: 'boolean';
+  date: 'date';
+  bigint: 'bigint';
+  symbol: 'symbol';
+  undefined: 'undefined';
+  null: 'null';
+  array: 'array';
+  object: 'object';
+  unknown: 'unknown';
+  promise: 'promise';
+  void: 'void';
+  never: 'never';
+  map: 'map';
+  set: 'set';
+};
+declare type ZodParsedType = keyof typeof ZodParsedType;
+declare const getParsedType: (data: any) => ZodParsedType;
+
+declare type allKeys<T> = T extends any ? keyof T : never;
+declare type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
+declare 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';
+};
+declare type ZodIssueCode = keyof typeof ZodIssueCode;
+declare type ZodIssueBase = {
+  path: (string | number)[];
+  message?: string;
+};
+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;
+}
+declare type StringValidation =
+  | 'email'
+  | 'url'
+  | 'emoji'
+  | 'uuid'
+  | 'nanoid'
+  | 'regex'
+  | 'cuid'
+  | 'cuid2'
+  | 'ulid'
+  | 'datetime'
+  | 'date'
+  | 'time'
+  | 'duration'
+  | 'ip'
+  | 'base64'
+  | {
+      includes: string;
+      position?: number;
+    }
+  | {
+      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;
+  };
+}
+declare type DenormalizedError = {
+  [k: string]: DenormalizedError | string[];
+};
+declare type ZodIssueOptionalMessage =
+  | ZodInvalidTypeIssue
+  | ZodInvalidLiteralIssue
+  | ZodUnrecognizedKeysIssue
+  | ZodInvalidUnionIssue
+  | ZodInvalidUnionDiscriminatorIssue
+  | ZodInvalidEnumValueIssue
+  | ZodInvalidArgumentsIssue
+  | ZodInvalidReturnTypeIssue
+  | ZodInvalidDateIssue
+  | ZodInvalidStringIssue
+  | ZodTooSmallIssue
+  | ZodTooBigIssue
+  | ZodInvalidIntersectionTypesIssue
+  | ZodNotMultipleOfIssue
+  | ZodNotFiniteIssue
+  | ZodCustomIssue;
+declare type ZodIssue = ZodIssueOptionalMessage & {
+  fatal?: boolean;
+  message: string;
+};
+declare const quotelessJson: (obj: any) => string;
+declare 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;
+declare type ZodFormattedError<T, U = string> = {
+  _errors: U[];
+} & recursiveZodFormattedError<NonNullable<T>>;
+declare 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>;
+}
+declare type stripPath<T extends object> = T extends any ? util.OmitKeys<T, 'path'> : never;
+declare type IssueData = stripPath<ZodIssueOptionalMessage> & {
+  path?: (string | number)[];
+  fatal?: boolean;
+};
+declare type ErrorMapCtx = {
+  defaultError: string;
+  data: any;
+};
+declare type ZodErrorMap = (
+  issue: ZodIssueOptionalMessage,
+  _ctx: ErrorMapCtx,
+) => {
+  message: string;
+};
+
+declare const errorMap: ZodErrorMap;
+//# sourceMappingURL=en.d.ts.map
+
+declare function setErrorMap(map: ZodErrorMap): void;
+declare function getErrorMap(): ZodErrorMap;
+
+declare const makeIssue: (params: {
+  data: any;
+  path: (string | number)[];
+  errorMaps: ZodErrorMap[];
+  issueData: IssueData;
+}) => ZodIssue;
+declare type ParseParams = {
+  path: (string | number)[];
+  errorMap: ZodErrorMap;
+  async: boolean;
+};
+declare type ParsePathComponent = string | number;
+declare type ParsePath = ParsePathComponent[];
+declare const EMPTY_PATH: ParsePath;
+interface ParseContext {
+  readonly common: {
+    readonly issues: ZodIssue[];
+    readonly contextualErrorMap?: ZodErrorMap;
+    readonly async: boolean;
+  };
+  readonly path: ParsePath;
+  readonly schemaErrorMap?: ZodErrorMap;
+  readonly parent: ParseContext | null;
+  readonly data: any;
+  readonly parsedType: ZodParsedType;
+}
+declare type ParseInput = {
+  data: any;
+  path: (string | number)[];
+  parent: ParseContext;
+};
+declare function addIssueToContext(ctx: ParseContext, issueData: IssueData): void;
+declare 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;
+}
+declare type INVALID = {
+  status: 'aborted';
+};
+declare const INVALID: INVALID;
+declare type DIRTY<T> = {
+  status: 'dirty';
+  value: T;
+};
+declare const DIRTY: <T>(value: T) => DIRTY<T>;
+declare type OK<T> = {
+  status: 'valid';
+  value: T;
+};
+declare const OK: <T>(value: T) => OK<T>;
+declare type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
+declare type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
+declare 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>;
+
+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 {};
+}
+
+declare namespace errorUtil {
+  type ErrMessage =
+    | string
+    | {
+        message?: string;
+      };
+  const errToObj: (message?: ErrMessage | undefined) => {
+    message?: string | undefined;
+  };
+  const toString: (message?: ErrMessage | undefined) => string | undefined;
+}
+
+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;
+}
+
+interface RefinementCtx {
+  addIssue: (arg: IssueData) => void;
+  path: (string | number)[];
+}
+declare type ZodRawShape = {
+  [k: string]: ZodTypeAny;
+};
+declare type ZodTypeAny = ZodType<any, any, any>;
+declare type TypeOf<T extends ZodType<any, any, any>> = T['_output'];
+declare type input<T extends ZodType<any, any, any>> = T['_input'];
+declare type output<T extends ZodType<any, any, any>> = T['_output'];
+
+declare type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, 'code'>>;
+interface ZodTypeDef {
+  errorMap?: ZodErrorMap;
+  description?: string;
+}
+declare type RawCreateParams =
+  | {
+      errorMap?: ZodErrorMap;
+      invalid_type_error?: string;
+      required_error?: string;
+      message?: string;
+      description?: string;
+    }
+  | undefined;
+declare type ProcessedCreateParams = {
+  errorMap?: ZodErrorMap;
+  description?: string;
+};
+declare type SafeParseSuccess<Output> = {
+  success: true;
+  data: Output;
+  error?: never;
+};
+declare type SafeParseError<Input> = {
+  success: false;
+  error: ZodError<Input>;
+  data?: never;
+};
+declare 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;
+  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?: Partial<ParseParams>): Output;
+  safeParse(data: unknown, params?: Partial<ParseParams>): SafeParseReturnType<Input, Output>;
+  parseAsync(data: unknown, params?: Partial<ParseParams>): Promise<Output>;
+  safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
+  /** Alias of safeParseAsync */
+  spa: (data: unknown, params?: Partial<ParseParams> | undefined) => 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;
+}
+declare type IpVersion = 'v4' | 'v6';
+declare type ZodStringCheck =
+  | {
+      kind: 'min';
+      value: number;
+      message?: string;
+    }
+  | {
+      kind: 'max';
+      value: number;
+      message?: string;
+    }
+  | {
+      kind: 'length';
+      value: number;
+      message?: string;
+    }
+  | {
+      kind: 'email';
+      message?: string;
+    }
+  | {
+      kind: 'url';
+      message?: string;
+    }
+  | {
+      kind: 'emoji';
+      message?: string;
+    }
+  | {
+      kind: 'uuid';
+      message?: string;
+    }
+  | {
+      kind: 'nanoid';
+      message?: string;
+    }
+  | {
+      kind: 'cuid';
+      message?: string;
+    }
+  | {
+      kind: 'includes';
+      value: string;
+      position?: number;
+      message?: string;
+    }
+  | {
+      kind: 'cuid2';
+      message?: string;
+    }
+  | {
+      kind: 'ulid';
+      message?: string;
+    }
+  | {
+      kind: 'startsWith';
+      value: string;
+      message?: string;
+    }
+  | {
+      kind: 'endsWith';
+      value: string;
+      message?: string;
+    }
+  | {
+      kind: 'regex';
+      regex: RegExp;
+      message?: string;
+    }
+  | {
+      kind: 'trim';
+      message?: string;
+    }
+  | {
+      kind: 'toLowerCase';
+      message?: string;
+    }
+  | {
+      kind: 'toUpperCase';
+      message?: string;
+    }
+  | {
+      kind: 'datetime';
+      offset: boolean;
+      local: boolean;
+      precision: number | null;
+      message?: string;
+    }
+  | {
+      kind: 'date';
+      message?: string;
+    }
+  | {
+      kind: 'time';
+      precision: number | null;
+      message?: string;
+    }
+  | {
+      kind: 'duration';
+      message?: string;
+    }
+  | {
+      kind: 'ip';
+      version?: IpVersion;
+      message?: string;
+    }
+  | {
+      kind: 'base64';
+      message?: string;
+    };
+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;
+  ip(
+    options?:
+      | string
+      | {
+          version?: 'v4' | 'v6';
+          message?: string;
+        },
+  ): 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;
+  /**
+   * @deprecated Use z.string().min(1) instead.
+   * @see {@link ZodString.min}
+   */
+  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 isBase64(): boolean;
+  get minLength(): number | null;
+  get maxLength(): number | null;
+  static create: (
+    params?:
+      | ({
+          errorMap?: ZodErrorMap | undefined;
+          invalid_type_error?: string | undefined;
+          required_error?: string | undefined;
+          message?: string | undefined;
+          description?: string | undefined;
+        } & {
+          coerce?: true | undefined;
+        })
+      | undefined,
+  ) => ZodString;
+}
+declare type ZodNumberCheck =
+  | {
+      kind: 'min';
+      value: number;
+      inclusive: boolean;
+      message?: string;
+    }
+  | {
+      kind: 'max';
+      value: number;
+      inclusive: boolean;
+      message?: string;
+    }
+  | {
+      kind: 'int';
+      message?: string;
+    }
+  | {
+      kind: 'multipleOf';
+      value: number;
+      message?: string;
+    }
+  | {
+      kind: 'finite';
+      message?: string;
+    };
+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?:
+      | ({
+          errorMap?: ZodErrorMap | undefined;
+          invalid_type_error?: string | undefined;
+          required_error?: string | undefined;
+          message?: string | undefined;
+          description?: string | undefined;
+        } & {
+          coerce?: boolean | undefined;
+        })
+      | undefined,
+  ) => ZodNumber;
+  gte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  min: (value: number, message?: errorUtil.ErrMessage | undefined) => ZodNumber;
+  gt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  lte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  max: (value: number, message?: errorUtil.ErrMessage | undefined) => 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 | undefined) => 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;
+}
+declare type ZodBigIntCheck =
+  | {
+      kind: 'min';
+      value: bigint;
+      inclusive: boolean;
+      message?: string;
+    }
+  | {
+      kind: 'max';
+      value: bigint;
+      inclusive: boolean;
+      message?: string;
+    }
+  | {
+      kind: 'multipleOf';
+      value: bigint;
+      message?: string;
+    };
+interface ZodBigIntDef extends ZodTypeDef {
+  checks: ZodBigIntCheck[];
+  typeName: ZodFirstPartyTypeKind.ZodBigInt;
+  coerce: boolean;
+}
+declare class ZodBigInt extends ZodType<bigint, ZodBigIntDef, bigint> {
+  _parse(input: ParseInput): ParseReturnType<bigint>;
+  static create: (
+    params?:
+      | ({
+          errorMap?: ZodErrorMap | undefined;
+          invalid_type_error?: string | undefined;
+          required_error?: string | undefined;
+          message?: string | undefined;
+          description?: string | undefined;
+        } & {
+          coerce?: boolean | undefined;
+        })
+      | undefined,
+  ) => ZodBigInt;
+  gte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  min: (value: bigint, message?: errorUtil.ErrMessage | undefined) => ZodBigInt;
+  gt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  lte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  max: (value: bigint, message?: errorUtil.ErrMessage | undefined) => 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?:
+      | ({
+          errorMap?: ZodErrorMap | undefined;
+          invalid_type_error?: string | undefined;
+          required_error?: string | undefined;
+          message?: string | undefined;
+          description?: string | undefined;
+        } & {
+          coerce?: boolean | undefined;
+        })
+      | undefined,
+  ) => ZodBoolean;
+}
+declare type ZodDateCheck =
+  | {
+      kind: 'min';
+      value: number;
+      message?: string;
+    }
+  | {
+      kind: 'max';
+      value: number;
+      message?: string;
+    };
+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?:
+      | ({
+          errorMap?: ZodErrorMap | undefined;
+          invalid_type_error?: string | undefined;
+          required_error?: string | undefined;
+          message?: string | undefined;
+          description?: string | undefined;
+        } & {
+          coerce?: boolean | undefined;
+        })
+      | undefined,
+  ) => 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;
+  } | null;
+  minLength: {
+    value: number;
+    message?: string;
+  } | null;
+  maxLength: {
+    value: number;
+    message?: string;
+  } | null;
+}
+declare type ArrayCardinality = 'many' | 'atleastone';
+declare 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: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodArray<T_1, 'many'>;
+}
+declare type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, 'atleastone'>;
+declare 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;
+}
+declare type mergeTypes<A, B> = {
+  [k in keyof A | keyof B]: k extends keyof B ? B[k] : k extends keyof A ? A[k] : never;
+};
+declare type objectOutputType<
+  Shape extends ZodRawShape,
+  Catchall extends ZodTypeAny,
+  UnknownKeys extends UnknownKeysParam = UnknownKeysParam,
+> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> &
+  CatchallOutput<Catchall> &
+  PassthroughType<UnknownKeys>;
+declare type baseObjectOutputType<Shape extends ZodRawShape> = {
+  [k in keyof Shape]: Shape[k]['_output'];
+};
+declare type objectInputType<
+  Shape extends ZodRawShape,
+  Catchall extends ZodTypeAny,
+  UnknownKeys extends UnknownKeysParam = UnknownKeysParam,
+> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
+declare type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{
+  [k in keyof Shape]: Shape[k]['_input'];
+}>;
+declare type CatchallOutput<T extends ZodType> = ZodType extends T
+  ? unknown
+  : {
+      [k: string]: T['_output'];
+    };
+declare type CatchallInput<T extends ZodType> = ZodType extends T
+  ? unknown
+  : {
+      [k: string]: T['_input'];
+    };
+declare type PassthroughType<T extends UnknownKeysParam> = T extends 'passthrough'
+  ? {
+      [k: string]: unknown;
+    }
+  : unknown;
+declare type deoptional<T extends ZodTypeAny> =
+  T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
+declare type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+declare 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,
+    objectOutputType<objectUtil.extendShape<T, Augmentation>, Catchall, UnknownKeys>,
+    objectInputType<objectUtil.extendShape<T, Augmentation>, Catchall, UnknownKeys>
+  >;
+  /**
+   * 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: <T_1 extends ZodRawShape>(
+    shape: T_1,
+    params?: RawCreateParams,
+  ) => ZodObject<
+    T_1,
+    'strip',
+    ZodTypeAny,
+    {
+      [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>]: objectUtil.addQuestionMarks<
+        baseObjectOutputType<T_1>,
+        any
+      >[k];
+    },
+    { [k_1 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_1] }
+  >;
+  static strictCreate: <T_1 extends ZodRawShape>(
+    shape: T_1,
+    params?: RawCreateParams,
+  ) => ZodObject<
+    T_1,
+    'strict',
+    ZodTypeAny,
+    {
+      [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>]: objectUtil.addQuestionMarks<
+        baseObjectOutputType<T_1>,
+        any
+      >[k];
+    },
+    { [k_1 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_1] }
+  >;
+  static lazycreate: <T_1 extends ZodRawShape>(
+    shape: () => T_1,
+    params?: RawCreateParams,
+  ) => ZodObject<
+    T_1,
+    'strip',
+    ZodTypeAny,
+    {
+      [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>]: objectUtil.addQuestionMarks<
+        baseObjectOutputType<T_1>,
+        any
+      >[k];
+    },
+    { [k_1 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_1] }
+  >;
+}
+declare type AnyZodObject = ZodObject<any, any, any>;
+declare 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: <T_1 extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(
+    types: T_1,
+    params?: RawCreateParams,
+  ) => ZodUnion<T_1>;
+}
+declare type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<
+  {
+    [key in Discriminator]: ZodTypeAny;
+  } & ZodRawShape,
+  UnknownKeysParam,
+  ZodTypeAny
+>;
+interface ZodDiscriminatedUnionDef<
+  Discriminator extends string,
+  Options extends 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 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 [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: <T_1 extends ZodTypeAny, U_1 extends ZodTypeAny>(
+    left: T_1,
+    right: U_1,
+    params?: RawCreateParams,
+  ) => ZodIntersection<T_1, U_1>;
+}
+declare type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
+declare type AssertArray<T> = T extends any[] ? T : never;
+declare type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
+  [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]['_output'] : never;
+}>;
+declare type OutputTypeOfTupleWithRest<
+  T extends ZodTupleItems | [],
+  Rest extends ZodTypeAny | null = null,
+> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest['_output'][]] : OutputTypeOfTuple<T>;
+declare type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
+  [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]['_input'] : never;
+}>;
+declare 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;
+}
+declare type AnyZodTuple = ZodTuple<[ZodTypeAny, ...ZodTypeAny[]] | [], ZodTypeAny | null>;
+declare class ZodTuple<
+  T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]],
+  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<Rest extends ZodTypeAny>(rest: Rest): ZodTuple<T, Rest>;
+  static create: <T_1 extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(
+    schemas: T_1,
+    params?: RawCreateParams,
+  ) => ZodTuple<T_1, null>;
+}
+interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  valueType: Value;
+  keyType: Key;
+  typeName: ZodFirstPartyTypeKind.ZodRecord;
+}
+declare type KeySchema = ZodType<string | number | symbol, any, any>;
+declare 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: <Key_1 extends ZodTypeAny = ZodTypeAny, Value_1 extends ZodTypeAny = ZodTypeAny>(
+    keyType: Key_1,
+    valueType: Value_1,
+    params?: RawCreateParams,
+  ) => ZodMap<Key_1, Value_1>;
+}
+interface ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  valueType: Value;
+  typeName: ZodFirstPartyTypeKind.ZodSet;
+  minSize: {
+    value: number;
+    message?: string;
+  } | null;
+  maxSize: {
+    value: number;
+    message?: string;
+  } | 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: <Value_1 extends ZodTypeAny = ZodTypeAny>(
+    valueType: Value_1,
+    params?: RawCreateParams,
+  ) => ZodSet<Value_1>;
+}
+interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny>
+  extends ZodTypeDef {
+  args: Args;
+  returns: Returns;
+  typeName: ZodFirstPartyTypeKind.ZodFunction;
+}
+declare type OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> =
+  Args['_input'] extends Array<any> ? (...args: Args['_input']) => Returns['_output'] : never;
+declare 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: <T_1 extends ZodTypeAny>(getter: () => T_1, params?: RawCreateParams) => ZodLazy<T_1>;
+}
+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: <T_1 extends Primitive>(value: T_1, params?: RawCreateParams) => ZodLiteral<T_1>;
+}
+declare type ArrayKeys = keyof any[];
+declare type Indices<T> = Exclude<keyof T, ArrayKeys>;
+declare type EnumValues<T extends string = string> = readonly [T, ...T[]];
+declare type Values<T extends EnumValues> = {
+  [k in T[number]]: k;
+};
+interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
+  values: T;
+  typeName: ZodFirstPartyTypeKind.ZodEnum;
+}
+declare type Writeable<T> = {
+  -readonly [P in keyof T]: T[P];
+};
+declare type FilterEnum<Values, ToExclude> = Values extends []
+  ? []
+  : Values extends [infer Head, ...infer Rest]
+    ? Head extends ToExclude
+      ? FilterEnum<Rest, ToExclude>
+      : [Head, ...FilterEnum<Rest, ToExclude>]
+    : never;
+declare 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]> {
+  #private;
+  _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;
+}
+declare 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]> {
+  #private;
+  _parse(input: ParseInput): ParseReturnType<T[keyof T]>;
+  get enum(): T;
+  static create: <T_1 extends EnumLike>(values: T_1, params?: RawCreateParams) => ZodNativeEnum<T_1>;
+}
+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: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
+}
+declare type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
+declare type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;
+declare type RefinementEffect<T> = {
+  type: 'refinement';
+  refinement: (arg: T, ctx: RefinementCtx) => any;
+};
+declare type TransformEffect<T> = {
+  type: 'transform';
+  transform: (arg: T, ctx: RefinementCtx) => any;
+};
+declare type PreprocessEffect<T> = {
+  type: 'preprocess';
+  transform: (arg: T, ctx: RefinementCtx) => any;
+};
+declare 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'], input<I>>;
+  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;
+}
+declare 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: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodOptional<T_1>;
+}
+interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  typeName: ZodFirstPartyTypeKind.ZodNullable;
+}
+declare 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: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodNullable<T_1>;
+}
+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: <T_1 extends ZodTypeAny>(
+    type: T_1,
+    params: {
+      errorMap?: ZodErrorMap | undefined;
+      invalid_type_error?: string | undefined;
+      required_error?: string | undefined;
+      message?: string | undefined;
+      description?: string | undefined;
+    } & {
+      default: T_1['_input'] | (() => util.noUndefined<T_1['_input']>);
+    },
+  ) => ZodDefault<T_1>;
+}
+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: <T_1 extends ZodTypeAny>(
+    type: T_1,
+    params: {
+      errorMap?: ZodErrorMap | undefined;
+      invalid_type_error?: string | undefined;
+      required_error?: string | undefined;
+      message?: string | undefined;
+      description?: string | undefined;
+    } & {
+      catch: T_1['_output'] | (() => T_1['_output']);
+    },
+  ) => ZodCatch<T_1>;
+}
+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;
+declare 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<A extends ZodTypeAny, B extends ZodTypeAny>(a: A, b: B): ZodPipeline<A, B>;
+}
+declare type BuiltIn =
+  | (((...args: any[]) => any) | (new (...args: any[]) => any))
+  | {
+      readonly [Symbol.toStringTag]: string;
+    }
+  | Date
+  | Error
+  | Generator
+  | Promise<unknown>
+  | RegExp;
+declare 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: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodReadonly<T_1>;
+  unwrap(): T;
+}
+declare 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: <T extends ZodRawShape>(
+    shape: () => T,
+    params?: RawCreateParams,
+  ) => ZodObject<
+    T,
+    'strip',
+    ZodTypeAny,
+    {
+      [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T>, any>]: objectUtil.addQuestionMarks<
+        baseObjectOutputType<T>,
+        any
+      >[k];
+    },
+    { [k_1 in keyof baseObjectInputType<T>]: baseObjectInputType<T>[k_1] }
+  >;
+};
+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',
+}
+declare 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?:
+    | ({
+        errorMap?: ZodErrorMap | undefined;
+        invalid_type_error?: string | undefined;
+        required_error?: string | undefined;
+        message?: string | undefined;
+        description?: string | undefined;
+      } & {
+        coerce?: true | undefined;
+      })
+    | undefined,
+) => ZodString;
+declare const numberType: (
+  params?:
+    | ({
+        errorMap?: ZodErrorMap | undefined;
+        invalid_type_error?: string | undefined;
+        required_error?: string | undefined;
+        message?: string | undefined;
+        description?: string | undefined;
+      } & {
+        coerce?: boolean | undefined;
+      })
+    | undefined,
+) => ZodNumber;
+declare const nanType: (params?: RawCreateParams) => ZodNaN;
+declare const bigIntType: (
+  params?:
+    | ({
+        errorMap?: ZodErrorMap | undefined;
+        invalid_type_error?: string | undefined;
+        required_error?: string | undefined;
+        message?: string | undefined;
+        description?: string | undefined;
+      } & {
+        coerce?: boolean | undefined;
+      })
+    | undefined,
+) => ZodBigInt;
+declare const booleanType: (
+  params?:
+    | ({
+        errorMap?: ZodErrorMap | undefined;
+        invalid_type_error?: string | undefined;
+        required_error?: string | undefined;
+        message?: string | undefined;
+        description?: string | undefined;
+      } & {
+        coerce?: boolean | undefined;
+      })
+    | undefined,
+) => ZodBoolean;
+declare const dateType: (
+  params?:
+    | ({
+        errorMap?: ZodErrorMap | undefined;
+        invalid_type_error?: string | undefined;
+        required_error?: string | undefined;
+        message?: string | undefined;
+        description?: string | undefined;
+      } & {
+        coerce?: boolean | undefined;
+      })
+    | undefined,
+) => 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: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodArray<T, 'many'>;
+declare const objectType: <T extends ZodRawShape>(
+  shape: T,
+  params?: RawCreateParams,
+) => ZodObject<
+  T,
+  'strip',
+  ZodTypeAny,
+  {
+    [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T>, any>]: objectUtil.addQuestionMarks<
+      baseObjectOutputType<T>,
+      any
+    >[k];
+  },
+  { [k_1 in keyof baseObjectInputType<T>]: baseObjectInputType<T>[k_1] }
+>;
+declare const strictObjectType: <T extends ZodRawShape>(
+  shape: T,
+  params?: RawCreateParams,
+) => ZodObject<
+  T,
+  'strict',
+  ZodTypeAny,
+  {
+    [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T>, any>]: objectUtil.addQuestionMarks<
+      baseObjectOutputType<T>,
+      any
+    >[k];
+  },
+  { [k_1 in keyof baseObjectInputType<T>]: baseObjectInputType<T>[k_1] }
+>;
+declare const unionType: <T extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(
+  types: T,
+  params?: RawCreateParams,
+) => ZodUnion<T>;
+declare const discriminatedUnionType: typeof ZodDiscriminatedUnion.create;
+declare const intersectionType: <T extends ZodTypeAny, U extends ZodTypeAny>(
+  left: T,
+  right: U,
+  params?: RawCreateParams,
+) => ZodIntersection<T, U>;
+declare const tupleType: <T extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(
+  schemas: T,
+  params?: RawCreateParams,
+) => ZodTuple<T, null>;
+declare const recordType: typeof ZodRecord.create;
+declare const mapType: <Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny>(
+  keyType: Key,
+  valueType: Value,
+  params?: RawCreateParams,
+) => ZodMap<Key, Value>;
+declare const setType: <Value extends ZodTypeAny = ZodTypeAny>(
+  valueType: Value,
+  params?: RawCreateParams,
+) => ZodSet<Value>;
+declare const functionType: typeof ZodFunction.create;
+declare const lazyType: <T extends ZodTypeAny>(getter: () => T, params?: RawCreateParams) => ZodLazy<T>;
+declare const literalType: <T extends Primitive>(value: T, params?: RawCreateParams) => ZodLiteral<T>;
+declare const enumType: typeof createZodEnum;
+declare const nativeEnumType: <T extends EnumLike>(values: T, params?: RawCreateParams) => ZodNativeEnum<T>;
+declare const promiseType: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodPromise<T>;
+declare const effectsType: <I extends ZodTypeAny>(
+  schema: I,
+  effect: Effect<I['_output']>,
+  params?: RawCreateParams,
+) => ZodEffects<I, I['_output'], input<I>>;
+declare const optionalType: <T extends ZodTypeAny>(type: T, params?: RawCreateParams) => ZodOptional<T>;
+declare const nullableType: <T extends ZodTypeAny>(type: T, params?: RawCreateParams) => ZodNullable<T>;
+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: (
+    params?:
+      | ({
+          errorMap?: ZodErrorMap | undefined;
+          invalid_type_error?: string | undefined;
+          required_error?: string | undefined;
+          message?: string | undefined;
+          description?: string | undefined;
+        } & {
+          coerce?: true | undefined;
+        })
+      | undefined,
+  ) => ZodString;
+  number: (
+    params?:
+      | ({
+          errorMap?: ZodErrorMap | undefined;
+          invalid_type_error?: string | undefined;
+          required_error?: string | undefined;
+          message?: string | undefined;
+          description?: string | undefined;
+        } & {
+          coerce?: boolean | undefined;
+        })
+      | undefined,
+  ) => ZodNumber;
+  boolean: (
+    params?:
+      | ({
+          errorMap?: ZodErrorMap | undefined;
+          invalid_type_error?: string | undefined;
+          required_error?: string | undefined;
+          message?: string | undefined;
+          description?: string | undefined;
+        } & {
+          coerce?: boolean | undefined;
+        })
+      | undefined,
+  ) => ZodBoolean;
+  bigint: (
+    params?:
+      | ({
+          errorMap?: ZodErrorMap | undefined;
+          invalid_type_error?: string | undefined;
+          required_error?: string | undefined;
+          message?: string | undefined;
+          description?: string | undefined;
+        } & {
+          coerce?: boolean | undefined;
+        })
+      | undefined,
+  ) => ZodBigInt;
+  date: (
+    params?:
+      | ({
+          errorMap?: ZodErrorMap | undefined;
+          invalid_type_error?: string | undefined;
+          required_error?: string | undefined;
+          message?: string | undefined;
+          description?: string | undefined;
+        } & {
+          coerce?: boolean | undefined;
+        })
+      | undefined,
+  ) => ZodDate;
+};
+
+declare const NEVER: never;
+
+//# sourceMappingURL=external.d.ts.map
+
+declare const z_setErrorMap: typeof setErrorMap;
+declare const z_getErrorMap: typeof getErrorMap;
+declare const z_makeIssue: typeof makeIssue;
+type z_ParseParams = ParseParams;
+type z_ParsePathComponent = ParsePathComponent;
+type z_ParsePath = ParsePath;
+declare const z_EMPTY_PATH: typeof EMPTY_PATH;
+type z_ParseContext = ParseContext;
+type z_ParseInput = ParseInput;
+declare const z_addIssueToContext: typeof addIssueToContext;
+type z_ObjectPair = ObjectPair;
+type z_ParseStatus = ParseStatus;
+declare const z_ParseStatus: typeof ParseStatus;
+type z_ParseResult = ParseResult;
+declare const z_INVALID: typeof INVALID;
+declare const z_DIRTY: typeof DIRTY;
+declare const z_OK: typeof OK;
+type z_SyncParseReturnType<T = any> = SyncParseReturnType<T>;
+type z_AsyncParseReturnType<T> = AsyncParseReturnType<T>;
+type z_ParseReturnType<T> = ParseReturnType<T>;
+declare const z_isAborted: typeof isAborted;
+declare const z_isDirty: typeof isDirty;
+declare const z_isValid: typeof isValid;
+declare const z_isAsync: typeof isAsync;
+type z_Primitive = Primitive;
+type z_Scalars = Scalars;
+declare const z_util: typeof util;
+declare const z_objectUtil: typeof objectUtil;
+type z_ZodParsedType = ZodParsedType;
+declare const z_getParsedType: typeof getParsedType;
+declare const z_oboolean: typeof oboolean;
+declare const z_onumber: typeof onumber;
+declare const z_ostring: typeof ostring;
+type z_RefinementCtx = RefinementCtx;
+type z_ZodRawShape = ZodRawShape;
+type z_ZodTypeAny = ZodTypeAny;
+type z_TypeOf<T extends ZodType<any, any, any>> = TypeOf<T>;
+type z_input<T extends ZodType<any, any, any>> = input<T>;
+type z_output<T extends ZodType<any, any, any>> = output<T>;
+type z_CustomErrorParams = CustomErrorParams;
+type z_ZodTypeDef = ZodTypeDef;
+type z_RawCreateParams = RawCreateParams;
+type z_ProcessedCreateParams = ProcessedCreateParams;
+type z_SafeParseSuccess<Output> = SafeParseSuccess<Output>;
+type z_SafeParseError<Input> = SafeParseError<Input>;
+type z_SafeParseReturnType<Input, Output> = SafeParseReturnType<Input, Output>;
+type z_ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> = ZodType<Output, Def, Input>;
+declare const z_ZodType: typeof ZodType;
+type z_IpVersion = IpVersion;
+type z_ZodStringCheck = ZodStringCheck;
+type z_ZodStringDef = ZodStringDef;
+declare const z_datetimeRegex: typeof datetimeRegex;
+type z_ZodString = ZodString;
+declare const z_ZodString: typeof ZodString;
+type z_ZodNumberCheck = ZodNumberCheck;
+type z_ZodNumberDef = ZodNumberDef;
+type z_ZodNumber = ZodNumber;
+declare const z_ZodNumber: typeof ZodNumber;
+type z_ZodBigIntCheck = ZodBigIntCheck;
+type z_ZodBigIntDef = ZodBigIntDef;
+type z_ZodBigInt = ZodBigInt;
+declare const z_ZodBigInt: typeof ZodBigInt;
+type z_ZodBooleanDef = ZodBooleanDef;
+type z_ZodBoolean = ZodBoolean;
+declare const z_ZodBoolean: typeof ZodBoolean;
+type z_ZodDateCheck = ZodDateCheck;
+type z_ZodDateDef = ZodDateDef;
+type z_ZodDate = ZodDate;
+declare const z_ZodDate: typeof ZodDate;
+type z_ZodSymbolDef = ZodSymbolDef;
+type z_ZodSymbol = ZodSymbol;
+declare const z_ZodSymbol: typeof ZodSymbol;
+type z_ZodUndefinedDef = ZodUndefinedDef;
+type z_ZodUndefined = ZodUndefined;
+declare const z_ZodUndefined: typeof ZodUndefined;
+type z_ZodNullDef = ZodNullDef;
+type z_ZodNull = ZodNull;
+declare const z_ZodNull: typeof ZodNull;
+type z_ZodAnyDef = ZodAnyDef;
+type z_ZodAny = ZodAny;
+declare const z_ZodAny: typeof ZodAny;
+type z_ZodUnknownDef = ZodUnknownDef;
+type z_ZodUnknown = ZodUnknown;
+declare const z_ZodUnknown: typeof ZodUnknown;
+type z_ZodNeverDef = ZodNeverDef;
+type z_ZodNever = ZodNever;
+declare const z_ZodNever: typeof ZodNever;
+type z_ZodVoidDef = ZodVoidDef;
+type z_ZodVoid = ZodVoid;
+declare const z_ZodVoid: typeof ZodVoid;
+type z_ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> = ZodArrayDef<T>;
+type z_ArrayCardinality = ArrayCardinality;
+type z_arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = 'many'> = arrayOutputType<
+  T,
+  Cardinality
+>;
+type z_ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = 'many'> = ZodArray<T, Cardinality>;
+declare const z_ZodArray: typeof ZodArray;
+type z_ZodNonEmptyArray<T extends ZodTypeAny> = ZodNonEmptyArray<T>;
+type z_UnknownKeysParam = UnknownKeysParam;
+type z_ZodObjectDef<
+  T extends ZodRawShape = ZodRawShape,
+  UnknownKeys extends UnknownKeysParam = UnknownKeysParam,
+  Catchall extends ZodTypeAny = ZodTypeAny,
+> = ZodObjectDef<T, UnknownKeys, Catchall>;
+type z_mergeTypes<A, B> = mergeTypes<A, B>;
+type z_objectOutputType<
+  Shape extends ZodRawShape,
+  Catchall extends ZodTypeAny,
+  UnknownKeys extends UnknownKeysParam = UnknownKeysParam,
+> = objectOutputType<Shape, Catchall, UnknownKeys>;
+type z_baseObjectOutputType<Shape extends ZodRawShape> = baseObjectOutputType<Shape>;
+type z_objectInputType<
+  Shape extends ZodRawShape,
+  Catchall extends ZodTypeAny,
+  UnknownKeys extends UnknownKeysParam = UnknownKeysParam,
+> = objectInputType<Shape, Catchall, UnknownKeys>;
+type z_baseObjectInputType<Shape extends ZodRawShape> = baseObjectInputType<Shape>;
+type z_CatchallOutput<T extends ZodType> = CatchallOutput<T>;
+type z_CatchallInput<T extends ZodType> = CatchallInput<T>;
+type z_PassthroughType<T extends UnknownKeysParam> = PassthroughType<T>;
+type z_deoptional<T extends ZodTypeAny> = deoptional<T>;
+type z_SomeZodObject = SomeZodObject;
+type z_noUnrecognized<Obj extends object, Shape extends object> = noUnrecognized<Obj, Shape>;
+type z_ZodObject<
+  T extends ZodRawShape,
+  UnknownKeys extends UnknownKeysParam = UnknownKeysParam,
+  Catchall extends ZodTypeAny = ZodTypeAny,
+  Output = objectOutputType<T, Catchall, UnknownKeys>,
+  Input = objectInputType<T, Catchall, UnknownKeys>,
+> = ZodObject<T, UnknownKeys, Catchall, Output, Input>;
+declare const z_ZodObject: typeof ZodObject;
+type z_AnyZodObject = AnyZodObject;
+type z_ZodUnionOptions = ZodUnionOptions;
+type z_ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>> = ZodUnionDef<T>;
+type z_ZodUnion<T extends ZodUnionOptions> = ZodUnion<T>;
+declare const z_ZodUnion: typeof ZodUnion;
+type z_ZodDiscriminatedUnionOption<Discriminator extends string> = ZodDiscriminatedUnionOption<Discriminator>;
+type z_ZodDiscriminatedUnionDef<
+  Discriminator extends string,
+  Options extends ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[],
+> = ZodDiscriminatedUnionDef<Discriminator, Options>;
+type z_ZodDiscriminatedUnion<
+  Discriminator extends string,
+  Options extends ZodDiscriminatedUnionOption<Discriminator>[],
+> = ZodDiscriminatedUnion<Discriminator, Options>;
+declare const z_ZodDiscriminatedUnion: typeof ZodDiscriminatedUnion;
+type z_ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> = ZodIntersectionDef<
+  T,
+  U
+>;
+type z_ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> = ZodIntersection<T, U>;
+declare const z_ZodIntersection: typeof ZodIntersection;
+type z_ZodTupleItems = ZodTupleItems;
+type z_AssertArray<T> = AssertArray<T>;
+type z_OutputTypeOfTuple<T extends ZodTupleItems | []> = OutputTypeOfTuple<T>;
+type z_OutputTypeOfTupleWithRest<
+  T extends ZodTupleItems | [],
+  Rest extends ZodTypeAny | null = null,
+> = OutputTypeOfTupleWithRest<T, Rest>;
+type z_InputTypeOfTuple<T extends ZodTupleItems | []> = InputTypeOfTuple<T>;
+type z_InputTypeOfTupleWithRest<
+  T extends ZodTupleItems | [],
+  Rest extends ZodTypeAny | null = null,
+> = InputTypeOfTupleWithRest<T, Rest>;
+type z_ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> = ZodTupleDef<
+  T,
+  Rest
+>;
+type z_AnyZodTuple = AnyZodTuple;
+type z_ZodTuple<
+  T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]],
+  Rest extends ZodTypeAny | null = null,
+> = ZodTuple<T, Rest>;
+declare const z_ZodTuple: typeof ZodTuple;
+type z_ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> = ZodRecordDef<
+  Key,
+  Value
+>;
+type z_KeySchema = KeySchema;
+type z_RecordType<K extends string | number | symbol, V> = RecordType<K, V>;
+type z_ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> = ZodRecord<Key, Value>;
+declare const z_ZodRecord: typeof ZodRecord;
+type z_ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> = ZodMapDef<Key, Value>;
+type z_ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> = ZodMap<Key, Value>;
+declare const z_ZodMap: typeof ZodMap;
+type z_ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> = ZodSetDef<Value>;
+type z_ZodSet<Value extends ZodTypeAny = ZodTypeAny> = ZodSet<Value>;
+declare const z_ZodSet: typeof ZodSet;
+type z_ZodFunctionDef<
+  Args extends ZodTuple<any, any> = ZodTuple<any, any>,
+  Returns extends ZodTypeAny = ZodTypeAny,
+> = ZodFunctionDef<Args, Returns>;
+type z_OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = OuterTypeOfFunction<
+  Args,
+  Returns
+>;
+type z_InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = InnerTypeOfFunction<
+  Args,
+  Returns
+>;
+type z_ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = ZodFunction<Args, Returns>;
+declare const z_ZodFunction: typeof ZodFunction;
+type z_ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> = ZodLazyDef<T>;
+type z_ZodLazy<T extends ZodTypeAny> = ZodLazy<T>;
+declare const z_ZodLazy: typeof ZodLazy;
+type z_ZodLiteralDef<T = any> = ZodLiteralDef<T>;
+type z_ZodLiteral<T> = ZodLiteral<T>;
+declare const z_ZodLiteral: typeof ZodLiteral;
+type z_ArrayKeys = ArrayKeys;
+type z_Indices<T> = Indices<T>;
+type z_EnumValues<T extends string = string> = EnumValues<T>;
+type z_Values<T extends EnumValues> = Values<T>;
+type z_ZodEnumDef<T extends EnumValues = EnumValues> = ZodEnumDef<T>;
+type z_Writeable<T> = Writeable<T>;
+type z_FilterEnum<Values, ToExclude> = FilterEnum<Values, ToExclude>;
+type z_typecast<A, T> = typecast<A, T>;
+type z_ZodEnum<T extends [string, ...string[]]> = ZodEnum<T>;
+declare const z_ZodEnum: typeof ZodEnum;
+type z_ZodNativeEnumDef<T extends EnumLike = EnumLike> = ZodNativeEnumDef<T>;
+type z_EnumLike = EnumLike;
+type z_ZodNativeEnum<T extends EnumLike> = ZodNativeEnum<T>;
+declare const z_ZodNativeEnum: typeof ZodNativeEnum;
+type z_ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> = ZodPromiseDef<T>;
+type z_ZodPromise<T extends ZodTypeAny> = ZodPromise<T>;
+declare const z_ZodPromise: typeof ZodPromise;
+type z_Refinement<T> = Refinement<T>;
+type z_SuperRefinement<T> = SuperRefinement<T>;
+type z_RefinementEffect<T> = RefinementEffect<T>;
+type z_TransformEffect<T> = TransformEffect<T>;
+type z_PreprocessEffect<T> = PreprocessEffect<T>;
+type z_Effect<T> = Effect<T>;
+type z_ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> = ZodEffectsDef<T>;
+type z_ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> = ZodEffects<T, Output, Input>;
+declare const z_ZodEffects: typeof ZodEffects;
+type z_ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> = ZodOptionalDef<T>;
+type z_ZodOptionalType<T extends ZodTypeAny> = ZodOptionalType<T>;
+type z_ZodOptional<T extends ZodTypeAny> = ZodOptional<T>;
+declare const z_ZodOptional: typeof ZodOptional;
+type z_ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> = ZodNullableDef<T>;
+type z_ZodNullableType<T extends ZodTypeAny> = ZodNullableType<T>;
+type z_ZodNullable<T extends ZodTypeAny> = ZodNullable<T>;
+declare const z_ZodNullable: typeof ZodNullable;
+type z_ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> = ZodDefaultDef<T>;
+type z_ZodDefault<T extends ZodTypeAny> = ZodDefault<T>;
+declare const z_ZodDefault: typeof ZodDefault;
+type z_ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> = ZodCatchDef<T>;
+type z_ZodCatch<T extends ZodTypeAny> = ZodCatch<T>;
+declare const z_ZodCatch: typeof ZodCatch;
+type z_ZodNaNDef = ZodNaNDef;
+type z_ZodNaN = ZodNaN;
+declare const z_ZodNaN: typeof ZodNaN;
+type z_ZodBrandedDef<T extends ZodTypeAny> = ZodBrandedDef<T>;
+type z_BRAND<T extends string | number | symbol> = BRAND<T>;
+type z_ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> = ZodBranded<T, B>;
+declare const z_ZodBranded: typeof ZodBranded;
+type z_ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> = ZodPipelineDef<A, B>;
+type z_ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> = ZodPipeline<A, B>;
+declare const z_ZodPipeline: typeof ZodPipeline;
+type z_ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> = ZodReadonlyDef<T>;
+type z_ZodReadonly<T extends ZodTypeAny> = ZodReadonly<T>;
+declare const z_ZodReadonly: typeof ZodReadonly;
+declare const z_custom: typeof custom;
+declare const z_late: typeof late;
+type z_ZodFirstPartyTypeKind = ZodFirstPartyTypeKind;
+declare const z_ZodFirstPartyTypeKind: typeof ZodFirstPartyTypeKind;
+type z_ZodFirstPartySchemaTypes = ZodFirstPartySchemaTypes;
+declare const z_coerce: typeof coerce;
+declare const z_NEVER: typeof NEVER;
+type z_inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = inferFlattenedErrors<T, U>;
+type z_typeToFlattenedError<T, U = string> = typeToFlattenedError<T, U>;
+type z_ZodIssueCode = ZodIssueCode;
+type z_ZodIssueBase = ZodIssueBase;
+type z_ZodInvalidTypeIssue = ZodInvalidTypeIssue;
+type z_ZodInvalidLiteralIssue = ZodInvalidLiteralIssue;
+type z_ZodUnrecognizedKeysIssue = ZodUnrecognizedKeysIssue;
+type z_ZodInvalidUnionIssue = ZodInvalidUnionIssue;
+type z_ZodInvalidUnionDiscriminatorIssue = ZodInvalidUnionDiscriminatorIssue;
+type z_ZodInvalidEnumValueIssue = ZodInvalidEnumValueIssue;
+type z_ZodInvalidArgumentsIssue = ZodInvalidArgumentsIssue;
+type z_ZodInvalidReturnTypeIssue = ZodInvalidReturnTypeIssue;
+type z_ZodInvalidDateIssue = ZodInvalidDateIssue;
+type z_StringValidation = StringValidation;
+type z_ZodInvalidStringIssue = ZodInvalidStringIssue;
+type z_ZodTooSmallIssue = ZodTooSmallIssue;
+type z_ZodTooBigIssue = ZodTooBigIssue;
+type z_ZodInvalidIntersectionTypesIssue = ZodInvalidIntersectionTypesIssue;
+type z_ZodNotMultipleOfIssue = ZodNotMultipleOfIssue;
+type z_ZodNotFiniteIssue = ZodNotFiniteIssue;
+type z_ZodCustomIssue = ZodCustomIssue;
+type z_DenormalizedError = DenormalizedError;
+type z_ZodIssueOptionalMessage = ZodIssueOptionalMessage;
+type z_ZodIssue = ZodIssue;
+declare const z_quotelessJson: typeof quotelessJson;
+type z_ZodFormattedError<T, U = string> = ZodFormattedError<T, U>;
+type z_inferFormattedError<T extends ZodType<any, any, any>, U = string> = inferFormattedError<T, U>;
+type z_ZodError<T = any> = ZodError<T>;
+declare const z_ZodError: typeof ZodError;
+type z_IssueData = IssueData;
+type z_ErrorMapCtx = ErrorMapCtx;
+type z_ZodErrorMap = ZodErrorMap;
+declare namespace z {
+  export {
+    errorMap as defaultErrorMap,
+    z_setErrorMap as setErrorMap,
+    z_getErrorMap as getErrorMap,
+    z_makeIssue as makeIssue,
+    type z_ParseParams as ParseParams,
+    type z_ParsePathComponent as ParsePathComponent,
+    type z_ParsePath as ParsePath,
+    z_EMPTY_PATH as EMPTY_PATH,
+    type z_ParseContext as ParseContext,
+    type z_ParseInput as ParseInput,
+    z_addIssueToContext as addIssueToContext,
+    type z_ObjectPair as ObjectPair,
+    z_ParseStatus as ParseStatus,
+    type z_ParseResult as ParseResult,
+    z_INVALID as INVALID,
+    z_DIRTY as DIRTY,
+    z_OK as OK,
+    type z_SyncParseReturnType as SyncParseReturnType,
+    type z_AsyncParseReturnType as AsyncParseReturnType,
+    type z_ParseReturnType as ParseReturnType,
+    z_isAborted as isAborted,
+    z_isDirty as isDirty,
+    z_isValid as isValid,
+    z_isAsync as isAsync,
+    type z_Primitive as Primitive,
+    type z_Scalars as Scalars,
+    z_util as util,
+    z_objectUtil as objectUtil,
+    type z_ZodParsedType as ZodParsedType,
+    z_getParsedType as getParsedType,
+    type TypeOf as infer,
+    ZodEffects as ZodTransformer,
+    ZodType as Schema,
+    ZodType as ZodSchema,
+    anyType as any,
+    arrayType as array,
+    bigIntType as bigint,
+    booleanType as boolean,
+    dateType as date,
+    discriminatedUnionType as discriminatedUnion,
+    effectsType as effect,
+    enumType as enum,
+    functionType as function,
+    instanceOfType as instanceof,
+    intersectionType as intersection,
+    lazyType as lazy,
+    literalType as literal,
+    mapType as map,
+    nanType as nan,
+    nativeEnumType as nativeEnum,
+    neverType as never,
+    nullType as null,
+    nullableType as nullable,
+    numberType as number,
+    objectType as object,
+    z_oboolean as oboolean,
+    z_onumber as onumber,
+    optionalType as optional,
+    z_ostring as ostring,
+    pipelineType as pipeline,
+    preprocessType as preprocess,
+    promiseType as promise,
+    recordType as record,
+    setType as set,
+    strictObjectType as strictObject,
+    stringType as string,
+    symbolType as symbol,
+    effectsType as transformer,
+    tupleType as tuple,
+    undefinedType as undefined,
+    unionType as union,
+    unknownType as unknown,
+    voidType as void,
+    type z_RefinementCtx as RefinementCtx,
+    type z_ZodRawShape as ZodRawShape,
+    type z_ZodTypeAny as ZodTypeAny,
+    type z_TypeOf as TypeOf,
+    type z_input as input,
+    type z_output as output,
+    type z_CustomErrorParams as CustomErrorParams,
+    type z_ZodTypeDef as ZodTypeDef,
+    type z_RawCreateParams as RawCreateParams,
+    type z_ProcessedCreateParams as ProcessedCreateParams,
+    type z_SafeParseSuccess as SafeParseSuccess,
+    type z_SafeParseError as SafeParseError,
+    type z_SafeParseReturnType as SafeParseReturnType,
+    z_ZodType as ZodType,
+    type z_IpVersion as IpVersion,
+    type z_ZodStringCheck as ZodStringCheck,
+    type z_ZodStringDef as ZodStringDef,
+    z_datetimeRegex as datetimeRegex,
+    z_ZodString as ZodString,
+    type z_ZodNumberCheck as ZodNumberCheck,
+    type z_ZodNumberDef as ZodNumberDef,
+    z_ZodNumber as ZodNumber,
+    type z_ZodBigIntCheck as ZodBigIntCheck,
+    type z_ZodBigIntDef as ZodBigIntDef,
+    z_ZodBigInt as ZodBigInt,
+    type z_ZodBooleanDef as ZodBooleanDef,
+    z_ZodBoolean as ZodBoolean,
+    type z_ZodDateCheck as ZodDateCheck,
+    type z_ZodDateDef as ZodDateDef,
+    z_ZodDate as ZodDate,
+    type z_ZodSymbolDef as ZodSymbolDef,
+    z_ZodSymbol as ZodSymbol,
+    type z_ZodUndefinedDef as ZodUndefinedDef,
+    z_ZodUndefined as ZodUndefined,
+    type z_ZodNullDef as ZodNullDef,
+    z_ZodNull as ZodNull,
+    type z_ZodAnyDef as ZodAnyDef,
+    z_ZodAny as ZodAny,
+    type z_ZodUnknownDef as ZodUnknownDef,
+    z_ZodUnknown as ZodUnknown,
+    type z_ZodNeverDef as ZodNeverDef,
+    z_ZodNever as ZodNever,
+    type z_ZodVoidDef as ZodVoidDef,
+    z_ZodVoid as ZodVoid,
+    type z_ZodArrayDef as ZodArrayDef,
+    type z_ArrayCardinality as ArrayCardinality,
+    type z_arrayOutputType as arrayOutputType,
+    z_ZodArray as ZodArray,
+    type z_ZodNonEmptyArray as ZodNonEmptyArray,
+    type z_UnknownKeysParam as UnknownKeysParam,
+    type z_ZodObjectDef as ZodObjectDef,
+    type z_mergeTypes as mergeTypes,
+    type z_objectOutputType as objectOutputType,
+    type z_baseObjectOutputType as baseObjectOutputType,
+    type z_objectInputType as objectInputType,
+    type z_baseObjectInputType as baseObjectInputType,
+    type z_CatchallOutput as CatchallOutput,
+    type z_CatchallInput as CatchallInput,
+    type z_PassthroughType as PassthroughType,
+    type z_deoptional as deoptional,
+    type z_SomeZodObject as SomeZodObject,
+    type z_noUnrecognized as noUnrecognized,
+    z_ZodObject as ZodObject,
+    type z_AnyZodObject as AnyZodObject,
+    type z_ZodUnionOptions as ZodUnionOptions,
+    type z_ZodUnionDef as ZodUnionDef,
+    z_ZodUnion as ZodUnion,
+    type z_ZodDiscriminatedUnionOption as ZodDiscriminatedUnionOption,
+    type z_ZodDiscriminatedUnionDef as ZodDiscriminatedUnionDef,
+    z_ZodDiscriminatedUnion as ZodDiscriminatedUnion,
+    type z_ZodIntersectionDef as ZodIntersectionDef,
+    z_ZodIntersection as ZodIntersection,
+    type z_ZodTupleItems as ZodTupleItems,
+    type z_AssertArray as AssertArray,
+    type z_OutputTypeOfTuple as OutputTypeOfTuple,
+    type z_OutputTypeOfTupleWithRest as OutputTypeOfTupleWithRest,
+    type z_InputTypeOfTuple as InputTypeOfTuple,
+    type z_InputTypeOfTupleWithRest as InputTypeOfTupleWithRest,
+    type z_ZodTupleDef as ZodTupleDef,
+    type z_AnyZodTuple as AnyZodTuple,
+    z_ZodTuple as ZodTuple,
+    type z_ZodRecordDef as ZodRecordDef,
+    type z_KeySchema as KeySchema,
+    type z_RecordType as RecordType,
+    z_ZodRecord as ZodRecord,
+    type z_ZodMapDef as ZodMapDef,
+    z_ZodMap as ZodMap,
+    type z_ZodSetDef as ZodSetDef,
+    z_ZodSet as ZodSet,
+    type z_ZodFunctionDef as ZodFunctionDef,
+    type z_OuterTypeOfFunction as OuterTypeOfFunction,
+    type z_InnerTypeOfFunction as InnerTypeOfFunction,
+    z_ZodFunction as ZodFunction,
+    type z_ZodLazyDef as ZodLazyDef,
+    z_ZodLazy as ZodLazy,
+    type z_ZodLiteralDef as ZodLiteralDef,
+    z_ZodLiteral as ZodLiteral,
+    type z_ArrayKeys as ArrayKeys,
+    type z_Indices as Indices,
+    type z_EnumValues as EnumValues,
+    type z_Values as Values,
+    type z_ZodEnumDef as ZodEnumDef,
+    type z_Writeable as Writeable,
+    type z_FilterEnum as FilterEnum,
+    type z_typecast as typecast,
+    z_ZodEnum as ZodEnum,
+    type z_ZodNativeEnumDef as ZodNativeEnumDef,
+    type z_EnumLike as EnumLike,
+    z_ZodNativeEnum as ZodNativeEnum,
+    type z_ZodPromiseDef as ZodPromiseDef,
+    z_ZodPromise as ZodPromise,
+    type z_Refinement as Refinement,
+    type z_SuperRefinement as SuperRefinement,
+    type z_RefinementEffect as RefinementEffect,
+    type z_TransformEffect as TransformEffect,
+    type z_PreprocessEffect as PreprocessEffect,
+    type z_Effect as Effect,
+    type z_ZodEffectsDef as ZodEffectsDef,
+    z_ZodEffects as ZodEffects,
+    type z_ZodOptionalDef as ZodOptionalDef,
+    type z_ZodOptionalType as ZodOptionalType,
+    z_ZodOptional as ZodOptional,
+    type z_ZodNullableDef as ZodNullableDef,
+    type z_ZodNullableType as ZodNullableType,
+    z_ZodNullable as ZodNullable,
+    type z_ZodDefaultDef as ZodDefaultDef,
+    z_ZodDefault as ZodDefault,
+    type z_ZodCatchDef as ZodCatchDef,
+    z_ZodCatch as ZodCatch,
+    type z_ZodNaNDef as ZodNaNDef,
+    z_ZodNaN as ZodNaN,
+    type z_ZodBrandedDef as ZodBrandedDef,
+    type z_BRAND as BRAND,
+    z_ZodBranded as ZodBranded,
+    type z_ZodPipelineDef as ZodPipelineDef,
+    z_ZodPipeline as ZodPipeline,
+    type z_ZodReadonlyDef as ZodReadonlyDef,
+    z_ZodReadonly as ZodReadonly,
+    z_custom as custom,
+    z_late as late,
+    z_ZodFirstPartyTypeKind as ZodFirstPartyTypeKind,
+    type z_ZodFirstPartySchemaTypes as ZodFirstPartySchemaTypes,
+    z_coerce as coerce,
+    z_NEVER as NEVER,
+    type z_inferFlattenedErrors as inferFlattenedErrors,
+    type z_typeToFlattenedError as typeToFlattenedError,
+    type z_ZodIssueCode as ZodIssueCode,
+    type z_ZodIssueBase as ZodIssueBase,
+    type z_ZodInvalidTypeIssue as ZodInvalidTypeIssue,
+    type z_ZodInvalidLiteralIssue as ZodInvalidLiteralIssue,
+    type z_ZodUnrecognizedKeysIssue as ZodUnrecognizedKeysIssue,
+    type z_ZodInvalidUnionIssue as ZodInvalidUnionIssue,
+    type z_ZodInvalidUnionDiscriminatorIssue as ZodInvalidUnionDiscriminatorIssue,
+    type z_ZodInvalidEnumValueIssue as ZodInvalidEnumValueIssue,
+    type z_ZodInvalidArgumentsIssue as ZodInvalidArgumentsIssue,
+    type z_ZodInvalidReturnTypeIssue as ZodInvalidReturnTypeIssue,
+    type z_ZodInvalidDateIssue as ZodInvalidDateIssue,
+    type z_StringValidation as StringValidation,
+    type z_ZodInvalidStringIssue as ZodInvalidStringIssue,
+    type z_ZodTooSmallIssue as ZodTooSmallIssue,
+    type z_ZodTooBigIssue as ZodTooBigIssue,
+    type z_ZodInvalidIntersectionTypesIssue as ZodInvalidIntersectionTypesIssue,
+    type z_ZodNotMultipleOfIssue as ZodNotMultipleOfIssue,
+    type z_ZodNotFiniteIssue as ZodNotFiniteIssue,
+    type z_ZodCustomIssue as ZodCustomIssue,
+    type z_DenormalizedError as DenormalizedError,
+    type z_ZodIssueOptionalMessage as ZodIssueOptionalMessage,
+    type z_ZodIssue as ZodIssue,
+    z_quotelessJson as quotelessJson,
+    type z_ZodFormattedError as ZodFormattedError,
+    type z_inferFormattedError as inferFormattedError,
+    z_ZodError as ZodError,
+    type z_IssueData as IssueData,
+    type z_ErrorMapCtx as ErrorMapCtx,
+    type z_ZodErrorMap as ZodErrorMap,
+  };
+}
+
+//# sourceMappingURL=index.d.ts.map
+
+export {
+  type AnyZodObject,
+  type AnyZodTuple,
+  type ArrayCardinality,
+  type ArrayKeys,
+  type AssertArray,
+  type AsyncParseReturnType,
+  BRAND,
+  type CatchallInput,
+  type CatchallOutput,
+  type CustomErrorParams,
+  DIRTY,
+  type DenormalizedError,
+  EMPTY_PATH,
+  type Effect,
+  type EnumLike,
+  type EnumValues,
+  type ErrorMapCtx,
+  type FilterEnum,
+  INVALID,
+  type Indices,
+  type InnerTypeOfFunction,
+  type InputTypeOfTuple,
+  type InputTypeOfTupleWithRest,
+  type IpVersion,
+  type IssueData,
+  type KeySchema,
+  NEVER,
+  OK,
+  type ObjectPair,
+  type OuterTypeOfFunction,
+  type OutputTypeOfTuple,
+  type OutputTypeOfTupleWithRest,
+  type ParseContext,
+  type ParseInput,
+  type ParseParams,
+  type ParsePath,
+  type ParsePathComponent,
+  type ParseResult,
+  type ParseReturnType,
+  ParseStatus,
+  type PassthroughType,
+  type PreprocessEffect,
+  type Primitive,
+  type ProcessedCreateParams,
+  type RawCreateParams,
+  type RecordType,
+  type Refinement,
+  type RefinementCtx,
+  type RefinementEffect,
+  type SafeParseError,
+  type SafeParseReturnType,
+  type SafeParseSuccess,
+  type Scalars,
+  ZodType as Schema,
+  type SomeZodObject,
+  type StringValidation,
+  type SuperRefinement,
+  type SyncParseReturnType,
+  type TransformEffect,
+  type TypeOf,
+  type UnknownKeysParam,
+  type Values,
+  type Writeable,
+  ZodAny,
+  type ZodAnyDef,
+  ZodArray,
+  type ZodArrayDef,
+  ZodBigInt,
+  type ZodBigIntCheck,
+  type ZodBigIntDef,
+  ZodBoolean,
+  type ZodBooleanDef,
+  ZodBranded,
+  type ZodBrandedDef,
+  ZodCatch,
+  type ZodCatchDef,
+  type ZodCustomIssue,
+  ZodDate,
+  type ZodDateCheck,
+  type ZodDateDef,
+  ZodDefault,
+  type ZodDefaultDef,
+  ZodDiscriminatedUnion,
+  type ZodDiscriminatedUnionDef,
+  type ZodDiscriminatedUnionOption,
+  ZodEffects,
+  type ZodEffectsDef,
+  ZodEnum,
+  type ZodEnumDef,
+  ZodError,
+  type ZodErrorMap,
+  type ZodFirstPartySchemaTypes,
+  ZodFirstPartyTypeKind,
+  type ZodFormattedError,
+  ZodFunction,
+  type ZodFunctionDef,
+  ZodIntersection,
+  type ZodIntersectionDef,
+  type ZodInvalidArgumentsIssue,
+  type ZodInvalidDateIssue,
+  type ZodInvalidEnumValueIssue,
+  type ZodInvalidIntersectionTypesIssue,
+  type ZodInvalidLiteralIssue,
+  type ZodInvalidReturnTypeIssue,
+  type ZodInvalidStringIssue,
+  type ZodInvalidTypeIssue,
+  type ZodInvalidUnionDiscriminatorIssue,
+  type ZodInvalidUnionIssue,
+  type ZodIssue,
+  type ZodIssueBase,
+  ZodIssueCode,
+  type ZodIssueOptionalMessage,
+  ZodLazy,
+  type ZodLazyDef,
+  ZodLiteral,
+  type ZodLiteralDef,
+  ZodMap,
+  type ZodMapDef,
+  ZodNaN,
+  type ZodNaNDef,
+  ZodNativeEnum,
+  type ZodNativeEnumDef,
+  ZodNever,
+  type ZodNeverDef,
+  type ZodNonEmptyArray,
+  type ZodNotFiniteIssue,
+  type ZodNotMultipleOfIssue,
+  ZodNull,
+  type ZodNullDef,
+  ZodNullable,
+  type ZodNullableDef,
+  type ZodNullableType,
+  ZodNumber,
+  type ZodNumberCheck,
+  type ZodNumberDef,
+  ZodObject,
+  type ZodObjectDef,
+  ZodOptional,
+  type ZodOptionalDef,
+  type ZodOptionalType,
+  ZodParsedType,
+  ZodPipeline,
+  type ZodPipelineDef,
+  ZodPromise,
+  type ZodPromiseDef,
+  type ZodRawShape,
+  ZodReadonly,
+  type ZodReadonlyDef,
+  ZodRecord,
+  type ZodRecordDef,
+  ZodType as ZodSchema,
+  ZodSet,
+  type ZodSetDef,
+  ZodString,
+  type ZodStringCheck,
+  type ZodStringDef,
+  ZodSymbol,
+  type ZodSymbolDef,
+  type ZodTooBigIssue,
+  type ZodTooSmallIssue,
+  ZodEffects as ZodTransformer,
+  ZodTuple,
+  type ZodTupleDef,
+  type ZodTupleItems,
+  ZodType,
+  type ZodTypeAny,
+  type ZodTypeDef,
+  ZodUndefined,
+  type ZodUndefinedDef,
+  ZodUnion,
+  type ZodUnionDef,
+  type ZodUnionOptions,
+  ZodUnknown,
+  type ZodUnknownDef,
+  type ZodUnrecognizedKeysIssue,
+  ZodVoid,
+  type ZodVoidDef,
+  addIssueToContext,
+  anyType as any,
+  arrayType as array,
+  type arrayOutputType,
+  type baseObjectInputType,
+  type baseObjectOutputType,
+  bigIntType as bigint,
+  booleanType as boolean,
+  coerce,
+  custom,
+  dateType as date,
+  datetimeRegex,
+  z as default,
+  errorMap as defaultErrorMap,
+  type deoptional,
+  discriminatedUnionType as discriminatedUnion,
+  effectsType as effect,
+  enumType as enum,
+  functionType as function,
+  getErrorMap,
+  getParsedType,
+  type TypeOf as infer,
+  type inferFlattenedErrors,
+  type inferFormattedError,
+  type input,
+  instanceOfType as instanceof,
+  intersectionType as intersection,
+  isAborted,
+  isAsync,
+  isDirty,
+  isValid,
+  late,
+  lazyType as lazy,
+  literalType as literal,
+  makeIssue,
+  mapType as map,
+  type mergeTypes,
+  nanType as nan,
+  nativeEnumType as nativeEnum,
+  neverType as never,
+  type noUnrecognized,
+  nullType as null,
+  nullableType as nullable,
+  numberType as number,
+  objectType as object,
+  type objectInputType,
+  type objectOutputType,
+  objectUtil,
+  oboolean,
+  onumber,
+  optionalType as optional,
+  ostring,
+  type output,
+  pipelineType as pipeline,
+  preprocessType as preprocess,
+  promiseType as promise,
+  quotelessJson,
+  recordType as record,
+  setType as set,
+  setErrorMap,
+  strictObjectType as strictObject,
+  stringType as string,
+  symbolType as symbol,
+  effectsType as transformer,
+  tupleType as tuple,
+  type typeToFlattenedError,
+  type typecast,
+  undefinedType as undefined,
+  unionType as union,
+  unknownType as unknown,
+  util,
+  voidType as void,
+  z,
+};
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 38c3b130..7eb9fc34 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -91,7 +91,7 @@ importers:
         version: 1.4.0
       '@monaco-editor/react':
         specifier: ^4.6.0
-        version: 4.6.0(monaco-editor@0.48.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+        version: 4.6.0(monaco-editor@0.50.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@tanstack/react-table':
         specifier: 8.17.3
         version: 8.17.3(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
@@ -123,8 +123,8 @@ importers:
         specifier: ^2.2.3
         version: 2.2.3
       monaco-editor:
-        specifier: ^0.48.0
-        version: 0.48.0
+        specifier: ^0.50.0
+        version: 0.50.0
       react-ace:
         specifier: ^11.0.1
         version: 11.0.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
@@ -4992,8 +4992,8 @@ packages:
     resolution: {integrity: sha512-xV2bxeN6F7oYjZWTe/YPAy6MN2M+sL4u/Rlm2AHCIVGfo2p1yGmBHQ6vHehl4bRTZBdHu3TSkWdYgkwpYzAGSw==}
     engines: {node: '>=0.10.0'}
 
-  monaco-editor@0.48.0:
-    resolution: {integrity: sha512-goSDElNqFfw7iDHMg8WDATkfcyeLTNpBHQpO8incK6p5qZt5G/1j41X0xdGzpIkGojGXM+QiRQyLjnfDVvrpwA==}
+  monaco-editor@0.50.0:
+    resolution: {integrity: sha512-8CclLCmrRRh+sul7C08BmPBP3P8wVWfBHomsTcndxg5NRCEPfu/mc2AGU8k37ajjDVXcXFc12ORAMUkmk+lkFA==}
 
   ms@2.0.0:
     resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==}
@@ -7092,7 +7092,7 @@ snapshots:
       '@babel/traverse': 7.24.1
       '@babel/types': 7.24.0
       convert-source-map: 2.0.0
-      debug: 4.3.4(supports-color@8.1.1)
+      debug: 4.3.4
       gensync: 1.0.0-beta.2
       json5: 2.2.3
       semver: 6.3.1
@@ -7153,7 +7153,7 @@ snapshots:
       '@babel/core': 7.24.4
       '@babel/helper-compilation-targets': 7.23.6
       '@babel/helper-plugin-utils': 7.24.0
-      debug: 4.3.4(supports-color@8.1.1)
+      debug: 4.3.4
       lodash.debounce: 4.0.8
       resolve: 1.22.8
     transitivePeerDependencies:
@@ -7834,7 +7834,7 @@ snapshots:
       '@babel/helper-split-export-declaration': 7.22.6
       '@babel/parser': 7.24.4
       '@babel/types': 7.24.0
-      debug: 4.3.4(supports-color@8.1.1)
+      debug: 4.3.4
       globals: 11.12.0
     transitivePeerDependencies:
       - supports-color
@@ -7849,7 +7849,7 @@ snapshots:
       '@babel/helper-split-export-declaration': 7.22.6
       '@babel/parser': 7.24.4
       '@babel/types': 7.24.0
-      debug: 4.3.4(supports-color@8.1.1)
+      debug: 4.3.4
       globals: 11.12.0
     transitivePeerDependencies:
       - supports-color
@@ -8210,15 +8210,15 @@ snapshots:
 
   '@microsoft/tsdoc@0.14.2': {}
 
-  '@monaco-editor/loader@1.4.0(monaco-editor@0.48.0)':
+  '@monaco-editor/loader@1.4.0(monaco-editor@0.50.0)':
     dependencies:
-      monaco-editor: 0.48.0
+      monaco-editor: 0.50.0
       state-local: 1.0.7
 
-  '@monaco-editor/react@4.6.0(monaco-editor@0.48.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+  '@monaco-editor/react@4.6.0(monaco-editor@0.50.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@monaco-editor/loader': 1.4.0(monaco-editor@0.48.0)
-      monaco-editor: 0.48.0
+      '@monaco-editor/loader': 1.4.0(monaco-editor@0.50.0)
+      monaco-editor: 0.50.0
       react: 18.3.1
       react-dom: 18.3.1(react@18.3.1)
 
@@ -11067,6 +11067,10 @@ snapshots:
     dependencies:
       ms: 2.0.0
 
+  debug@4.3.4:
+    dependencies:
+      ms: 2.1.2
+
   debug@4.3.4(supports-color@8.1.1):
     dependencies:
       ms: 2.1.2
@@ -11174,7 +11178,7 @@ snapshots:
   detect-port@1.5.1:
     dependencies:
       address: 1.2.2
-      debug: 4.3.4(supports-color@8.1.1)
+      debug: 4.3.4
     transitivePeerDependencies:
       - supports-color
 
@@ -11384,7 +11388,7 @@ snapshots:
 
   esbuild-register@3.5.0(esbuild@0.20.2):
     dependencies:
-      debug: 4.3.4(supports-color@8.1.1)
+      debug: 4.3.4
       esbuild: 0.20.2
     transitivePeerDependencies:
       - supports-color
@@ -12993,7 +12997,7 @@ snapshots:
 
   modify-values@1.0.1: {}
 
-  monaco-editor@0.48.0: {}
+  monaco-editor@0.50.0: {}
 
   ms@2.0.0: {}
 
@@ -15090,7 +15094,7 @@ snapshots:
       '@microsoft/api-extractor': 7.43.0(@types/node@20.12.12)
       '@rollup/pluginutils': 5.1.0(rollup@4.15.0)
       '@vue/language-core': 1.8.27(typescript@5.4.5)
-      debug: 4.3.4(supports-color@8.1.1)
+      debug: 4.3.4
       kolorist: 1.8.0
       magic-string: 0.30.10
       typescript: 5.4.5