likec4 1.53.0 → 1.54.0

package/dist/_chunks/libs/@modelcontextprotocol/sdk.d.mts

@@ -1,4 +1,99 @@
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/core/standard-schema.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/json-schema.d.cts
+type _JSONSchema = boolean | JSONSchema$1;
+type JSONSchema$1 = {
+  [k: string]: unknown;
+  $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
+  $id?: string;
+  $anchor?: string;
+  $ref?: string;
+  $dynamicRef?: string;
+  $dynamicAnchor?: string;
+  $vocabulary?: Record<string, boolean>;
+  $comment?: string;
+  $defs?: Record<string, JSONSchema$1>;
+  type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
+  additionalItems?: _JSONSchema;
+  unevaluatedItems?: _JSONSchema;
+  prefixItems?: _JSONSchema[];
+  items?: _JSONSchema | _JSONSchema[];
+  contains?: _JSONSchema;
+  additionalProperties?: _JSONSchema;
+  unevaluatedProperties?: _JSONSchema;
+  properties?: Record<string, _JSONSchema>;
+  patternProperties?: Record<string, _JSONSchema>;
+  dependentSchemas?: Record<string, _JSONSchema>;
+  propertyNames?: _JSONSchema;
+  if?: _JSONSchema;
+  then?: _JSONSchema;
+  else?: _JSONSchema;
+  allOf?: JSONSchema$1[];
+  anyOf?: JSONSchema$1[];
+  oneOf?: JSONSchema$1[];
+  not?: _JSONSchema;
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: number | boolean;
+  minimum?: number;
+  exclusiveMinimum?: number | boolean;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxContains?: number;
+  minContains?: number;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  dependentRequired?: Record<string, string[]>;
+  enum?: Array<string | number | boolean | null>;
+  const?: string | number | boolean | null;
+  id?: string;
+  title?: string;
+  description?: string;
+  default?: unknown;
+  deprecated?: boolean;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  nullable?: boolean;
+  examples?: unknown[];
+  format?: string;
+  contentMediaType?: string;
+  contentEncoding?: string;
+  contentSchema?: JSONSchema$1;
+  _prefault?: unknown;
+};
+type BaseSchema = JSONSchema$1;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/standard-schema.d.cts
+/** The Standard interface. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
 /** The Standard Schema interface. */
 interface StandardSchemaV1$1<Input = unknown, Output = Input> {
   /** The Standard Schema properties. */
@@ -6,15 +101,9 @@ interface StandardSchemaV1$1<Input = unknown, Output = Input> {
 }
 declare namespace StandardSchemaV1$1 {
   /** The Standard Schema properties interface. */
-  interface Props<Input = unknown, Output = Input> {
-    /** The version number of the standard. */
-    readonly version: 1;
-    /** The vendor name of the schema library. */
-    readonly vendor: string;
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
     /** Validates unknown input values. */
-    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-    /** Inferred types associated with the schema. */
-    readonly types?: Types<Input, Output> | undefined;
+    readonly validate: (value: unknown, options?: StandardSchemaV1$1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
   }
   /** The result interface of the validate function. */
   type Result<Output> = SuccessResult<Output> | FailureResult;
@@ -22,9 +111,13 @@ declare namespace StandardSchemaV1$1 {
   interface SuccessResult<Output> {
     /** The typed output value. */
     readonly value: Output;
-    /** The non-existent issues. */
+    /** The absence of issues indicates success. */
     readonly issues?: undefined;
   }
+  interface Options {
+    /** Implicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
   /** The result interface if validation fails. */
   interface FailureResult {
     /** The issues of failed validation. */
@@ -42,26 +135,179 @@ declare namespace StandardSchemaV1$1 {
     /** The key representing a path segment. */
     readonly key: PropertyKey;
   }
-  /** The Standard Schema types interface. */
-  interface Types<Input = unknown, Output = Input> {
-    /** The input type of the schema. */
-    readonly input: Input;
-    /** The output type of the schema. */
-    readonly output: Output;
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard JSON Schema properties. */
+  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardJSONSchemaV1 {
+  /** The Standard JSON Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Methods for generating the input/output JSON Schema. */
+    readonly jsonSchema: Converter;
   }
-  /** Infers the input type of a Standard Schema. */
-  type InferInput<Schema extends StandardSchemaV1$1> = NonNullable<Schema["~standard"]["types"]>["input"];
-  /** Infers the output type of a Standard Schema. */
-  type InferOutput<Schema extends StandardSchemaV1$1> = NonNullable<Schema["~standard"]["types"]>["output"];
+  /** The Standard JSON Schema converter interface. */
+  interface Converter {
+    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+  }
+  /** The target version of the generated JSON Schema.
+   *
+   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use.
+   *
+   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+   *
+   * All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+   */
+  type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+  /** The options for the input/output methods. */
+  interface Options {
+    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+    readonly target: Target;
+    /** Implicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+interface StandardSchemaWithJSONProps<Input = unknown, Output = Input> extends StandardSchemaV1$1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/registries.d.cts
+declare const $output: unique symbol;
+type $output = typeof $output;
+declare const $input: unique symbol;
+type $input = typeof $input;
+type $replace<Meta, S extends $ZodType> = Meta extends $output ? output$1<S> : Meta extends $input ? input$1<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends ((...args: infer P) => infer R) ? (...args: { [K in keyof P]: $replace<P[K], S> }) => $replace<R, S> : Meta extends object ? { [K in keyof Meta]: $replace<Meta[K], S> } : Meta;
+type MetadataType = object | undefined;
+declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
+  _meta: Meta;
+  _schema: Schema;
+  _map: WeakMap<Schema, $replace<Meta, Schema>>;
+  _idmap: Map<string, Schema>;
+  add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;
+  clear(): this;
+  remove(schema: Schema): this;
+  get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
+  has(schema: Schema): boolean;
+}
+interface JSONSchemaMeta {
+  id?: string | undefined;
+  title?: string | undefined;
+  description?: string | undefined;
+  deprecated?: boolean | undefined;
+  [k: string]: unknown;
+}
+interface GlobalMeta extends JSONSchemaMeta {}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/to-json-schema.d.cts
+type Processor<T extends $ZodType = $ZodType> = (schema: T, ctx: ToJSONSchemaContext, json: BaseSchema, params: ProcessParams) => void;
+interface JSONSchemaGeneratorParams {
+  processors: Record<string, Processor>;
+  /** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.
+   *  @default globalRegistry */
+  metadata?: $ZodRegistry<Record<string, any>>;
+  /** The JSON Schema version to target.
+   * - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
+   * - `"draft-07"` — JSON Schema Draft 7
+   * - `"draft-04"` — JSON Schema Draft 4
+   * - `"openapi-3.0"` — OpenAPI 3.0 Schema Object */
+  target?: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string) | undefined;
+  /** How to handle unrepresentable types.
+   * - `"throw"` — Default. Unrepresentable types throw an error
+   * - `"any"` — Unrepresentable types become `{}` */
+  unrepresentable?: "throw" | "any";
+  /** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
+  override?: (ctx: {
+    zodSchema: $ZodTypes;
+    jsonSchema: BaseSchema;
+    path: (string | number)[];
+  }) => void;
+  /** Whether to extract the `"input"` or `"output"` type. Relevant to transforms, defaults, coerced primitives, etc.
+   * - `"output"` — Default. Convert the output schema.
+   * - `"input"` — Convert the input schema. */
+  io?: "input" | "output";
+  cycles?: "ref" | "throw";
+  reused?: "ref" | "inline";
+  external?: {
+    registry: $ZodRegistry<{
+      id?: string | undefined;
+    }>;
+    uri?: ((id: string) => string) | undefined;
+    defs: Record<string, BaseSchema>;
+  } | undefined;
+}
+/**
+ * Parameters for the toJSONSchema function.
+ */
+type ToJSONSchemaParams = Omit<JSONSchemaGeneratorParams, "processors" | "external">;
+interface ProcessParams {
+  schemaPath: $ZodType[];
+  path: (string | number)[];
+}
+interface Seen {
+  /** JSON Schema result for this Zod schema */
+  schema: BaseSchema;
+  /** A cached version of the schema that doesn't get overwritten during ref resolution */
+  def?: BaseSchema;
+  defId?: string | undefined;
+  /** Number of times this schema was encountered during traversal */
+  count: number;
+  /** Cycle path */
+  cycle?: (string | number)[] | undefined;
+  isParent?: boolean | undefined;
+  /** Schema to inherit JSON Schema properties from (set by processor for wrappers) */
+  ref?: $ZodType | null;
+  /** JSON Schema property path for this schema */
+  path?: (string | number)[] | undefined;
+}
+interface ToJSONSchemaContext {
+  processors: Record<string, Processor>;
+  metadataRegistry: $ZodRegistry<Record<string, any>>;
+  target: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string);
+  unrepresentable: "throw" | "any";
+  override: (ctx: {
+    zodSchema: $ZodType;
+    jsonSchema: BaseSchema;
+    path: (string | number)[];
+  }) => void;
+  io: "input" | "output";
+  counter: number;
+  seen: Map<$ZodType, Seen>;
+  cycles: "ref" | "throw";
+  reused: "ref" | "inline";
+  external?: {
+    registry: $ZodRegistry<{
+      id?: string | undefined;
+    }>;
+    uri?: ((id: string) => string) | undefined;
+    defs: Record<string, BaseSchema>;
+  } | undefined;
+}
+type ZodStandardSchemaWithJSON$1<T> = StandardSchemaWithJSONProps<input$1<T>, output$1<T>>;
+interface ZodStandardJSONSchemaPayload<T> extends BaseSchema {
+  "~standard": ZodStandardSchemaWithJSON$1<T>;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/core/util.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/util.d.cts
 type JWTAlgorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | (string & {});
+type MimeTypes = "application/json" | "application/xml" | "application/x-www-form-urlencoded" | "application/javascript" | "application/pdf" | "application/zip" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/octet-stream" | "application/graphql" | "text/html" | "text/plain" | "text/css" | "text/javascript" | "text/csv" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/webp" | "audio/mpeg" | "audio/ogg" | "audio/wav" | "audio/webm" | "video/mp4" | "video/webm" | "video/ogg" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "multipart/form-data" | (string & {});
 type IsAny<T> = 0 extends 1 & T ? true : false;
 type Omit$1<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 type MakePartial<T, K extends keyof T> = Omit$1<T, K> & InexactPartial<Pick<T, K>>;
 type NoUndefined<T> = T extends undefined ? never : T;
-type Whatever = {} | undefined | null;
 type LoosePartial<T extends object> = InexactPartial<T> & {
   [k: string]: unknown;
 };
@@ -76,6 +322,7 @@ type Identity<T> = T;
 type Flatten$1<T> = Identity<{ [k in keyof T]: T[k] }>;
 type Prettify<T> = { [K in keyof T]: T[K] } & {};
 type Extend<A extends SomeObject, B extends SomeObject> = Flatten$1<keyof A & keyof B extends never ? A & B : { [K in keyof A as K extends keyof B ? never : K]: A[K] } & { [K in keyof B]: B[K] }>;
+type TupleItems = ReadonlyArray<SomeType>;
 type AnyFunc = (...args: any[]) => any;
 type MaybeAsync<T> = T | Promise<T>;
 type EnumValue = string | number;
@@ -94,14 +341,14 @@ declare abstract class Class {
   constructor(..._args: any[]);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/core/versions.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/versions.d.cts
 declare const version: {
   readonly major: 4;
-  readonly minor: 0;
+  readonly minor: 3;
   readonly patch: number;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/core/schemas.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/schemas.d.cts
 interface ParseContext$1<T extends $ZodIssueBase = never> {
   /** Customize error messages. */
   readonly error?: $ZodErrorMap<T>;
@@ -113,14 +360,18 @@ interface ParseContext$1<T extends $ZodIssueBase = never> {
 /** @internal */
 interface ParseContextInternal<T extends $ZodIssueBase = never> extends ParseContext$1<T> {
   readonly async?: boolean | undefined;
+  readonly direction?: "forward" | "backward";
+  readonly skipChecks?: boolean;
 }
 interface ParsePayload<T = unknown> {
   value: T;
   issues: $ZodRawIssue[];
+  /** A may to mark a whole payload as aborted. Used in codecs/pipes. */
+  aborted?: boolean;
 }
 type CheckFn<T> = (input: ParsePayload<T>) => MaybeAsync<void>;
 interface $ZodTypeDef {
-  type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "custom";
+  type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "function" | "custom";
   error?: $ZodErrorMap<never> | undefined;
   checks?: $ZodCheck<never>[];
 }
@@ -152,6 +403,7 @@ interface _$ZodTypeInternals {
    * Todo: unions?
    */
   values?: PrimitiveSet | undefined;
+  /** Default value bubbled up from  */
   /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
   propValues?: PropValues | undefined;
   /** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
@@ -162,6 +414,8 @@ interface _$ZodTypeInternals {
   bag: Record<string, unknown>;
   /** @internal The set of issues this schema might throw during type checking. */
   isst: $ZodIssueBase;
+  /** @internal Subject to change, not a public API. */
+  processJSONSchema?: ((ctx: ToJSONSchemaContext, json: BaseSchema, params: ProcessParams) => void) | undefined;
   /** An optional method used to override `toJSONSchema` logic. */
   toJSONSchema?: () => unknown;
   /** @internal The parent of this schema. Only set during certain clone operations. */
@@ -182,6 +436,7 @@ interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals
   _zod: Internals;
   "~standard": $ZodStandardSchema<this>;
 }
+interface _$ZodType<T extends $ZodTypeInternals = $ZodTypeInternals> extends $ZodType<T["output"], T["input"], T> {}
 declare const $ZodType: $constructor<$ZodType>;
 interface $ZodStringDef extends $ZodTypeDef {
   type: "string";
@@ -202,6 +457,8 @@ interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, Input> {
     contentEncoding: string;
   }>;
 }
+interface $ZodString<Input = unknown> extends _$ZodType<$ZodStringInternals<Input>> {}
+declare const $ZodString: $constructor<$ZodString>;
 interface $ZodStringFormatDef<Format extends string = string> extends $ZodStringDef, $ZodCheckStringFormatDef<Format> {}
 interface $ZodStringFormatInternals<Format extends string = string> extends $ZodStringInternals<string>, $ZodCheckStringFormatInternals {
   def: $ZodStringFormatDef<Format>;
@@ -233,6 +490,7 @@ declare const $ZodEmail: $constructor<$ZodEmail>;
 interface $ZodURLDef extends $ZodStringFormatDef<"url"> {
   hostname?: RegExp | undefined;
   protocol?: RegExp | undefined;
+  normalize?: boolean | undefined;
 }
 interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
   def: $ZodURLDef;
@@ -392,6 +650,10 @@ interface $ZodNumberInternals<Input = unknown> extends $ZodTypeInternals<number,
     pattern: RegExp;
   }>;
 }
+interface $ZodNumber<Input = unknown> extends $ZodType {
+  _zod: $ZodNumberInternals<Input>;
+}
+declare const $ZodNumber: $constructor<$ZodNumber>;
 interface $ZodNumberFormatDef extends $ZodNumberDef, $ZodCheckNumberFormatDef {}
 interface $ZodNumberFormatInternals extends $ZodNumberInternals<number>, $ZodCheckNumberFormatInternals {
   def: $ZodNumberFormatDef;
@@ -407,6 +669,53 @@ interface $ZodBooleanInternals<T = unknown> extends $ZodTypeInternals<boolean, T
   def: $ZodBooleanDef;
   isst: $ZodIssueInvalidType;
 }
+interface $ZodBoolean<T = unknown> extends $ZodType {
+  _zod: $ZodBooleanInternals<T>;
+}
+declare const $ZodBoolean: $constructor<$ZodBoolean>;
+interface $ZodBigIntDef extends $ZodTypeDef {
+  type: "bigint";
+  coerce?: boolean;
+}
+interface $ZodBigIntInternals<T = unknown> extends $ZodTypeInternals<bigint, T> {
+  pattern: RegExp;
+  /** @internal Internal API, use with caution */
+  def: $ZodBigIntDef;
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: bigint;
+    maximum: bigint;
+    format: string;
+  }>;
+}
+interface $ZodBigInt<T = unknown> extends $ZodType {
+  _zod: $ZodBigIntInternals<T>;
+}
+declare const $ZodBigInt: $constructor<$ZodBigInt>;
+interface $ZodSymbolDef extends $ZodTypeDef {
+  type: "symbol";
+}
+interface $ZodSymbolInternals extends $ZodTypeInternals<symbol, symbol> {
+  def: $ZodSymbolDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodSymbol extends $ZodType {
+  _zod: $ZodSymbolInternals;
+}
+declare const $ZodSymbol: $constructor<$ZodSymbol>;
+interface $ZodUndefinedDef extends $ZodTypeDef {
+  type: "undefined";
+}
+interface $ZodUndefinedInternals extends $ZodTypeInternals<undefined, undefined> {
+  pattern: RegExp;
+  def: $ZodUndefinedDef;
+  values: PrimitiveSet;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodUndefined extends $ZodType {
+  _zod: $ZodUndefinedInternals;
+}
+declare const $ZodUndefined: $constructor<$ZodUndefined>;
 interface $ZodNullDef extends $ZodTypeDef {
   type: "null";
 }
@@ -416,6 +725,10 @@ interface $ZodNullInternals extends $ZodTypeInternals<null, null> {
   values: PrimitiveSet;
   isst: $ZodIssueInvalidType;
 }
+interface $ZodNull extends $ZodType {
+  _zod: $ZodNullInternals;
+}
+declare const $ZodNull: $constructor<$ZodNull>;
 interface $ZodAnyDef extends $ZodTypeDef {
   type: "any";
 }
@@ -423,6 +736,10 @@ interface $ZodAnyInternals extends $ZodTypeInternals<any, any> {
   def: $ZodAnyDef;
   isst: never;
 }
+interface $ZodAny extends $ZodType {
+  _zod: $ZodAnyInternals;
+}
+declare const $ZodAny: $constructor<$ZodAny>;
 interface $ZodUnknownDef extends $ZodTypeDef {
   type: "unknown";
 }
@@ -430,6 +747,49 @@ interface $ZodUnknownInternals extends $ZodTypeInternals<unknown, unknown> {
   def: $ZodUnknownDef;
   isst: never;
 }
+interface $ZodUnknown extends $ZodType {
+  _zod: $ZodUnknownInternals;
+}
+declare const $ZodUnknown: $constructor<$ZodUnknown>;
+interface $ZodNeverDef extends $ZodTypeDef {
+  type: "never";
+}
+interface $ZodNeverInternals extends $ZodTypeInternals<never, never> {
+  def: $ZodNeverDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodNever extends $ZodType {
+  _zod: $ZodNeverInternals;
+}
+declare const $ZodNever: $constructor<$ZodNever>;
+interface $ZodVoidDef extends $ZodTypeDef {
+  type: "void";
+}
+interface $ZodVoidInternals extends $ZodTypeInternals<void, void> {
+  def: $ZodVoidDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodVoid extends $ZodType {
+  _zod: $ZodVoidInternals;
+}
+declare const $ZodVoid: $constructor<$ZodVoid>;
+interface $ZodDateDef extends $ZodTypeDef {
+  type: "date";
+  coerce?: boolean;
+}
+interface $ZodDateInternals<T = unknown> extends $ZodTypeInternals<Date, T> {
+  def: $ZodDateDef;
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: Date;
+    maximum: Date;
+    format: string;
+  }>;
+}
+interface $ZodDate<T = unknown> extends $ZodType {
+  _zod: $ZodDateInternals<T>;
+}
+declare const $ZodDate: $constructor<$ZodDate>;
 interface $ZodArrayDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "array";
   element: T;
@@ -486,24 +846,25 @@ interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef
   shape: Shape;
   catchall?: $ZodType | undefined;
 }
-interface $ZodObjectInternals< /** @ts-ignore Cast variance */out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
+interface $ZodObjectInternals< /** @ts-ignore Cast variance */out Shape extends $ZodShape = $ZodShape, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
   def: $ZodObjectDef<Shape>;
   config: Config;
   isst: $ZodIssueInvalidType | $ZodIssueUnrecognizedKeys;
   propValues: PropValues;
   output: $InferObjectOutput<Shape, Config["out"]>;
   input: $InferObjectInput<Shape, Config["in"]>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
 }
 type $ZodLooseShape = Record<string, any>;
-interface $ZodObject< /** @ts-ignore Cast variance */out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {
-  "~standard": $ZodStandardSchema<this>;
-}
+interface $ZodObject< /** @ts-ignore Cast variance */out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {}
 declare const $ZodObject: $constructor<$ZodObject>;
 type $InferUnionOutput<T extends SomeType> = T extends any ? output$1<T> : never;
 type $InferUnionInput<T extends SomeType> = T extends any ? input$1<T> : never;
 interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
   type: "union";
   options: Options;
+  inclusive?: boolean;
 }
 type IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;
 type IsOptionalOut<T extends SomeType> = T extends OptionalOutSchema ? true : false;
@@ -521,16 +882,16 @@ interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends
   _zod: $ZodUnionInternals<T>;
 }
 declare const $ZodUnion: $constructor<$ZodUnion>;
-interface $ZodDiscriminatedUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodUnionDef<Options> {
-  discriminator: string;
+interface $ZodDiscriminatedUnionDef<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionDef<Options> {
+  discriminator: Disc;
   unionFallback?: boolean;
 }
-interface $ZodDiscriminatedUnionInternals<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodUnionInternals<Options> {
-  def: $ZodDiscriminatedUnionDef<Options>;
+interface $ZodDiscriminatedUnionInternals<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionInternals<Options> {
+  def: $ZodDiscriminatedUnionDef<Options, Disc>;
   propValues: PropValues;
 }
-interface $ZodDiscriminatedUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType {
-  _zod: $ZodDiscriminatedUnionInternals<T>;
+interface $ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodType {
+  _zod: $ZodDiscriminatedUnionInternals<Options, Disc>;
 }
 declare const $ZodDiscriminatedUnion: $constructor<$ZodDiscriminatedUnion>;
 interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right extends SomeType = $ZodType> extends $ZodTypeDef {
@@ -538,24 +899,49 @@ interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right extends So
   left: Left;
   right: Right;
 }
-interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output$1<A> & output$1<B>, input$1<A> & input$1<B>> {
+interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _$ZodTypeInternals {
   def: $ZodIntersectionDef<A, B>;
   isst: never;
   optin: A["_zod"]["optin"] | B["_zod"]["optin"];
   optout: A["_zod"]["optout"] | B["_zod"]["optout"];
+  output: output$1<A> & output$1<B>;
+  input: input$1<A> & input$1<B>;
 }
 interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
   _zod: $ZodIntersectionInternals<A, B>;
 }
 declare const $ZodIntersection: $constructor<$ZodIntersection>;
-type $ZodRecordKey = $ZodType<string | number | symbol, string | number | symbol>;
+interface $ZodTupleDef<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodTypeDef {
+  type: "tuple";
+  items: T;
+  rest: Rest;
+}
+type $InferTupleInputType<T extends TupleItems, Rest extends SomeType | null> = [...TupleInputTypeWithOptionals<T>, ...(Rest extends SomeType ? input$1<Rest>[] : [])];
+type TupleInputTypeNoOptionals<T extends TupleItems> = { [k in keyof T]: input$1<T[k]> };
+type TupleInputTypeWithOptionals<T extends TupleItems> = T extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optin"] extends "optional" ? [...TupleInputTypeWithOptionals<Prefix>, input$1<Tail>?] : TupleInputTypeNoOptionals<T> : [];
+type $InferTupleOutputType<T extends TupleItems, Rest extends SomeType | null> = [...TupleOutputTypeWithOptionals<T>, ...(Rest extends SomeType ? output$1<Rest>[] : [])];
+type TupleOutputTypeNoOptionals<T extends TupleItems> = { [k in keyof T]: output$1<T[k]> };
+type TupleOutputTypeWithOptionals<T extends TupleItems> = T extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, output$1<Tail>?] : TupleOutputTypeNoOptionals<T> : [];
+interface $ZodTupleInternals<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends _$ZodTypeInternals {
+  def: $ZodTupleDef<T, Rest>;
+  isst: $ZodIssueInvalidType | $ZodIssueTooBig<unknown[]> | $ZodIssueTooSmall<unknown[]>;
+  output: $InferTupleOutputType<T, Rest>;
+  input: $InferTupleInputType<T, Rest>;
+}
+interface $ZodTuple<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodType {
+  _zod: $ZodTupleInternals<T, Rest>;
+}
+declare const $ZodTuple: $constructor<$ZodTuple>;
+type $ZodRecordKey = $ZodType<string | number | symbol, unknown>;
 interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "record";
   keyType: Key;
   valueType: Value;
+  /** @default "strict" - errors on keys not matching keyType. "loose" passes through non-matching keys unchanged. */
+  mode?: "strict" | "loose";
 }
 type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<output$1<Key>, output$1<Value>>> : Record<output$1<Key>, output$1<Value>>;
-type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<input$1<Key>, input$1<Value>>> : Record<input$1<Key>, input$1<Value>>;
+type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<input$1<Key> & PropertyKey, input$1<Value>>> : Record<input$1<Key> & PropertyKey, input$1<Value>>;
 interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
   def: $ZodRecordDef<Key, Value>;
   isst: $ZodIssueInvalidType | $ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
@@ -569,6 +955,35 @@ interface $ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends So
   _zod: $ZodRecordInternals<Key, Value>;
 }
 declare const $ZodRecord: $constructor<$ZodRecord>;
+interface $ZodMapDef<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "map";
+  keyType: Key;
+  valueType: Value;
+}
+interface $ZodMapInternals<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeInternals<Map<output$1<Key>, output$1<Value>>, Map<input$1<Key>, input$1<Value>>> {
+  def: $ZodMapDef<Key, Value>;
+  isst: $ZodIssueInvalidType | $ZodIssueInvalidKey | $ZodIssueInvalidElement<unknown>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+interface $ZodMap<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodMapInternals<Key, Value>;
+}
+declare const $ZodMap: $constructor<$ZodMap>;
+interface $ZodSetDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "set";
+  valueType: T;
+}
+interface $ZodSetInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Set<output$1<T>>, Set<input$1<T>>> {
+  def: $ZodSetDef<T>;
+  isst: $ZodIssueInvalidType;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+interface $ZodSet<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodSetInternals<T>;
+}
+declare const $ZodSet: $constructor<$ZodSet>;
 type $InferEnumOutput<T extends EnumLike> = T[keyof T] & {};
 type $InferEnumInput<T extends EnumLike> = T[keyof T] & {};
 interface $ZodEnumDef<T extends EnumLike = EnumLike> extends $ZodTypeDef {
@@ -601,9 +1016,30 @@ interface $ZodLiteral<T extends Literal = Literal> extends $ZodType {
   _zod: $ZodLiteralInternals<T>;
 }
 declare const $ZodLiteral: $constructor<$ZodLiteral>;
-declare global {
-  interface File {}
+type _File = typeof globalThis extends {
+  File: infer F extends new (...args: any[]) => any;
+} ? InstanceType<F> : {};
+/** Do not reference this directly. */
+interface File extends _File {
+  readonly type: string;
+  readonly size: number;
+}
+interface $ZodFileDef extends $ZodTypeDef {
+  type: "file";
+}
+interface $ZodFileInternals extends $ZodTypeInternals<File, File> {
+  def: $ZodFileDef;
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: number;
+    maximum: number;
+    mime: MimeTypes[];
+  }>;
 }
+interface $ZodFile extends $ZodType {
+  _zod: $ZodFileInternals;
+}
+declare const $ZodFile: $constructor<$ZodFile>;
 interface $ZodTransformDef extends $ZodTypeDef {
   type: "transform";
   transform: (input: unknown, payload: ParsePayload<unknown>) => MaybeAsync<unknown>;
@@ -632,6 +1068,16 @@ interface $ZodOptional<T extends SomeType = $ZodType> extends $ZodType {
   _zod: $ZodOptionalInternals<T>;
 }
 declare const $ZodOptional: $constructor<$ZodOptional>;
+interface $ZodExactOptionalDef<T extends SomeType = $ZodType> extends $ZodOptionalDef<T> {}
+interface $ZodExactOptionalInternals<T extends SomeType = $ZodType> extends $ZodOptionalInternals<T> {
+  def: $ZodExactOptionalDef<T>;
+  output: output$1<T>;
+  input: input$1<T>;
+}
+interface $ZodExactOptional<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodExactOptionalInternals<T>;
+}
+declare const $ZodExactOptional: $constructor<$ZodExactOptional>;
 interface $ZodNullableDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "nullable";
   innerType: T;
@@ -697,6 +1143,20 @@ interface $ZodNonOptional<T extends SomeType = $ZodType> extends $ZodType {
   _zod: $ZodNonOptionalInternals<T>;
 }
 declare const $ZodNonOptional: $constructor<$ZodNonOptional>;
+interface $ZodSuccessDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "success";
+  innerType: T;
+}
+interface $ZodSuccessInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, input$1<T>> {
+  def: $ZodSuccessDef<T>;
+  isst: never;
+  optin: T["_zod"]["optin"];
+  optout: "optional" | undefined;
+}
+interface $ZodSuccess<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodSuccessInternals<T>;
+}
+declare const $ZodSuccess: $constructor<$ZodSuccess>;
 interface $ZodCatchCtx extends ParsePayload {
   /** @deprecated Use `ctx.issues` */
   error: {
@@ -710,7 +1170,7 @@ interface $ZodCatchDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
   innerType: T;
   catchValue: (ctx: $ZodCatchCtx) => unknown;
 }
-interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output$1<T>, input$1<T> | Whatever> {
+interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output$1<T>, input$1<T>> {
   def: $ZodCatchDef<T>;
   optin: T["_zod"]["optin"];
   optout: T["_zod"]["optout"];
@@ -721,10 +1181,25 @@ interface $ZodCatch<T extends SomeType = $ZodType> extends $ZodType {
   _zod: $ZodCatchInternals<T>;
 }
 declare const $ZodCatch: $constructor<$ZodCatch>;
+interface $ZodNaNDef extends $ZodTypeDef {
+  type: "nan";
+}
+interface $ZodNaNInternals extends $ZodTypeInternals<number, number> {
+  def: $ZodNaNDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodNaN extends $ZodType {
+  _zod: $ZodNaNInternals;
+}
+declare const $ZodNaN: $constructor<$ZodNaN>;
 interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "pipe";
   in: A;
   out: B;
+  /** Only defined inside $ZodCodec instances. */
+  transform?: (value: output$1<A>, payload: ParsePayload<output$1<A>>) => MaybeAsync<input$1<B>>;
+  /** Only defined inside $ZodCodec instances. */
+  reverseTransform?: (value: input$1<B>, payload: ParsePayload<input$1<B>>) => MaybeAsync<output$1<A>>;
 }
 interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output$1<B>, input$1<A>> {
   def: $ZodPipeDef<A, B>;
@@ -732,6 +1207,7 @@ interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType =
   values: A["_zod"]["values"];
   optin: A["_zod"]["optin"];
   optout: B["_zod"]["optout"];
+  propValues: A["_zod"]["propValues"];
 }
 interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
   _zod: $ZodPipeInternals<A, B>;
@@ -753,6 +1229,87 @@ interface $ZodReadonly<T extends SomeType = $ZodType> extends $ZodType {
   _zod: $ZodReadonlyInternals<T>;
 }
 declare const $ZodReadonly: $constructor<$ZodReadonly>;
+interface $ZodTemplateLiteralDef extends $ZodTypeDef {
+  type: "template_literal";
+  parts: $ZodTemplateLiteralPart[];
+  format?: string | undefined;
+}
+interface $ZodTemplateLiteralInternals<Template extends string = string> extends $ZodTypeInternals<Template, Template> {
+  pattern: RegExp;
+  def: $ZodTemplateLiteralDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodTemplateLiteral<Template extends string = string> extends $ZodType {
+  _zod: $ZodTemplateLiteralInternals<Template>;
+}
+type LiteralPart = Exclude<Literal, symbol>;
+interface SchemaPartInternals extends $ZodTypeInternals<LiteralPart, LiteralPart> {
+  pattern: RegExp;
+}
+interface SchemaPart extends $ZodType {
+  _zod: SchemaPartInternals;
+}
+type $ZodTemplateLiteralPart = LiteralPart | SchemaPart;
+declare const $ZodTemplateLiteral: $constructor<$ZodTemplateLiteral>;
+type $ZodFunctionArgs = $ZodType<unknown[], unknown[]>;
+type $ZodFunctionIn = $ZodFunctionArgs;
+type $ZodFunctionOut = $ZodType;
+type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output$1<Args>) => input$1<Returns>;
+type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output$1<Args>) => MaybeAsync<input$1<Returns>>;
+type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input$1<Args>) => output$1<Returns>;
+type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input$1<Args>) => Promise<output$1<Returns>>;
+interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodTypeDef {
+  type: "function";
+  input: In;
+  output: Out;
+}
+interface $ZodFunctionInternals<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> extends $ZodTypeInternals<$InferOuterFunctionType<Args, Returns>, $InferInnerFunctionType<Args, Returns>> {
+  def: $ZodFunctionDef<Args, Returns>;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodType<any, any, $ZodFunctionInternals<Args, Returns>> {
+  /** @deprecated */
+  _def: $ZodFunctionDef<Args, Returns>;
+  _input: $InferInnerFunctionType<Args, Returns>;
+  _output: $InferOuterFunctionType<Args, Returns>;
+  implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): (...args: Parameters<this["_output"]>) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]>;
+  implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;
+  input<const Items extends TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest): $ZodFunction<$ZodTuple<Items, Rest>, Returns>;
+  input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
+  input(...args: any[]): $ZodFunction<any, Returns>;
+  output<NewReturns extends $ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
+}
+declare const $ZodFunction: $constructor<$ZodFunction>;
+interface $ZodPromiseDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "promise";
+  innerType: T;
+}
+interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<output$1<T>>, MaybeAsync<input$1<T>>> {
+  def: $ZodPromiseDef<T>;
+  isst: never;
+}
+interface $ZodPromise<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodPromiseInternals<T>;
+}
+declare const $ZodPromise: $constructor<$ZodPromise>;
+interface $ZodLazyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "lazy";
+  getter: () => T;
+}
+interface $ZodLazyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output$1<T>, input$1<T>> {
+  def: $ZodLazyDef<T>;
+  isst: never;
+  /** Auto-cached way to retrieve the inner schema */
+  innerType: T;
+  pattern: T["_zod"]["pattern"];
+  propValues: T["_zod"]["propValues"];
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+}
+interface $ZodLazy<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodLazyInternals<T>;
+}
+declare const $ZodLazy: $constructor<$ZodLazy>;
 interface $ZodCustomDef<O = unknown> extends $ZodTypeDef, $ZodCheckDef {
   type: "custom";
   check: "custom";
@@ -773,8 +1330,9 @@ interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
   _zod: $ZodCustomInternals<O, I>;
 }
 declare const $ZodCustom: $constructor<$ZodCustom>;
+type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodFunction | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile;
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/core/checks.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/checks.d.cts
 interface $ZodCheckDef {
   check: string;
   error?: $ZodErrorMap<never> | undefined;
@@ -956,17 +1514,18 @@ interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
 }
 declare const $ZodCheckEndsWith: $constructor<$ZodCheckEndsWith>;
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/core/errors.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/errors.d.cts
 interface $ZodIssueBase {
   readonly code?: string;
   readonly input?: unknown;
   readonly path: PropertyKey[];
   readonly message: string;
 }
+type $ZodInvalidTypeExpected = "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "undefined" | "null" | "never" | "void" | "date" | "array" | "object" | "tuple" | "record" | "map" | "set" | "file" | "nonoptional" | "nan" | "function" | (string & {});
 interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
   readonly code: "invalid_type";
-  readonly expected: $ZodType["_zod"]["def"]["type"];
-  readonly input: Input;
+  readonly expected: $ZodInvalidTypeExpected;
+  readonly input?: Input;
 }
 interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
   readonly code: "too_big";
@@ -974,7 +1533,7 @@ interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
   readonly maximum: number | bigint;
   readonly inclusive?: boolean;
   readonly exact?: boolean;
-  readonly input: Input;
+  readonly input?: Input;
 }
 interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
   readonly code: "too_small";
@@ -984,59 +1543,70 @@ interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
   readonly inclusive?: boolean;
   /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
   readonly exact?: boolean;
-  readonly input: Input;
+  readonly input?: Input;
 }
 interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
   readonly code: "invalid_format";
   readonly format: $ZodStringFormats | (string & {});
   readonly pattern?: string;
-  readonly input: string;
+  readonly input?: string;
 }
 interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
   readonly code: "not_multiple_of";
   readonly divisor: number;
-  readonly input: Input;
+  readonly input?: Input;
 }
 interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
   readonly code: "unrecognized_keys";
   readonly keys: string[];
-  readonly input: Record<string, unknown>;
+  readonly input?: Record<string, unknown>;
 }
-interface $ZodIssueInvalidUnion extends $ZodIssueBase {
+interface $ZodIssueInvalidUnionNoMatch extends $ZodIssueBase {
   readonly code: "invalid_union";
   readonly errors: $ZodIssue[][];
-  readonly input: unknown;
+  readonly input?: unknown;
+  readonly discriminator?: string | undefined;
+  readonly inclusive?: true;
 }
+interface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {
+  readonly code: "invalid_union";
+  readonly errors: [];
+  readonly input?: unknown;
+  readonly discriminator?: string | undefined;
+  readonly inclusive: false;
+}
+type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
 interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
   readonly code: "invalid_key";
   readonly origin: "map" | "record";
   readonly issues: $ZodIssue[];
-  readonly input: Input;
+  readonly input?: Input;
 }
 interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
   readonly code: "invalid_element";
   readonly origin: "map" | "set";
   readonly key: unknown;
   readonly issues: $ZodIssue[];
-  readonly input: Input;
+  readonly input?: Input;
 }
 interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
   readonly code: "invalid_value";
   readonly values: Primitive$2[];
-  readonly input: Input;
+  readonly input?: Input;
 }
 interface $ZodIssueCustom extends $ZodIssueBase {
   readonly code: "custom";
   readonly params?: Record<string, any> | undefined;
-  readonly input: unknown;
+  readonly input?: unknown;
 }
 type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
-type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
-type RawIssue<T extends $ZodIssueBase> = Flatten$1<MakePartial<T, "message" | "path"> & {
-  /** The input data */readonly input?: unknown; /** The schema or check that originated this issue. */
-  readonly inst?: $ZodType | $ZodCheck; /** @deprecated Internal use only. If `true`, Zod will continue executing validation despite this issue. */
+type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue$1<T> : never;
+type RawIssue$1<T extends $ZodIssueBase> = T extends any ? Flatten$1<MakePartial<T, "message" | "path"> & {
+  /** The input data */readonly input: unknown; /** The schema or check that originated this issue. */
+  readonly inst?: $ZodType | $ZodCheck; /** If `true`, Zod will continue executing checks/refinements after this issue. */
   readonly continue?: boolean | undefined;
-} & Record<string, any>>;
+} & Record<string, unknown>> : never;
+type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
 interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
   (issue: $ZodRawIssue<T>): {
     message: string;
@@ -1065,7 +1635,7 @@ type $ZodFormattedError<T, U = string> = {
   _errors: U[];
 } & Flatten$1<_ZodFormattedError<T, U>>;
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/core/core.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/core.d.cts
 type ZodTrait = {
   _zod: {
     def: any;
@@ -1083,46 +1653,32 @@ declare const $brand: unique symbol;
 type $brand<T extends string | number | symbol = string | number | symbol> = {
   [$brand]: { [k in T]: true };
 };
-type $ZodBranded<T extends SomeType, Brand extends string | number | symbol> = T & Record<"_zod", Record<"output", output$1<T> & $brand<Brand>>>;
+type $ZodBranded<T extends SomeType, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T & (Dir extends "inout" ? {
+  _zod: {
+    input: input$1<T> & $brand<Brand>;
+    output: output$1<T> & $brand<Brand>;
+  };
+} : Dir extends "in" ? {
+  _zod: {
+    input: input$1<T> & $brand<Brand>;
+  };
+} : {
+  _zod: {
+    output: output$1<T> & $brand<Brand>;
+  };
+});
 type input$1<T> = T extends {
   _zod: {
     input: any;
   };
-} ? Required<T["_zod"]>["input"] : unknown;
+} ? T["_zod"]["input"] : unknown;
 type output$1<T> = T extends {
   _zod: {
     output: any;
   };
-} ? Required<T["_zod"]>["output"] : unknown;
+} ? T["_zod"]["output"] : unknown;
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/core/registries.d.cts
-declare const $output: unique symbol;
-type $output = typeof $output;
-declare const $input: unique symbol;
-type $input = typeof $input;
-type $replace<Meta, S extends $ZodType> = Meta extends $output ? output$1<S> : Meta extends $input ? input$1<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends ((...args: infer P) => infer R) ? (...args: { [K in keyof P]: $replace<P[K], S> }) => $replace<R, S> : Meta extends object ? { [K in keyof Meta]: $replace<Meta[K], S> } : Meta;
-type MetadataType = Record<string, unknown> | undefined;
-declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
-  _meta: Meta;
-  _schema: Schema;
-  _map: Map<Schema, $replace<Meta, Schema>>;
-  _idmap: Map<string, Schema>;
-  add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;
-  clear(): this;
-  remove(schema: Schema): this;
-  get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
-  has(schema: Schema): boolean;
-}
-interface JSONSchemaMeta {
-  id?: string | undefined;
-  title?: string | undefined;
-  description?: string | undefined;
-  deprecated?: boolean | undefined;
-  [k: string]: unknown;
-}
-interface GlobalMeta extends JSONSchemaMeta {}
-//#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/core/api.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/api.d.cts
 type Params<T extends $ZodType | $ZodCheck, IssueTypes extends $ZodIssueBase, OmitKeys extends keyof T["_zod"]["def"] = never> = Flatten$1<Partial<EmptyToNever<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
   error?: string | $ZodErrorMap<IssueTypes> | undefined; /** @deprecated This parameter is deprecated. Use `error` instead. */
   message?: string | undefined;
@@ -1134,47 +1690,55 @@ type CheckParams<T extends $ZodCheck = $ZodCheck, // & { _issc: never },
 AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
 type CheckStringFormatParams<T extends $ZodStringFormat = $ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
 type CheckTypeParams<T extends $ZodType & $ZodCheck = $ZodType & $ZodCheck, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
-type $ZodCheckEmailParams = CheckStringFormatParams<$ZodEmail>;
-type $ZodCheckGUIDParams = CheckStringFormatParams<$ZodGUID, "pattern">;
-type $ZodCheckUUIDParams = CheckStringFormatParams<$ZodUUID, "pattern">;
-type $ZodCheckURLParams = CheckStringFormatParams<$ZodURL>;
-type $ZodCheckEmojiParams = CheckStringFormatParams<$ZodEmoji>;
-type $ZodCheckNanoIDParams = CheckStringFormatParams<$ZodNanoID>;
-type $ZodCheckCUIDParams = CheckStringFormatParams<$ZodCUID>;
-type $ZodCheckCUID2Params = CheckStringFormatParams<$ZodCUID2>;
-type $ZodCheckULIDParams = CheckStringFormatParams<$ZodULID>;
-type $ZodCheckXIDParams = CheckStringFormatParams<$ZodXID>;
-type $ZodCheckKSUIDParams = CheckStringFormatParams<$ZodKSUID>;
-type $ZodCheckIPv4Params = CheckStringFormatParams<$ZodIPv4, "pattern">;
-type $ZodCheckIPv6Params = CheckStringFormatParams<$ZodIPv6, "pattern">;
-type $ZodCheckCIDRv4Params = CheckStringFormatParams<$ZodCIDRv4, "pattern">;
-type $ZodCheckCIDRv6Params = CheckStringFormatParams<$ZodCIDRv6, "pattern">;
-type $ZodCheckBase64Params = CheckStringFormatParams<$ZodBase64, "pattern">;
-type $ZodCheckBase64URLParams = CheckStringFormatParams<$ZodBase64URL, "pattern">;
-type $ZodCheckE164Params = CheckStringFormatParams<$ZodE164>;
-type $ZodCheckJWTParams = CheckStringFormatParams<$ZodJWT, "pattern">;
-type $ZodCheckISODateTimeParams = CheckStringFormatParams<$ZodISODateTime, "pattern">;
-type $ZodCheckISODateParams = CheckStringFormatParams<$ZodISODate, "pattern">;
-type $ZodCheckISOTimeParams = CheckStringFormatParams<$ZodISOTime, "pattern">;
-type $ZodCheckISODurationParams = CheckStringFormatParams<$ZodISODuration>;
-type $ZodCheckNumberFormatParams = CheckParams<$ZodCheckNumberFormat, "format">;
-type $ZodCheckLessThanParams = CheckParams<$ZodCheckLessThan, "inclusive" | "value">;
-type $ZodCheckGreaterThanParams = CheckParams<$ZodCheckGreaterThan, "inclusive" | "value">;
-type $ZodCheckMultipleOfParams = CheckParams<$ZodCheckMultipleOf, "value">;
-type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum">;
-type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum">;
-type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length">;
-type $ZodCheckRegexParams = CheckParams<$ZodCheckRegex, "format" | "pattern">;
-type $ZodCheckLowerCaseParams = CheckParams<$ZodCheckLowerCase, "format">;
-type $ZodCheckUpperCaseParams = CheckParams<$ZodCheckUpperCase, "format">;
-type $ZodCheckIncludesParams = CheckParams<$ZodCheckIncludes, "includes" | "format" | "pattern">;
-type $ZodCheckStartsWithParams = CheckParams<$ZodCheckStartsWith, "prefix" | "format" | "pattern">;
-type $ZodCheckEndsWithParams = CheckParams<$ZodCheckEndsWith, "suffix" | "format" | "pattern">;
+type $ZodCheckEmailParams = CheckStringFormatParams<$ZodEmail, "when">;
+type $ZodCheckGUIDParams = CheckStringFormatParams<$ZodGUID, "pattern" | "when">;
+type $ZodCheckUUIDParams = CheckStringFormatParams<$ZodUUID, "pattern" | "when">;
+type $ZodCheckURLParams = CheckStringFormatParams<$ZodURL, "when">;
+type $ZodCheckEmojiParams = CheckStringFormatParams<$ZodEmoji, "when">;
+type $ZodCheckNanoIDParams = CheckStringFormatParams<$ZodNanoID, "when">;
+type $ZodCheckCUIDParams = CheckStringFormatParams<$ZodCUID, "when">;
+type $ZodCheckCUID2Params = CheckStringFormatParams<$ZodCUID2, "when">;
+type $ZodCheckULIDParams = CheckStringFormatParams<$ZodULID, "when">;
+type $ZodCheckXIDParams = CheckStringFormatParams<$ZodXID, "when">;
+type $ZodCheckKSUIDParams = CheckStringFormatParams<$ZodKSUID, "when">;
+type $ZodCheckIPv4Params = CheckStringFormatParams<$ZodIPv4, "pattern" | "when" | "version">;
+type $ZodCheckIPv6Params = CheckStringFormatParams<$ZodIPv6, "pattern" | "when" | "version">;
+type $ZodCheckCIDRv4Params = CheckStringFormatParams<$ZodCIDRv4, "pattern" | "when">;
+type $ZodCheckCIDRv6Params = CheckStringFormatParams<$ZodCIDRv6, "pattern" | "when">;
+type $ZodCheckBase64Params = CheckStringFormatParams<$ZodBase64, "pattern" | "when">;
+type $ZodCheckBase64URLParams = CheckStringFormatParams<$ZodBase64URL, "pattern" | "when">;
+type $ZodCheckE164Params = CheckStringFormatParams<$ZodE164, "when">;
+type $ZodCheckJWTParams = CheckStringFormatParams<$ZodJWT, "pattern" | "when">;
+type $ZodCheckISODateTimeParams = CheckStringFormatParams<$ZodISODateTime, "pattern" | "when">;
+type $ZodCheckISODateParams = CheckStringFormatParams<$ZodISODate, "pattern" | "when">;
+type $ZodCheckISOTimeParams = CheckStringFormatParams<$ZodISOTime, "pattern" | "when">;
+type $ZodCheckISODurationParams = CheckStringFormatParams<$ZodISODuration, "when">;
+type $ZodCheckNumberFormatParams = CheckParams<$ZodCheckNumberFormat, "format" | "when">;
+type $ZodCheckLessThanParams = CheckParams<$ZodCheckLessThan, "inclusive" | "value" | "when">;
+type $ZodCheckGreaterThanParams = CheckParams<$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
+type $ZodCheckMultipleOfParams = CheckParams<$ZodCheckMultipleOf, "value" | "when">;
+type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum" | "when">;
+type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum" | "when">;
+type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length" | "when">;
+type $ZodCheckRegexParams = CheckParams<$ZodCheckRegex, "format" | "pattern" | "when">;
+type $ZodCheckLowerCaseParams = CheckParams<$ZodCheckLowerCase, "format" | "when">;
+type $ZodCheckUpperCaseParams = CheckParams<$ZodCheckUpperCase, "format" | "when">;
+type $ZodCheckIncludesParams = CheckParams<$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
+type $ZodCheckStartsWithParams = CheckParams<$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
+type $ZodCheckEndsWithParams = CheckParams<$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
 type $ZodEnumParams = TypeParams<$ZodEnum, "entries">;
 type $ZodNonOptionalParams = TypeParams<$ZodNonOptional, "innerType">;
 type $ZodCustomParams = CheckTypeParams<$ZodCustom, "fn">;
+type $ZodSuperRefineIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = T extends any ? Flatten$1<MakePartial<T, "message" | "path"> & {
+  /** The schema or check that originated this issue. */readonly inst?: $ZodType | $ZodCheck; /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
+  readonly continue?: boolean | undefined;
+} & Record<string, unknown>> : never;
+interface $RefinementCtx<T = unknown> extends ParsePayload<T> {
+  addIssue(arg: string | $ZodSuperRefineIssue): void;
+}
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/classic/errors.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/errors.d.cts
 /** An Error-like class used to store Zod validation issues.  */
 interface ZodError$1<T = unknown> extends $ZodError<T> {
   /** @deprecated Use the `z.treeifyError(err)` function instead. */
@@ -1192,7 +1756,7 @@ interface ZodError$1<T = unknown> extends $ZodError<T> {
 }
 declare const ZodError$1: $constructor<ZodError$1>;
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/classic/parse.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/parse.d.cts
 type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
 type ZodSafeParseSuccess<T> = {
   success: true;
@@ -1205,10 +1769,8 @@ type ZodSafeParseError<T> = {
   error: ZodError$1<T>;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/classic/schemas.d.cts
-interface RefinementCtx$1<T = unknown> extends ParsePayload<T> {
-  addIssue(arg: string | $ZodRawIssue | Partial<$ZodIssueCustom>): void;
-}
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/schemas.d.cts
+type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<input$1<T>, output$1<T>>;
 interface ZodType$1<out Output = unknown, out Input = unknown, out Internals extends $ZodTypeInternals<Output, Input> = $ZodTypeInternals<Output, Input>> extends $ZodType<Output, Input, Internals> {
   def: Internals["def"];
   type: Internals["def"]["type"];
@@ -1218,33 +1780,45 @@ interface ZodType$1<out Output = unknown, out Input = unknown, out Internals ext
   _output: Internals["output"];
   /** @deprecated Use `z.input<typeof schema>` instead. */
   _input: Internals["input"];
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  /** Converts this schema to a JSON Schema representation. */
+  toJSONSchema(params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<this>;
   check(...checks: (CheckFn<output$1<this>> | $ZodCheck<output$1<this>>)[]): this;
+  with(...checks: (CheckFn<output$1<this>> | $ZodCheck<output$1<this>>)[]): this;
   clone(def?: Internals["def"], params?: {
     parent: boolean;
   }): this;
   register<R extends $ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [$replace<R["_meta"], this>?] : [$replace<R["_meta"], this>] : ["Incompatible schema"]): this;
-  brand<T extends PropertyKey = PropertyKey>(value?: T): PropertyKey extends T ? this : $ZodBranded<this, T>;
+  brand<T extends PropertyKey = PropertyKey, Dir extends "in" | "out" | "inout" = "out">(value?: T): PropertyKey extends T ? this : $ZodBranded<this, T, Dir>;
   parse(data: unknown, params?: ParseContext$1<$ZodIssue>): output$1<this>;
   safeParse(data: unknown, params?: ParseContext$1<$ZodIssue>): ZodSafeParseResult<output$1<this>>;
   parseAsync(data: unknown, params?: ParseContext$1<$ZodIssue>): Promise<output$1<this>>;
   safeParseAsync(data: unknown, params?: ParseContext$1<$ZodIssue>): Promise<ZodSafeParseResult<output$1<this>>>;
   spa: (data: unknown, params?: ParseContext$1<$ZodIssue>) => Promise<ZodSafeParseResult<output$1<this>>>;
-  refine(check: (arg: output$1<this>) => unknown | Promise<unknown>, params?: string | $ZodCustomParams): this;
-  /** @deprecated Use `.check()` instead. */
-  superRefine(refinement: (arg: output$1<this>, ctx: RefinementCtx$1<output$1<this>>) => void | Promise<void>): this;
+  encode(data: output$1<this>, params?: ParseContext$1<$ZodIssue>): input$1<this>;
+  decode(data: input$1<this>, params?: ParseContext$1<$ZodIssue>): output$1<this>;
+  encodeAsync(data: output$1<this>, params?: ParseContext$1<$ZodIssue>): Promise<input$1<this>>;
+  decodeAsync(data: input$1<this>, params?: ParseContext$1<$ZodIssue>): Promise<output$1<this>>;
+  safeEncode(data: output$1<this>, params?: ParseContext$1<$ZodIssue>): ZodSafeParseResult<input$1<this>>;
+  safeDecode(data: input$1<this>, params?: ParseContext$1<$ZodIssue>): ZodSafeParseResult<output$1<this>>;
+  safeEncodeAsync(data: output$1<this>, params?: ParseContext$1<$ZodIssue>): Promise<ZodSafeParseResult<input$1<this>>>;
+  safeDecodeAsync(data: input$1<this>, params?: ParseContext$1<$ZodIssue>): Promise<ZodSafeParseResult<output$1<this>>>;
+  refine<Ch extends (arg: output$1<this>) => unknown | Promise<unknown>>(check: Ch, params?: string | $ZodCustomParams): Ch extends ((arg: any) => arg is infer R) ? this & ZodType$1<R, input$1<this>> : this;
+  superRefine(refinement: (arg: output$1<this>, ctx: $RefinementCtx<output$1<this>>) => void | Promise<void>): this;
   overwrite(fn: (x: output$1<this>) => output$1<this>): this;
   optional(): ZodOptional$1<this>;
+  exactOptional(): ZodExactOptional<this>;
   nonoptional(params?: string | $ZodNonOptionalParams): ZodNonOptional<this>;
   nullable(): ZodNullable$1<this>;
   nullish(): ZodOptional$1<ZodNullable$1<this>>;
-  default(def: output$1<this>): ZodDefault$1<this>;
+  default(def: NoUndefined<output$1<this>>): ZodDefault$1<this>;
   default(def: () => NoUndefined<output$1<this>>): ZodDefault$1<this>;
   prefault(def: () => input$1<this>): ZodPrefault<this>;
   prefault(def: input$1<this>): ZodPrefault<this>;
   array(): ZodArray$1<this>;
   or<T extends SomeType>(option: T): ZodUnion$1<[this, T]>;
   and<T extends SomeType>(incoming: T): ZodIntersection$1<this, T>;
-  transform<NewOut>(transform: (arg: output$1<this>, ctx: RefinementCtx$1<output$1<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, output$1<this>>>;
+  transform<NewOut>(transform: (arg: output$1<this>, ctx: $RefinementCtx<output$1<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, output$1<this>>>;
   catch(def: output$1<this>): ZodCatch$1<this>;
   catch(def: (ctx: $ZodCatchCtx) => output$1<this>): ZodCatch$1<this>;
   pipe<T extends $ZodType<any, output$1<this>>>(target: T | $ZodType<any, output$1<this>>): ZodPipe<this, T>;
@@ -1273,6 +1847,7 @@ interface ZodType$1<out Output = unknown, out Input = unknown, out Internals ext
    * ```
    */
   isNullable(): boolean;
+  apply<T>(fn: (schema: this) => T): T;
 }
 interface _ZodType<out Internals extends $ZodTypeInternals = $ZodTypeInternals> extends ZodType$1<any, any, Internals> {}
 declare const ZodType$1: $constructor<ZodType$1>;
@@ -1281,7 +1856,7 @@ interface _ZodString<T extends $ZodStringInternals<unknown> = $ZodStringInternal
   minLength: number | null;
   maxLength: number | null;
   regex(regex: RegExp, params?: string | $ZodCheckRegexParams): this;
-  includes(value: string, params?: $ZodCheckIncludesParams): this;
+  includes(value: string, params?: string | $ZodCheckIncludesParams): this;
   startsWith(value: string, params?: string | $ZodCheckStartsWithParams): this;
   endsWith(value: string, params?: string | $ZodCheckEndsWithParams): this;
   min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
@@ -1294,6 +1869,7 @@ interface _ZodString<T extends $ZodStringInternals<unknown> = $ZodStringInternal
   normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): this;
   toLowerCase(): this;
   toUpperCase(): this;
+  slugify(): this;
 }
 /** @internal */
 declare const _ZodString: $constructor<_ZodString>;
@@ -1409,9 +1985,12 @@ interface ZodArray$1<T extends SomeType = $ZodType> extends _ZodType<$ZodArrayIn
   max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
   length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
   unwrap(): T;
+  "~standard": ZodStandardSchemaWithJSON<this>;
 }
 declare const ZodArray$1: $constructor<ZodArray$1>;
+type SafeExtendShape<Base extends $ZodShape, Ext extends $ZodLooseShape> = { [K in keyof Ext]: K extends keyof Base ? output$1<Ext[K]> extends output$1<Base[K]> ? input$1<Ext[K]> extends input$1<Base[K]> ? Ext[K] : never : never : Ext[K] };
 interface ZodObject$1< /** @ts-ignore Cast variance */out Shape extends $ZodShape = $ZodLooseShape, out Config extends $ZodObjectConfig = $strip> extends _ZodType<$ZodObjectInternals<Shape, Config>>, $ZodObject<Shape, Config> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
   shape: Shape;
   keyof(): ZodEnum$1<ToEnum<keyof Shape & string>>;
   /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
@@ -1424,45 +2003,43 @@ interface ZodObject$1< /** @ts-ignore Cast variance */out Shape extends $ZodShap
   strict(): ZodObject$1<Shape, $strict>;
   /** This is the default behavior. This method call is likely unnecessary. */
   strip(): ZodObject$1<Shape, $strip>;
-  extend<U extends $ZodLooseShape & Partial<Record<keyof Shape, SomeType>>>(shape: U): ZodObject$1<Extend<Shape, U>, Config>;
+  extend<U extends $ZodLooseShape>(shape: U): ZodObject$1<Extend<Shape, U>, Config>;
+  safeExtend<U extends $ZodLooseShape>(shape: SafeExtendShape<Shape, U> & Partial<Record<keyof Shape, SomeType>>): ZodObject$1<Extend<Shape, U>, Config>;
   /**
-   * @deprecated Use spread syntax and the `.shape` property to combine two object schemas:
-   *
-   * ```ts
-   * const A = z.object({ a: z.string() });
-   * const B = z.object({ b: z.number() });
-   *
-   * const C = z.object({
-   *    ...A.shape,
-   *    ...B.shape
-   * });
-   * ```
+   * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
    */
   merge<U extends ZodObject$1>(other: U): ZodObject$1<Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
-  pick<M extends Mask<keyof Shape>>(mask: M): ZodObject$1<Flatten$1<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
-  omit<M extends Mask<keyof Shape>>(mask: M): ZodObject$1<Flatten$1<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+  pick<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject$1<Flatten$1<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+  omit<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject$1<Flatten$1<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
   partial(): ZodObject$1<{ [k in keyof Shape]: ZodOptional$1<Shape[k]> }, Config>;
-  partial<M extends Mask<keyof Shape>>(mask: M): ZodObject$1<{ [k in keyof Shape]: k extends keyof M ? ZodOptional$1<Shape[k]> : Shape[k] }, Config>;
+  partial<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject$1<{ [k in keyof Shape]: k extends keyof M ? ZodOptional$1<Shape[k]> : Shape[k] }, Config>;
   required(): ZodObject$1<{ [k in keyof Shape]: ZodNonOptional<Shape[k]> }, Config>;
-  required<M extends Mask<keyof Shape>>(mask: M): ZodObject$1<{ [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k]> : Shape[k] }, Config>;
+  required<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject$1<{ [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k]> : Shape[k] }, Config>;
 }
 declare const ZodObject$1: $constructor<ZodObject$1>;
 interface ZodUnion$1<T extends readonly SomeType[] = readonly $ZodType[]> extends _ZodType<$ZodUnionInternals<T>>, $ZodUnion<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
   options: T;
 }
 declare const ZodUnion$1: $constructor<ZodUnion$1>;
-interface ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[]> extends ZodUnion$1<Options>, $ZodDiscriminatedUnion<Options> {
-  _zod: $ZodDiscriminatedUnionInternals<Options>;
+interface ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends ZodUnion$1<Options>, $ZodDiscriminatedUnion<Options, Disc> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  _zod: $ZodDiscriminatedUnionInternals<Options, Disc>;
+  def: $ZodDiscriminatedUnionDef<Options, Disc>;
 }
 declare const ZodDiscriminatedUnion: $constructor<ZodDiscriminatedUnion>;
-interface ZodIntersection$1<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodIntersectionInternals<A, B>>, $ZodIntersection<A, B> {}
+interface ZodIntersection$1<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodIntersectionInternals<A, B>>, $ZodIntersection<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
 declare const ZodIntersection$1: $constructor<ZodIntersection$1>;
 interface ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends _ZodType<$ZodRecordInternals<Key, Value>>, $ZodRecord<Key, Value> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
   keyType: Key;
   valueType: Value;
 }
 declare const ZodRecord: $constructor<ZodRecord>;
 interface ZodEnum$1< /** @ts-ignore Cast variance */out T extends EnumLike = EnumLike> extends _ZodType<$ZodEnumInternals<T>>, $ZodEnum<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
   enum: T;
   options: Array<T[keyof T]>;
   extract<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum$1<Flatten$1<Pick<T, U[number]>>>;
@@ -1470,61 +2047,81 @@ interface ZodEnum$1< /** @ts-ignore Cast variance */out T extends EnumLike = Enu
 }
 declare const ZodEnum$1: $constructor<ZodEnum$1>;
 interface ZodLiteral<T extends Literal = Literal> extends _ZodType<$ZodLiteralInternals<T>>, $ZodLiteral<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
   values: Set<T>;
   /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
   value: T;
 }
 declare const ZodLiteral: $constructor<ZodLiteral>;
-interface ZodTransform<O = unknown, I = unknown> extends _ZodType<$ZodTransformInternals<O, I>>, $ZodTransform<O, I> {}
+interface ZodTransform<O = unknown, I = unknown> extends _ZodType<$ZodTransformInternals<O, I>>, $ZodTransform<O, I> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
 declare const ZodTransform: $constructor<ZodTransform>;
 interface ZodOptional$1<T extends SomeType = $ZodType> extends _ZodType<$ZodOptionalInternals<T>>, $ZodOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
   unwrap(): T;
 }
 declare const ZodOptional$1: $constructor<ZodOptional$1>;
+interface ZodExactOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodExactOptionalInternals<T>>, $ZodExactOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodExactOptional: $constructor<ZodExactOptional>;
 interface ZodNullable$1<T extends SomeType = $ZodType> extends _ZodType<$ZodNullableInternals<T>>, $ZodNullable<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
   unwrap(): T;
 }
 declare const ZodNullable$1: $constructor<ZodNullable$1>;
 interface ZodDefault$1<T extends SomeType = $ZodType> extends _ZodType<$ZodDefaultInternals<T>>, $ZodDefault<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
   unwrap(): T;
   /** @deprecated Use `.unwrap()` instead. */
   removeDefault(): T;
 }
 declare const ZodDefault$1: $constructor<ZodDefault$1>;
 interface ZodPrefault<T extends SomeType = $ZodType> extends _ZodType<$ZodPrefaultInternals<T>>, $ZodPrefault<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
   unwrap(): T;
 }
 declare const ZodPrefault: $constructor<ZodPrefault>;
 interface ZodNonOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodNonOptionalInternals<T>>, $ZodNonOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
   unwrap(): T;
 }
 declare const ZodNonOptional: $constructor<ZodNonOptional>;
 interface ZodCatch$1<T extends SomeType = $ZodType> extends _ZodType<$ZodCatchInternals<T>>, $ZodCatch<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
   unwrap(): T;
   /** @deprecated Use `.unwrap()` instead. */
   removeCatch(): T;
 }
 declare const ZodCatch$1: $constructor<ZodCatch$1>;
 interface ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodPipeInternals<A, B>>, $ZodPipe<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
   in: A;
   out: B;
 }
 declare const ZodPipe: $constructor<ZodPipe>;
-interface ZodReadonly$1<T extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T>>, $ZodReadonly<T> {}
+interface ZodReadonly$1<T extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T>>, $ZodReadonly<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
 declare const ZodReadonly$1: $constructor<ZodReadonly$1>;
-interface ZodCustom<O = unknown, I = unknown> extends _ZodType<$ZodCustomInternals<O, I>>, $ZodCustom<O, I> {}
+interface ZodCustom<O = unknown, I = unknown> extends _ZodType<$ZodCustomInternals<O, I>>, $ZodCustom<O, I> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
 declare const ZodCustom: $constructor<ZodCustom>;
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/classic/iso.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/iso.d.cts
 interface ZodISODateTime extends ZodStringFormat {
   _zod: $ZodISODateTimeInternals;
 }
 declare const ZodISODateTime: $constructor<ZodISODateTime>;
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/typeAliases.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/typeAliases.d.cts
 type Primitive$1 = string | number | symbol | bigint | boolean | null | undefined;
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/util.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/util.d.cts
 declare namespace util {
   type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends (<V>() => V extends U ? 1 : 2) ? true : false;
   export type isAny<T> = 0 extends 1 & T ? true : false;
@@ -1586,28 +2183,28 @@ declare const ZodParsedType: {
 };
 type ZodParsedType = keyof typeof ZodParsedType;
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/ZodError.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/ZodError.d.cts
 type allKeys<T> = T extends any ? keyof T : never;
 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_type: "invalid_type";
+  too_big: "too_big";
+  too_small: "too_small";
+  not_multiple_of: "not_multiple_of";
+  unrecognized_keys: "unrecognized_keys";
   invalid_union: "invalid_union";
+  invalid_literal: "invalid_literal";
   invalid_union_discriminator: "invalid_union_discriminator";
   invalid_enum_value: "invalid_enum_value";
-  unrecognized_keys: "unrecognized_keys";
   invalid_arguments: "invalid_arguments";
   invalid_return_type: "invalid_return_type";
   invalid_date: "invalid_date";
   invalid_string: "invalid_string";
-  too_small: "too_small";
-  too_big: "too_big";
   invalid_intersection_types: "invalid_intersection_types";
-  not_multiple_of: "not_multiple_of";
   not_finite: "not_finite";
 };
 type ZodIssueCode = keyof typeof ZodIssueCode;
@@ -1736,7 +2333,7 @@ type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
   message: string;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/parseUtil.d.cts
 type ParseParams = {
   path: (string | number)[];
   errorMap: ZodErrorMap;
@@ -1794,7 +2391,7 @@ type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
 type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
 type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/enumUtil.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/enumUtil.d.cts
 declare namespace enumUtil {
   type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends ((k: infer Intersection) => void) ? Intersection : never;
   type GetUnionLast<T> = UnionToIntersectionFn<T> extends (() => infer Last) ? Last : never;
@@ -1804,7 +2401,7 @@ declare namespace enumUtil {
   export {};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/errorUtil.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/errorUtil.d.cts
 declare namespace errorUtil {
   type ErrMessage = string | {
     message?: string | undefined;
@@ -1815,12 +2412,12 @@ declare namespace errorUtil {
   const toString: (message?: ErrMessage) => string | undefined;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/partialUtil.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/partialUtil.d.cts
 declare namespace partialUtil {
   type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{ [k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>> }, T["_def"]["unknownKeys"], T["_def"]["catchall"]> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? { [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never } extends infer PI ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/standard-schema.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/standard-schema.d.cts
 /**
  * The Standard Schema interface.
  */
@@ -1924,7 +2521,7 @@ declare namespace StandardSchemaV1 {
   export {};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.d.cts
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/types.d.cts
 interface RefinementCtx {
   addIssue: (arg: IssueData) => void;
   path: (string | number)[];
@@ -2062,7 +2659,10 @@ type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
 } : unknown;
 type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
 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;
+  _cached: {
+    shape: T;
+    keys: string[];
+  } | null;
   _getCached(): {
     shape: T;
     keys: string[];
@@ -2316,7 +2916,7 @@ declare enum ZodFirstPartyTypeKind {
   ZodReadonly = "ZodReadonly"
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.d.ts
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.d.ts
 type AnySchema = ZodTypeAny | $ZodType;
 type AnyObjectSchema = AnyZodObject | $ZodObject | AnySchema;
 type ZodRawShapeCompat = Record<string, AnySchema>;
@@ -2327,7 +2927,7 @@ type SchemaOutput<S> = S extends ZodTypeAny ? TypeOf<S> : S extends $ZodType ? o
  */
 type ShapeOutput<Shape extends ZodRawShapeCompat> = { [K in keyof Shape]: SchemaOutput<Shape[K]> };
 //#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/auth/types.d.ts
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/server/auth/types.d.ts
 /**
  * Information about a validated access token, provided to request handlers.
  */
@@ -2360,7 +2960,7 @@ interface AuthInfo {
   extra?: Record<string, unknown>;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/types.d.ts
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/types.d.ts
 /**
  * Task creation parameters, used to ask that the server create a task to represent a request.
  */
@@ -6058,7 +6658,7 @@ type ServerRequest = Infer<typeof ServerRequestSchema>;
 type ServerNotification = Infer<typeof ServerNotificationSchema>;
 type ServerResult = Infer<typeof ServerResultSchema>;
 //#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/transport.d.ts
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/transport.d.ts
 /**
  * Options for sending a JSON-RPC message.
  */
@@ -6132,7 +6732,7 @@ interface Transport {
   setProtocolVersion?: (version: string) => void;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.d.ts
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.d.ts
 /**
  * Extended handler extra with task store for task creation.
  * @experimental
@@ -6348,7 +6948,7 @@ interface TaskStore {
   }>;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/responseMessage.d.ts
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/responseMessage.d.ts
 /**
  * Base message type
  */
@@ -6390,7 +6990,7 @@ interface ErrorMessage extends BaseResponseMessage {
  */
 type ResponseMessage<T extends Result$1> = TaskStatusMessage | TaskCreatedMessage | ResultMessage<T> | ErrorMessage;
 //#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.d.ts
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.d.ts
 /**
  * Callback for progress notifications.
  */
@@ -7856,7 +8456,7 @@ declare enum TypeName {
   String = "string"
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/types.d.ts
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/types.d.ts
 /**
  * JSON Schema type definition (JSON Schema Draft 2020-12)
  *
@@ -7921,7 +8521,7 @@ interface jsonSchemaValidator {
   getValidator<T>(schema: JsonSchemaType): JsonSchemaValidator<T>;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.d.ts
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.d.ts
 /**
  * Experimental task features for low-level MCP servers.
  *
@@ -8081,7 +8681,7 @@ declare class ExperimentalServerTasks<RequestT extends Request = Request, Notifi
   cancelTask(taskId: string, options?: RequestOptions): Promise<CancelTaskResult>;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.d.ts
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.d.ts
 type ServerOptions = ProtocolOptions & {
   /**
    * Capabilities to advertise as being supported by this server.
@@ -8272,7 +8872,7 @@ declare class Server<RequestT extends Request = Request, NotificationT extends N
   sendPromptListChanged(): Promise<void>;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/uriTemplate.d.ts
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/uriTemplate.d.ts
 type Variables = Record<string, string | string[]>;
 declare class UriTemplate {
   /**
@@ -8298,7 +8898,7 @@ declare class UriTemplate {
   match(uri: string): Variables | null;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.d.ts
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.d.ts
 /**
  * Experimental task features for McpServer.
  *
@@ -8366,7 +8966,7 @@ declare class ExperimentalMcpServerTasks {
   }, handler: ToolTaskHandler<InputArgs>): RegisteredTool;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.d.ts
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.d.ts
 /**
  * High-level MCP server that provides a simpler API for working with resources, tools, and prompts.
  * For advanced usage (like sending notifications or setting custom request handlers), use the underlying