@morlay/ui-conversation-message-actions 0.1.1 → 0.1.3

package/dist/testing.d.mts

@@ -117,17 +117,17 @@ declare const kSchema: unique symbol;
 declare global {
   namespace Schemastery {
     /** Convert primitive constructors, constants, and existing schemas into a schema type. */
-    type From<X> = X extends string | number | boolean ? Schema<X> : X extends Schema<any, any, SchemaMode> ? X : X extends typeof String ? Schema<string> : X extends typeof Number ? Schema<number> : X extends typeof Boolean ? Schema<boolean> : X extends typeof Function ? Schema<Function, (...args: any[]) => any> : X extends Constructor<infer S> ? Schema<S> : never;
-    type TypeS1<X> = X extends Schema<infer S, infer _T, infer _M> ? S : never;
-    type Inverse<X> = X extends Schema<infer _S, infer T, infer M> ? (arg: SchemaOutput<T, M>) => void : never;
+    type From<X> = X extends string | number | boolean ? Schema$1<X> : X extends Schema$1<any, any, SchemaMode> ? X : X extends typeof String ? Schema$1<string> : X extends typeof Number ? Schema$1<number> : X extends typeof Boolean ? Schema$1<boolean> : X extends typeof Function ? Schema$1<Function, (...args: any[]) => any> : X extends Constructor<infer S> ? Schema$1<S> : never;
+    type TypeS1<X> = X extends Schema$1<infer S, infer _T, infer _M> ? S : never;
+    type Inverse<X> = X extends Schema$1<infer _S, infer T, infer M> ? (arg: SchemaOutput<T, M>) => void : never;
     /** Input type accepted by a schema-like value. */
     type TypeS<X> = TypeS1<From<X>>;
     /** Output type returned by a schema-like value after validation. */
     type TypeT<X> = ReturnType<From<X>>;
     /** Resolver callback used by custom schema types registered with `Schema.extend()`. */
-    type Resolve = (data: any, schema: Schema, options: Options, strict?: boolean) => [any, any?];
+    type Resolve = (data: any, schema: Schema$1, options: Options, strict?: boolean) => [any, any?];
     /** Input type accepted by one schema in an intersection. */
-    type IntersectS<X> = From<X> extends Schema<infer S, infer _T, infer _M> ? S : never;
+    type IntersectS<X> = From<X> extends Schema$1<infer S, infer _T, infer _M> ? S : never;
     /** Output type returned by one schema in an intersection. */
     type IntersectT<X> = Inverse<From<X>> extends ((arg: infer T) => void) ? T : never;
     type TupleS<X extends readonly any[]> = X extends readonly [infer L, ...infer R] ? [TypeS<L>?, ...TupleS<R>] : any[];
@@ -137,9 +137,9 @@ declare global {
     type Constructor<T = any> = new (...args: any[]) => T;
     /** Static constructor and factory methods exposed by the default `Schema` export. */
     interface Static {
-      <T = any>(options: Partial<Schema<T>>): Schema<T>;
-      new <T = any>(options: Partial<Schema<T>>): Schema<T>;
-      prototype: Schema;
+      <T = any>(options: Partial<Schema$1<T>>): Schema$1<T>;
+      new <T = any>(options: Partial<Schema$1<T>>): Schema$1<T>;
+      prototype: Schema$1;
       /** Validate a value against a schema node and return `[output, adaptedInput?]`. */
       resolve: Resolve;
       /** Infer a schema from a primitive value, constructor, or existing schema. */
@@ -147,51 +147,51 @@ declare global {
       /** Register a resolver for a custom schema `type`. */
       extend(type: string, resolve: Resolve): void;
       /** Accept any value without validation. */
-      any<T = any>(): Schema<T>;
+      any<T = any>(): Schema$1<T>;
       /** Accept only nullable input. */
-      never(): Schema<never>;
+      never(): Schema$1<never>;
       /** Accept exactly one constant value. */
-      const<const T>(value: T): Schema<T>;
+      const<const T>(value: T): Schema$1<T>;
       /** Accept strings, with optional metadata constraints added by instance methods. */
-      string(): Schema<string>;
+      string(): Schema$1<string>;
       /** Accept numbers, with optional range and step constraints. */
-      number(): Schema<number>;
+      number(): Schema$1<number>;
       /** Accept non-negative integer numbers. */
-      natural(): Schema<number>;
+      natural(): Schema$1<number>;
       /** Accept a number between 0 and 1 and mark it as a slider. */
-      percent(): Schema<number>;
+      percent(): Schema$1<number>;
       /** Accept booleans. */
-      boolean(): Schema<boolean>;
+      boolean(): Schema$1<boolean>;
       /** Accept `Date` instances or parse datetime strings into `Date` objects. */
-      date(): Schema<string | Date, Date>;
+      date(): Schema$1<string | Date, Date>;
       /** Accept `RegExp` instances or parse strings into regular expressions. */
-      regExp(flag?: string): Schema<string | RegExp, RegExp>;
+      regExp(flag?: string): Schema$1<string | RegExp, RegExp>;
       /** Accept binary sources and normalize them to `ArrayBufferLike`. */
-      arrayBuffer(): Schema<Binary.Source, ArrayBufferLike>;
-      arrayBuffer(encoding: 'hex' | 'base64'): Schema<Binary.Source | string, ArrayBufferLike>;
+      arrayBuffer(): Schema$1<Binary.Source, ArrayBufferLike>;
+      arrayBuffer(encoding: 'hex' | 'base64'): Schema$1<Binary.Source | string, ArrayBufferLike>;
       /** Accept a numeric bitset or string keys and normalize to a number. */
-      bitset<K extends string>(bits: Partial<Record<K, number>>): Schema<number | readonly K[], number>;
+      bitset<K extends string>(bits: Partial<Record<K, number>>): Schema$1<number | readonly K[], number>;
       /** Accept functions. */
-      function(): Schema<Function, (...args: any[]) => any>;
+      function(): Schema$1<Function, (...args: any[]) => any>;
       /** Accept instances of a constructor or objects whose constructor name matches. */
-      is(constructor: string): Schema;
-      is<T>(constructor: Constructor<T>): Schema<T>;
+      is(constructor: string): Schema$1;
+      is<T>(constructor: Constructor<T>): Schema$1<T>;
       /** Accept arrays whose elements match `inner`. */
-      array<X>(inner: X): Schema<TypeS<X>[], TypeT<X>[]>;
+      array<X>(inner: X): Schema$1<TypeS<X>[], TypeT<X>[]>;
       /** Accept plain objects with values matching `inner` and optional key schema. */
-      dict<X, Y extends Schema<any, string> = Schema<string>>(inner: X, sKey?: Y): Schema<Dict<TypeS<X>, TypeS<Y>>, Dict<TypeT<X>, TypeT<Y>>>;
+      dict<X, Y extends Schema$1<any, string> = Schema$1<string>>(inner: X, sKey?: Y): Schema$1<Dict<TypeS<X>, TypeS<Y>>, Dict<TypeT<X>, TypeT<Y>>>;
       /** Accept tuple arrays where each index matches the corresponding schema. */
-      tuple<const X extends readonly any[]>(list: X): Schema<TupleS<X>, TupleT<X>>;
+      tuple<const X extends readonly any[]>(list: X): Schema$1<TupleS<X>, TupleT<X>>;
       /** Accept plain objects; infer fields from the dictionary, not the enclosing schema's output type. */
-      object<X extends Dict>(dict: X): Schema<ObjectS<NoInfer<X>>, ObjectT<NoInfer<X>>>;
+      object<X extends Dict>(dict: X): Schema$1<ObjectS<NoInfer<X>>, ObjectT<NoInfer<X>>>;
       /** Accept values matching at least one schema in `list`. */
-      union<const X>(list: readonly X[]): Schema<TypeS<X>, TypeT<X>>;
+      union<const X>(list: readonly X[]): Schema$1<TypeS<X>, TypeT<X>>;
       /** Accept values matching every schema in `list`, merging object outputs. */
-      intersect<const X>(list: readonly X[]): Schema<IntersectS<X>, IntersectT<X>>;
+      intersect<const X>(list: readonly X[]): Schema$1<IntersectS<X>, IntersectT<X>>;
       /** Validate with `inner`, then convert the result with `callback`. */
-      transform<X, T>(inner: X, callback: (value: TypeS<X>, options: Schemastery.Options) => T, preserve?: boolean): Schema<TypeS<X>, T>;
+      transform<X, T>(inner: X, callback: (value: TypeS<X>, options: Schemastery.Options) => T, preserve?: boolean): Schema$1<TypeS<X>, T>;
       /** Defer construction of a recursive schema until validation or serialization. */
-      lazy<X extends Schema<any, any, SchemaMode>>(callback: () => X): X;
+      lazy<X extends Schema$1<any, any, SchemaMode>>(callback: () => X): X;
       ValidationError: typeof ValidationError;
     }
     /** Runtime validation options shared by all schema calls. */
@@ -199,7 +199,7 @@ declare global {
       /** Remove invalid object properties instead of throwing when possible. */
       autofix?: boolean;
       /** Skip validation for selected values and schema nodes. */
-      ignore?(data: any, schema: Schema): boolean;
+      ignore?(data: any, schema: Schema$1): boolean;
       /** Path used to format nested validation errors. */
       path?: (keyof any)[];
     }
@@ -239,69 +239,69 @@ declare global {
     uid: number;
     meta: Schemastery.Meta<T>;
     type: string;
-    sKey?: Schema;
-    inner?: Schema;
-    list?: Schema[];
-    dict?: Dict<Schema>;
+    sKey?: Schema$1;
+    inner?: Schema$1;
+    list?: Schema$1[];
+    dict?: Dict<Schema$1>;
     bits?: Dict<number>;
     callback?: Function;
     constructor?: string | Function;
     builder?: Function;
     value?: T;
-    refs?: Dict<Schema>;
+    refs?: Dict<Schema$1>;
     preserve?: boolean;
     '~standard': StandardSchemaV1$1.Props;
     /** Format this schema as a compact TypeScript-like type string. */
     toString(inline?: boolean): string;
     /** Serialize this schema, preserving shared and recursive references. */
-    toJSON(): Schema<S, T, Mode>;
+    toJSON(): Schema$1<S, T, Mode>;
     /** Mark nullable input as invalid unless a default supplies a fallback. */
-    required<R extends boolean = true>(value?: R): Schema<S, T, SetRequired<Mode, R>>;
+    required<R extends boolean = true>(value?: R): Schema$1<S, T, SetRequired<Mode, R>>;
     /**
      * Parse this config field as a stable reference containing immutable data.
      * @returns a schema whose output supports get(), including when the field is absent.
      */
-    volatile(): Schema<NoInfer<S>, NoInfer<T>, Mode extends 'defined' | 'volatile-defined' ? 'volatile-defined' : 'volatile'>;
+    volatile(): Schema$1<NoInfer<S>, NoInfer<T>, Mode extends 'defined' | 'volatile-defined' ? 'volatile-defined' : 'volatile'>;
     /** Hide this schema node from UI renderers. */
-    hidden(value?: boolean): Schema<S, T, Mode>;
+    hidden(value?: boolean): Schema$1<S, T, Mode>;
     /** Return the default value instead of throwing when validation fails. */
-    loose(value?: boolean): Schema<S, T, Mode>;
+    loose(value?: boolean): Schema$1<S, T, Mode>;
     /** Attach a renderer role and optional role-specific metadata. */
-    role(text: string, extra?: any): Schema<S, T, Mode>;
+    role(text: string, extra?: any): Schema$1<S, T, Mode>;
     /** Attach an external documentation link. */
-    link(link: string): Schema<S, T, Mode>;
+    link(link: string): Schema$1<S, T, Mode>;
     /** Set the fallback value used for nullable input. */
-    default(value: T | NoInfer<Partial<S>>): Schema<S, T, SetRequired<Mode, true>>;
+    default(value: T | NoInfer<Partial<S>>): Schema$1<S, T, SetRequired<Mode, true>>;
     /** Attach an auxiliary comment for documentation or form UIs. */
-    comment(text: string): Schema<S, T, Mode>;
+    comment(text: string): Schema$1<S, T, Mode>;
     /** Attach a localized or plain description for documentation or form UIs. */
-    description(text: string): Schema<S, T, Mode>;
+    description(text: string): Schema$1<S, T, Mode>;
     /** Mark this schema node as disabled for form UIs. */
-    disabled(value?: boolean): Schema<S, T, Mode>;
+    disabled(value?: boolean): Schema$1<S, T, Mode>;
     /** Request collapsed rendering for nested form UIs. */
-    collapse(value?: boolean): Schema<S, T, Mode>;
+    collapse(value?: boolean): Schema$1<S, T, Mode>;
     /** Add a deprecated badge to this schema node. */
-    deprecated(): Schema<S, T, Mode>;
+    deprecated(): Schema$1<S, T, Mode>;
     /** Add an experimental badge to this schema node. */
-    experimental(): Schema<S, T, Mode>;
+    experimental(): Schema$1<S, T, Mode>;
     /** Require strings to match a regular expression. */
-    pattern(regexp: RegExp): Schema<S, T, Mode>;
+    pattern(regexp: RegExp): Schema$1<S, T, Mode>;
     /** Set an inclusive maximum for numbers or collection lengths. */
-    max(value: number): Schema<S, T, Mode>;
+    max(value: number): Schema$1<S, T, Mode>;
     /** Set an inclusive minimum for numbers or collection lengths. */
-    min(value: number): Schema<S, T, Mode>;
+    min(value: number): Schema$1<S, T, Mode>;
     /** Set the numeric increment constraint. */
-    step(value: number): Schema<S, T, Mode>;
+    step(value: number): Schema$1<S, T, Mode>;
     /** Add or replace an object property schema. */
-    set(key: string, value: Schema): Schema<S, T, Mode>;
+    set(key: string, value: Schema$1): Schema$1<S, T, Mode>;
     /** Append a tuple, union, or intersection member schema. */
-    push(value: Schema): Schema<S, T, Mode>;
+    push(value: Schema$1): Schema$1<S, T, Mode>;
     /** Remove values equal to schema defaults from normalized output. */
     simplify(value?: any): any;
     /** Return a schema clone with descriptions merged from locale messages. */
-    i18n(messages: Dict): Schema<S, T, Mode>;
+    i18n(messages: Dict): Schema$1<S, T, Mode>;
     /** Attach arbitrary metadata consumed by form renderers and downstream tools. */
-    extra<K extends keyof Schemastery.Meta>(key: K, value: Schemastery.Meta[K]): Schema<S, T, Mode>;
+    extra<K extends keyof Schemastery.Meta>(key: K, value: Schemastery.Meta[K]): Schema$1<S, T, Mode>;
   }
 }
 declare class ValidationError extends TypeError {
@@ -313,10 +313,12 @@ declare class ValidationError extends TypeError {
 type SchemaMode = 'plain' | 'defined' | 'volatile' | 'volatile-defined';
 type SchemaOutput<T, M extends SchemaMode> = M extends 'volatile' ? Volatile<T | undefined> : M extends 'volatile-defined' ? Volatile<T> : T;
 type SetRequired<M extends SchemaMode, R extends boolean> = M extends 'volatile' | 'volatile-defined' ? R extends true ? 'volatile-defined' : 'volatile' : R extends true ? 'defined' : 'plain';
-type Schema<S = any, T = S, Mode extends SchemaMode = 'plain'> = Schemastery<S, T, Mode>;
-declare const Schema: Schemastery.Static;
-//#endregion
-//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/json-schema.d.cts
+type Schema$1<S = any, T = S, Mode extends SchemaMode = 'plain'> = Schemastery<S, T, Mode>;
+declare const Schema$1: Schemastery.Static;
+declare namespace json_schema_d_exports {
+  export { ArraySchema, BaseSchema, BooleanSchema, IntegerSchema, JSONSchema, NullSchema, NumberSchema, ObjectSchema, Schema, SchemaType, StringSchema, _JSONSchema };
+}
+type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema | IntegerSchema | BooleanSchema | NullSchema;
 type _JSONSchema = boolean | JSONSchema;
 type SchemaType = "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
 type JSONSchema = {
@@ -384,6 +386,27 @@ type JSONSchema = {
   _prefault?: unknown;
 };
 type BaseSchema = JSONSchema;
+interface ObjectSchema extends JSONSchema {
+  type: "object";
+}
+interface ArraySchema extends JSONSchema {
+  type: "array";
+}
+interface StringSchema extends JSONSchema {
+  type: "string";
+}
+interface NumberSchema extends JSONSchema {
+  type: "number";
+}
+interface IntegerSchema extends JSONSchema {
+  type: "integer";
+}
+interface BooleanSchema extends JSONSchema {
+  type: "boolean";
+}
+interface NullSchema extends JSONSchema {
+  type: "null";
+}
 //#endregion
 //#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/standard-schema.d.cts
 /** The Standard interface. */
@@ -503,8 +526,9 @@ declare namespace StandardJSONSchemaV1 {
   type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
 }
 interface StandardSchemaWithJSONProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {}
-//#endregion
-//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/registries.d.cts
+declare namespace registries_d_exports {
+  export { $ZodRegistry, $input, $output, $replace, GlobalMeta, JSONSchemaMeta, globalRegistry, registry };
+}
 declare const $output: unique symbol;
 type $output = typeof $output;
 declare const $input: unique symbol;
@@ -530,6 +554,8 @@ interface JSONSchemaMeta {
   [k: string]: unknown;
 }
 interface GlobalMeta extends JSONSchemaMeta {}
+declare function registry<T extends MetadataType = MetadataType, S extends $ZodType = $ZodType>(): $ZodRegistry<T, S>;
+declare const globalRegistry: $ZodRegistry<GlobalMeta>;
 //#endregion
 //#region ../../../node_modules/.pnpm/zod@4.6.5/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;
@@ -585,6 +611,12 @@ interface JSONSchemaGeneratorParams {
  * Parameters for the toJSONSchema function.
  */
 type ToJSONSchemaParams = Omit<JSONSchemaGeneratorParams, "processors" | "external">;
+/**
+ * Parameters for the toJSONSchema function when passing a registry.
+ */
+interface RegistryToJSONSchemaParams extends ToJSONSchemaParams {
+  uri?: (id: string) => string;
+}
 interface ProcessParams {
   schemaPath: $ZodType[];
   path: (string | number)[];
@@ -648,46 +680,261 @@ interface ToJSONSchemaContext {
     defs: Record<string, BaseSchema>;
   } | undefined;
 }
+declare function initializeContext(params: JSONSchemaGeneratorParams): ToJSONSchemaContext;
+/**
+ * Applies the `unrepresentable` setting at a site that has no JSON Schema equivalent. Throws
+ * `message` unless the setting (or the handler's return value) says otherwise. Returns `true` if a
+ * custom JSON Schema was written into `json`, in which case the caller must not write its own.
+ */
+declare function handleUnrepresentable(schema: $ZodType, ctx: ToJSONSchemaContext, json: BaseSchema, params: ProcessParams, message: string): boolean;
+declare function processSchema<T extends $ZodType>(schema: T, ctx: ToJSONSchemaContext, _params?: ProcessParams): BaseSchema;
+declare function extractDefs<T extends $ZodType>(ctx: ToJSONSchemaContext, schema: T): void;
+declare function finalize<T extends $ZodType>(ctx: ToJSONSchemaContext, schema: T): ZodStandardJSONSchemaPayload<T>;
 type ZodStandardSchemaWithJSON$1<T> = StandardSchemaWithJSONProps<input<T>, output<T>>;
 interface ZodStandardJSONSchemaPayload<T> extends BaseSchema {
   "~standard": ZodStandardSchemaWithJSON$1<T>;
 }
-//#endregion
-//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/util.d.cts
+/**
+ * Creates a toJSONSchema method for a schema instance.
+ * This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
+ */
+declare const createToJSONSchemaMethod: <T extends $ZodType>(schema: T, processors?: Record<string, Processor>) => (params?: ToJSONSchemaParams) => ZodStandardJSONSchemaPayload<T>;
+/**
+ * Creates a toJSONSchema method for a schema instance.
+ * This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
+ */
+type StandardJSONSchemaMethodParams = Parameters<StandardJSONSchemaV1["~standard"]["jsonSchema"]["input"]>[0];
+declare const createStandardJSONSchemaMethod: <T extends $ZodType>(schema: T, io: "input" | "output", processors?: Record<string, Processor>) => (params?: StandardJSONSchemaMethodParams) => BaseSchema;
+declare namespace util_d_exports {
+  export { AnyFunc, AssertEqual, AssertExtends, AssertNotEqual, BIGINT_FORMAT_RANGES, BuiltIn, CONSTANT_CATCH, Class, CleanKey, Constructor$1 as Constructor, EmptyObject, EmptyToNever, EnumLike, EnumValue, Exactly, Extend, ExtractIndexSignature, Flatten, FromCleanMap, HasLength, HasSize, HashAlgorithm, HashEncoding, HashFormat, IPVersion, Identity, InexactPartial, IsAny, IsProp, JSONType, JWTAlgorithm, KeyOf, Keys, KeysArray, KeysEnum, Literal, LiteralArray, LoosePartial, MakePartial, MakeReadonly, MakeRequired, Mapped, Mask, MaybeAsync, MimeTypes, NUMBER_FORMAT_RANGES, NoNever, NoNeverKeys, NoUndefined, Normalize, Numeric, Omit$1 as Omit, OmitIndexSignature, OmitKeys, ParsedTypes, Prettify, Primitive, PrimitiveArray, PrimitiveSet, PropValues, ProtoOf, SafeParseError, SafeParseResult, SafeParseSuccess, SchemaClass, ShapeGetter, SomeObject, ToCleanMap, ToEnum, TupleItems, Whatever, Widen, Writeable, aborted, allowsEval, assert, assertEqual, assertIs, assertNever, assertNotEqual, assignProp, attachSchema, base64ToUint8Array, base64urlToUint8Array, cached, captureStackTrace, cleanEnum, cleanRegex, clone, cloneDef, codePointLength, constantCatch, createTransparentProxy, defineLazy, defineLazyInternal, derived, esc, escapeRegex, explicitlyAborted, extend, finalizeIssue, floatSafeRemainder, getElementAtPath, getEnumValues, getLengthableOrigin, getParsedType, getSizableOrigin, hexToUint8Array, hide, installLazyProp, isObject, isPlainObject, issue, joinValues, jsonStringifyReplacer, members, merge, mergeDefs, normalizeParams, nullish, numKeys, objectClone, omit, optionalKeys, own, parsedType, partial, pick, prefixIssues, primitiveTypes, promiseAllObject, propertyKeyTypes, randomString, rawShape, required, safeExtend, shallowClone, slugify, stringifyPrimitive, toZod, uint8ArrayToBase64, uint8ArrayToBase64url, uint8ArrayToHex, unwrapMessage };
+}
+type JSONType = string | number | boolean | null | JSONType[] | {
+  [key: string]: JSONType;
+};
+type JWTAlgorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | (string & {});
+type HashAlgorithm = "md5" | "sha1" | "sha256" | "sha384" | "sha512";
+type HashEncoding = "hex" | "base64" | "base64url";
+type HashFormat = `${HashAlgorithm}_${HashEncoding}`;
+type IPVersion = "v4" | "v6";
 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 ParsedTypes = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "file" | "date" | "array" | "map" | "set" | "nan" | "null" | "promise";
+type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends (<V>() => V extends U ? 1 : 2) ? true : false;
+type AssertNotEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends (<V>() => V extends U ? 1 : 2) ? false : true;
+type AssertExtends<T, U> = T extends U ? T : never;
+type ToZodMismatch<T, S extends $ZodType> = {
+  "types do not match": {
+    expected: T;
+    received: S["_zod"]["output"];
+  };
+};
+type ToZodKeyMismatch<Expected, Received> = $ZodType & {
+  "types do not match": {
+    expected: Expected;
+    received: Received;
+  };
+};
+declare const toZodDummy: unique symbol;
+type ToZodNormalize<T> = [T] extends [(...args: any[]) => any] ? T : [T] extends [object] ? { [K in keyof T]: ToZodNormalize<T[K]>; } : T | typeof toZodDummy;
+type ToZodEqual<Output, T> = AssertEqual<Output, T> extends true ? true : IsAny<Output> extends true ? false : IsAny<T> extends true ? false : AssertEqual<ToZodNormalize<Output>, ToZodNormalize<T>>;
+type ToZodShape<Shape, T> = { [K in keyof Shape]: Shape[K] extends $ZodType ? K extends keyof T ? ToZodEqual<Shape[K]["_zod"]["output"], T[K]> extends true ? Shape[K] : ToZodKeyMismatch<T[K], Shape[K]["_zod"]["output"]> : ToZodKeyMismatch<never, Shape[K]["_zod"]["output"]> : Shape[K]; } & { [K in Exclude<keyof T, keyof Shape>]: ToZodKeyMismatch<T[K], never>; };
+type ToZodExpand<X> = { [K in keyof X]: X[K]; } & {};
+type ToZodTarget<S extends $ZodType, T> = S extends $ZodObject<infer Shape, infer Config> ? T extends object ? AssertEqual<ToZodExpand<ToZodShape<Shape, T>>, ToZodExpand<Shape>> extends true ? S & ToZodMismatch<T, S> : $ZodObject<ToZodExpand<ToZodShape<Shape, T>>, Config> : S & ToZodMismatch<T, S> : S & ToZodMismatch<T, S>;
 type IsAny<T> = 0 extends 1 & T ? true : false;
 type Omit$1<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
 type MakePartial<T, K extends keyof T> = Omit$1<T, K> & InexactPartial<Pick<T, K>>;
+type MakeRequired<T, K extends keyof T> = Omit$1<T, K> & Required<Pick<T, K>>;
+type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
 type NoUndefined<T> = T extends undefined ? never : T;
+type Whatever = {} | undefined | null;
+type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T;
 type LoosePartial<T extends object> = InexactPartial<T> & {
   [k: string]: unknown;
 };
+type Mask<Keys extends PropertyKey> = { [K in Keys]?: true; };
+type Writeable<T> = { -readonly [P in keyof T]: T[P]; } & {};
 type InexactPartial<T> = { [P in keyof T]?: T[P] | undefined; };
+type EmptyObject = Record<string, never>;
 type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
   readonly [Symbol.toStringTag]: string;
 } | Date | Error | Generator | Promise<unknown> | RegExp;
 type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+type SomeObject = Record<PropertyKey, any>;
 type Identity<T> = T;
 type Flatten<T> = Identity<{ [k in keyof T]: T[k]; }>;
+type Mapped<T> = { [k in keyof T]: T[k]; };
 type Prettify<T> = { [K in keyof T]: T[K]; } & {};
+type NoNeverKeys<T> = { [k in keyof T]: [T[k]] extends [never] ? never : k; }[keyof T];
+type NoNever<T> = Identity<{ [k in NoNeverKeys<T>]: k extends keyof T ? T[k] : never; }>;
+type Extend<A extends SomeObject, B extends SomeObject> = Flatten<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 IsProp<T, K extends keyof T> = T[K] extends AnyFunc ? never : K;
 type MaybeAsync<T> = T | Promise<T>;
+type KeyOf<T> = keyof OmitIndexSignature<T>;
+type OmitIndexSignature<T> = { [K in keyof T as string extends K ? never : K extends string ? K : never]: T[K]; };
+type ExtractIndexSignature<T> = { [K in keyof T as string extends K ? K : K extends string ? never : K]: T[K]; };
+type Keys<T extends object> = keyof OmitIndexSignature<T>;
+type SchemaClass<T extends SomeType> = {
+  new (def: T["_zod"]["def"]): T;
+};
 type EnumValue = string | number;
 type EnumLike = Readonly<Record<string, EnumValue>>;
+type ToEnum<T extends EnumValue> = Flatten<{ [k in T]: k; }>;
+type KeysEnum<T extends object> = ToEnum<Exclude<keyof T, symbol>>;
+type KeysArray<T extends object> = Flatten<(keyof T & string)[]>;
 type Literal = string | number | bigint | boolean | null | undefined;
+type LiteralArray = Array<Literal>;
 type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+type PrimitiveArray = Array<Primitive>;
+type HasSize = {
+  size: number;
+};
 type HasLength = {
   length: number;
 };
+type Numeric = number | bigint | Date;
+type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseError<T>;
+type SafeParseSuccess<T> = {
+  success: true;
+  data: T;
+  error?: never;
+};
+type SafeParseError<T> = {
+  success: false;
+  data?: never;
+  error: $ZodError<T>;
+};
 type PropValues = Record<string, Set<Primitive>>;
 type PrimitiveSet = Set<Primitive>;
+declare function assertEqual<A, B>(val: AssertEqual<A, B>): AssertEqual<A, B>;
+declare function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertNotEqual<A, B>;
+declare function toZod<T>(): <S extends $ZodType>(schema: ToZodEqual<S["_zod"]["output"], T> extends true ? S : ToZodTarget<S, T>) => S;
+declare function assertIs<T>(_arg: T): void;
+declare function assertNever(_x: never): never;
+declare function assert<T>(_: any): asserts _ is T;
+declare function getEnumValues(entries: EnumLike): EnumValue[];
+declare function joinValues<T extends Primitive[]>(array: T, separator?: string): string;
+declare function jsonStringifyReplacer(_: string, value: any): any;
+declare function cached<T>(getter: () => T): {
+  value: T;
+};
+declare function nullish(input: any): boolean;
+declare function cleanRegex(source: string): string;
+declare function floatSafeRemainder(val: number, step: number): number;
+declare function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void;
+declare function objectClone(obj: object): any;
+declare function assignProp<T extends object, K extends PropertyKey>(target: T, prop: K, value: K extends keyof T ? T[K] : any): void;
+/** A def's `shape` accessor, carrying whichever object it currently answers from. */
+interface ShapeGetter {
+  (): Record<PropertyKey, any>;
+  raw: Record<PropertyKey, any>;
+}
+/**
+ * Whichever object a def's `shape` currently answers from: the one the caller passed until the first read, the frozen copy after it.
+ *
+ * Its keys and descriptors read without invoking anything, which is what lets a discriminated union check its discriminator, and the cycle walk read a shape, without resolving a getter that references the schema being constructed. A def that answers `shape` from an accessor of its own has none.
+ */
+declare function rawShape(def: any): Record<PropertyKey, any> | undefined;
+declare function mergeDefs(...defs: Record<string, any>[]): any;
+declare function cloneDef(schema: $ZodType): any;
+declare function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any;
+declare function promiseAllObject<T extends object>(promisesObj: T): Promise<{ [k in keyof T]: Awaited<T[k]>; }>;
+declare function randomString(length?: number): string;
+declare function esc(str: string): string;
+declare function slugify(input: string): string;
+declare const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void;
+declare function isObject(data: any): data is Record<PropertyKey, unknown>;
+declare const allowsEval: {
+  value: boolean;
+};
+declare function isPlainObject(o: any): o is Record<PropertyKey, unknown>;
+declare function shallowClone(o: any): any;
+declare function numKeys(data: any): number;
+declare const getParsedType: (data: any) => ParsedTypes;
+declare const propertyKeyTypes: Set<string>;
+declare const primitiveTypes: Set<string>;
+declare function escapeRegex(str: string): string;
+declare function clone<T extends $ZodType>(inst: T, def?: T["_zod"]["def"], params?: {
+  parent: boolean;
+}): T;
 type EmptyToNever<T> = keyof T extends never ? never : T;
+type Normalize<T> = T extends undefined ? never : T extends Record<any, any> ? Flatten<{ [k in keyof Omit$1<T, "error" | "message">]: T[k]; } & ("error" extends keyof T ? {
+  error?: Exclude<T["error"], string>;
+} : unknown)> : never;
+declare function normalizeParams<T>(_params: T): Normalize<T>;
+declare function createTransparentProxy<T extends object>(getter: () => T): T;
+declare function stringifyPrimitive(value: any): string;
+declare function optionalKeys(shape: $ZodShape): string[];
+type CleanKey<T extends PropertyKey> = T extends `?${infer K}` ? K : T extends `${infer K}?` ? K : T;
+type ToCleanMap<T extends $ZodLooseShape> = { [k in keyof T]: k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k; };
+type FromCleanMap<T extends $ZodLooseShape> = { [k in keyof T as k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k]: k; };
+declare const NUMBER_FORMAT_RANGES: Record<$ZodNumberFormats, [number, number]>;
+declare const BIGINT_FORMAT_RANGES: Record<$ZodBigIntFormats, [bigint, bigint]>;
+declare function pick(schema: $ZodObject, mask: Record<string, unknown>): any;
+declare function omit(schema: $ZodObject, mask: object): any;
+declare function extend(schema: $ZodObject, shape: $ZodShape): any;
+declare function safeExtend(schema: $ZodObject, shape: $ZodShape): any;
+declare function merge(a: $ZodObject, b: $ZodObject): any;
+declare function partial(Class: SchemaClass<$ZodOptional> | null, schema: $ZodObject, mask: object | undefined, name?: string): any;
+declare function required(Class: SchemaClass<$ZodNonOptional>, schema: $ZodObject, mask: object | undefined): any;
+type Constructor$1<T, Def extends any[] = any[]> = new (...args: Def) => T;
+declare function aborted(x: ParsePayload, startIndex?: number): boolean;
+declare function explicitlyAborted(x: ParsePayload, startIndex?: number): boolean;
+declare function prefixIssues(path: PropertyKey, issues: $ZodRawIssue[]): $ZodRawIssue[];
+declare function unwrapMessage(message: string | {
+  message: string;
+} | undefined | null): string | undefined;
+declare function attachSchema(issues: $ZodRawIssue[], start: number, inst: $ZodType): void;
+declare function finalizeIssue(iss: $ZodRawIssue, ctx: ParseContextInternal | undefined, config: $ZodConfig): $ZodIssue;
+declare function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown";
+declare function codePointLength(str: string): number;
+declare function getLengthableOrigin(input: any): "array" | "string" | "unknown";
+declare function parsedType(data: unknown): $ZodInvalidTypeExpected;
+declare function issue(_iss: string, input: any, inst: any): $ZodRawIssue;
+declare function issue(_iss: $ZodRawIssue): $ZodRawIssue;
+declare function cleanEnum(obj: Record<string, EnumValue>): EnumValue[];
+declare function base64ToUint8Array(base64: string): InstanceType<typeof Uint8Array>;
+declare function uint8ArrayToBase64(bytes: Uint8Array): string;
+declare function base64urlToUint8Array(base64url: string): InstanceType<typeof Uint8Array>;
+declare function uint8ArrayToBase64url(bytes: Uint8Array): string;
+declare function hexToUint8Array(hex: string): InstanceType<typeof Uint8Array>;
+declare function uint8ArrayToHex(bytes: Uint8Array): string;
 declare abstract class Class {
   constructor(..._args: any[]);
 }
+/**
+ * Installs a trait's members on its prototype. Each value builds that member for the instance on first read; the built value shadows the accessor as an own property, so a detached `const { parse } = schema` keeps working.
+ *
+ * Call this from a `proto` initializer, which runs once per prototype — never per instance.
+ */
+declare function members(proto: object, table: object): void;
+/** Shadows a prototype member with an own value, so a getter that builds from the instance runs once. */
+declare function own<T>(inst: object, key: PropertyKey, value: T, enumerable?: boolean): T;
+/** Like {@link own}, for a member that was never an own data property and has to stay out of `Object.keys`. */
+declare function hide<T>(inst: object, key: PropertyKey, value: T): T;
+/** Adds members a table derives from the instance: each builds on first read and shadows as own data, and assignment shadows the same way, as when these were own properties. */
+declare function derived<T>(computes: { [K in keyof T]?: (inst: T) => T[K]; }, table: ProtoOf<T>): ProtoOf<T>;
 /** A trait's prototype members: a partial view of its own interface, with `this` typed as the instance. */
 type ProtoOf<T> = { [K in keyof T]?: (T[K] extends ((...args: infer A) => infer R) ? (...args: A) => R : T[K]) | undefined; } & ThisType<T>;
+/**
+ * Installs a lazily-derived internal on the `_zod` prototype of `inst`'s
+ * constructor, computed from the internals object itself and cached there on
+ * first read. One accessor per constructor rather than one per instance.
+ */
+declare function defineLazyInternal<T extends {
+  _zod: any;
+}>(inst: T, key: string, compute: (zod: T["_zod"]) => unknown): void;
+/**
+ * Installs `key` on `inst`'s prototype, computed by `make` on first read and cached there as an own
+ * data property. One accessor per constructor rather than one per instance, because an own accessor
+ * puts every instance after the first into v8 dictionary mode. The key doubles as the sentinel.
+ */
+declare function installLazyProp(inst: object, key: string, make: (self: any) => unknown, enumerable: boolean): void;
+/** Marks the thunk `_catch` synthesises for a constant catch value. `Function.length` cannot tell that thunk from a user callback — rest and defaulted parameters both report arity 0 — and a user callback reads `ctx.error`, whose issues only finalize correctly against the caller's per-parse error map. Provenance can say what arity cannot. A plain string key rather than `Symbol.for`, whose call at module scope no bundler can prove pure — the same shape that anchored `urlCanParse` into every build. */
+declare const CONSTANT_CATCH = "~constantCatch";
+/** Wraps a constant catch value in a thunk tagged with {@link CONSTANT_CATCH}. */
+declare function constantCatch<T>(value: T): () => T;
 //#endregion
 //#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/versions.d.cts
 declare const version: {
@@ -695,8 +942,9 @@ declare const version: {
   readonly minor: 6;
   readonly patch: number;
 };
-//#endregion
-//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/schemas.d.cts
+declare namespace schemas_d_exports {
+  export { $DiscriminatedOption, $DiscriminatorValue, $InferEnumInput, $InferEnumOutput, $InferInnerFunctionType, $InferInnerFunctionTypeAsync, $InferObjectInput, $InferObjectOutput, $InferOuterFunctionType, $InferOuterFunctionTypeAsync, $InferTupleInputType, $InferTupleOutputType, $InferUnionInput, $InferUnionOutput, $InferZodRecordInput, $InferZodRecordOutput, $PartsToTemplateLiteral, $ZodAny, $ZodAnyDef, $ZodAnyInternals, $ZodArray, $ZodArrayDef, $ZodArrayInternals, $ZodBase64, $ZodBase64Def, $ZodBase64Internals, $ZodBase64URL, $ZodBase64URLDef, $ZodBase64URLInternals, $ZodBigInt, $ZodBigIntDef, $ZodBigIntFormat, $ZodBigIntFormatDef, $ZodBigIntFormatInternals, $ZodBigIntInternals, $ZodBoolean, $ZodBooleanDef, $ZodBooleanInternals, $ZodCIDRv4, $ZodCIDRv4Def, $ZodCIDRv4Internals, $ZodCIDRv6, $ZodCIDRv6Def, $ZodCIDRv6Internals, $ZodCUID, $ZodCUID2, $ZodCUID2Def, $ZodCUID2Internals, $ZodCUIDDef, $ZodCUIDInternals, $ZodCatch, $ZodCatchCtx, $ZodCatchDef, $ZodCatchInternals, $ZodCodec, $ZodCodecDef, $ZodCodecInternals, $ZodCreditCard, $ZodCreditCardDef, $ZodCreditCardInternals, $ZodCustom, $ZodCustomDef, $ZodCustomInternals, $ZodCustomStringFormat, $ZodCustomStringFormatDef, $ZodCustomStringFormatInternals, $ZodDate, $ZodDateDef, $ZodDateInternals, $ZodDefault, $ZodDefaultDef, $ZodDefaultInternals, $ZodDiscriminatedUnion, $ZodDiscriminatedUnionDef, $ZodDiscriminatedUnionInternals, $ZodE164, $ZodE164Def, $ZodE164Internals, $ZodEmail, $ZodEmailDef, $ZodEmailInternals, $ZodEmoji, $ZodEmojiDef, $ZodEmojiInternals, $ZodEnum, $ZodEnumDef, $ZodEnumInternals, $ZodExactOptional, $ZodExactOptionalDef, $ZodExactOptionalInternals, $ZodFile, $ZodFileDef, $ZodFileInternals, $ZodFunction, $ZodFunctionArgs, $ZodFunctionDef, $ZodFunctionIn, $ZodFunctionInternals, $ZodFunctionOut, $ZodFunctionParams, $ZodGUID, $ZodGUIDDef, $ZodGUIDInternals, $ZodIBAN, $ZodIBANDef, $ZodIBANInternals, $ZodIPv4, $ZodIPv4Def, $ZodIPv4Internals, $ZodIPv6, $ZodIPv6Def, $ZodIPv6Internals, $ZodISODate, $ZodISODateDef, $ZodISODateInternals, $ZodISODateTime, $ZodISODateTimeDef, $ZodISODateTimeInternals, $ZodISODuration, $ZodISODurationDef, $ZodISODurationInternals, $ZodISOTime, $ZodISOTimeDef, $ZodISOTimeInternals, $ZodIntersection, $ZodIntersectionDef, $ZodIntersectionInternals, $ZodJWT, $ZodJWTDef, $ZodJWTInternals, $ZodKSUID, $ZodKSUIDDef, $ZodKSUIDInternals, $ZodLazy, $ZodLazyDef, $ZodLazyInternals, $ZodLiteral, $ZodLiteralDef, $ZodLiteralInternals, $ZodLooseShape, $ZodMAC, $ZodMACDef, $ZodMACInternals, $ZodMap, $ZodMapDef, $ZodMapInternals, $ZodMemoizer, $ZodNaN, $ZodNaNDef, $ZodNaNInternals, $ZodNanoID, $ZodNanoIDDef, $ZodNanoIDInternals, $ZodNever, $ZodNeverDef, $ZodNeverInternals, $ZodNonOptional, $ZodNonOptionalDef, $ZodNonOptionalInternals, $ZodNull, $ZodNullDef, $ZodNullInternals, $ZodNullable, $ZodNullableDef, $ZodNullableInternals, $ZodNumber, $ZodNumberDef, $ZodNumberFormat, $ZodNumberFormatDef, $ZodNumberFormatInternals, $ZodNumberInternals, $ZodObject, $ZodObjectConfig, $ZodObjectDef, $ZodObjectInternals, $ZodObjectJIT, $ZodOptional, $ZodOptionalDef, $ZodOptionalInternals, $ZodPipe, $ZodPipeDef, $ZodPipeInternals, $ZodPrefault, $ZodPrefaultDef, $ZodPrefaultInternals, $ZodPreprocess, $ZodPreprocessDef, $ZodPreprocessInternals, $ZodPromise, $ZodPromiseDef, $ZodPromiseInternals, $ZodReadonly, $ZodReadonlyDef, $ZodReadonlyInternals, $ZodRecord, $ZodRecordDef, $ZodRecordInternals, $ZodRecordKey, $ZodSet, $ZodSetDef, $ZodSetInternals, $ZodShape, $ZodStandardSchema, $ZodString, $ZodStringDef, $ZodStringFormat, $ZodStringFormatDef, $ZodStringFormatInternals, $ZodStringFormatTypes, $ZodStringInternals, $ZodSuccess, $ZodSuccessDef, $ZodSuccessInternals, $ZodSymbol, $ZodSymbolDef, $ZodSymbolInternals, $ZodTemplateLiteral, $ZodTemplateLiteralDef, $ZodTemplateLiteralInternals, $ZodTemplateLiteralPart, $ZodTransform, $ZodTransformDef, $ZodTransformInternals, $ZodTuple, $ZodTupleDef, $ZodTupleInternals, $ZodType, $ZodTypeDef, $ZodTypeInternals, $ZodTypes, $ZodULID, $ZodULIDDef, $ZodULIDInternals, $ZodURL, $ZodURLDef, $ZodURLInternals, $ZodUUID, $ZodUUIDDef, $ZodUUIDInternals, $ZodUndefined, $ZodUndefinedDef, $ZodUndefinedInternals, $ZodUnion, $ZodUnionDef, $ZodUnionInternals, $ZodUnknown, $ZodUnknownDef, $ZodUnknownInternals, $ZodVoid, $ZodVoidDef, $ZodVoidInternals, $ZodXID, $ZodXIDDef, $ZodXIDInternals, $ZodXor, $ZodXorInternals, $catchall, $loose, $partial, $strict, $strip, CheckFn, ConcatenateTupleOfStrings, ConvertPartsToStringTuple, File, ParseContext, ParseContextInternal, ParsePayload, SomeType, ToTemplateLiteral, URL_BAD_FORMAT, URL_UNPARSEABLE, _$ZodType, _$ZodTypeInternals, base64Charset, base64urlCharset, canParseURL, clone, getDiscriminatedOption, isValidBase64, isValidBase64URL, isValidCIDRv6, isValidCreditCard, isValidIBAN, isValidIPv6, isValidJWT, mergeValues, parseURLObject, standardProps, stripTabAndNewline, urlHostnameOk, urlProtocolOk, validateURL };
+}
 interface ParseContext<T extends $ZodIssueBase = never> {
   /** Customize error messages. */
   readonly error?: $ZodErrorMap<T>;
@@ -713,6 +961,12 @@ interface ParseContextInternal<T extends $ZodIssueBase = never> extends ParseCon
   /** Set only by `validate`/`validateAsync`. A container may stop before its next child, never inside one, so a map entry and a tuple's fixed items parse whole. */
   readonly abortEarly?: boolean;
 }
+/** Gives a container cycle support: `attach` wraps its parse, and `alloc` registers the object it builds into before any child is parsed so a reference back to the same input resolves to it. */
+interface $ZodMemoizer {
+  attach(inst: $ZodType): void;
+  guard(inst: $ZodType): void;
+  alloc<T extends object>(inst: $ZodType, payload: ParsePayload, empty: T, ctx: ParseContextInternal): T;
+}
 interface ParsePayload<T = unknown> {
   value: T;
   issues: $ZodRawIssue[];
@@ -796,6 +1050,7 @@ interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals
 }
 interface _$ZodType<T extends $ZodTypeInternals = $ZodTypeInternals> extends $ZodType<T["output"], T["input"], T> {}
 declare const $ZodType: $constructor<$ZodType>;
+declare function standardProps(inst: $ZodType): StandardSchemaV1.Props<any, any>;
 interface $ZodStringDef extends $ZodTypeDef {
   type: "string";
   coerce?: boolean;
@@ -819,6 +1074,273 @@ interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, Input> {
 }
 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>;
+}
+interface $ZodStringFormat<Format extends string = string> extends $ZodType {
+  _zod: $ZodStringFormatInternals<Format>;
+}
+declare const $ZodStringFormat: $constructor<$ZodStringFormat>;
+interface $ZodGUIDDef extends $ZodStringFormatDef<"guid"> {}
+interface $ZodGUIDInternals extends $ZodStringFormatInternals<"guid"> {}
+interface $ZodGUID extends $ZodType {
+  _zod: $ZodGUIDInternals;
+}
+declare const $ZodGUID: $constructor<$ZodGUID>;
+interface $ZodUUIDDef extends $ZodStringFormatDef<"uuid"> {
+  version?: "v1" | "v2" | "v3" | "v4" | "v5" | "v6" | "v7" | "v8";
+}
+interface $ZodUUIDInternals extends $ZodStringFormatInternals<"uuid"> {
+  def: $ZodUUIDDef;
+}
+interface $ZodUUID extends $ZodType {
+  _zod: $ZodUUIDInternals;
+}
+declare const $ZodUUID: $constructor<$ZodUUID>;
+interface $ZodEmailDef extends $ZodStringFormatDef<"email"> {}
+interface $ZodEmailInternals extends $ZodStringFormatInternals<"email"> {}
+interface $ZodEmail extends $ZodType {
+  _zod: $ZodEmailInternals;
+}
+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;
+}
+interface $ZodURL extends $ZodType {
+  _zod: $ZodURLInternals;
+}
+/** The `://` guard rejected the input before the URL constructor saw it. */
+declare const URL_BAD_FORMAT = 1;
+/** The URL parser rejected the input. */
+declare const URL_UNPARSEABLE = 2;
+declare function canParseURL(input: string): boolean;
+declare function validateURL(trimmed: string, def: Pick<$ZodURLDef, "protocol" | "hostname" | "normalize">): URL | true | typeof URL_BAD_FORMAT | typeof URL_UNPARSEABLE;
+/** Parses a URL while preserving the non-normalizing HTTP guard. */
+declare function parseURLObject(trimmed: string, def: Pick<$ZodURLDef, "protocol" | "normalize">): URL | typeof URL_BAD_FORMAT | typeof URL_UNPARSEABLE;
+/** The URL parser deletes every ASCII tab, LF and CR from its input before it parses, so `new URL("https://exa\nmple.com")` reports on `example.com`. Applying the same deletion to the returned value closes the half of that divergence which can move the host; the parser's other rewrite, stripping C0 controls at the edges, cannot. */
+declare function stripTabAndNewline(value: string): string;
+declare function urlHostnameOk(url: URL, hostname: RegExp): boolean;
+declare function urlProtocolOk(url: URL, protocol: RegExp): boolean;
+declare const $ZodURL: $constructor<$ZodURL>;
+interface $ZodEmojiDef extends $ZodStringFormatDef<"emoji"> {}
+interface $ZodEmojiInternals extends $ZodStringFormatInternals<"emoji"> {}
+interface $ZodEmoji extends $ZodType {
+  _zod: $ZodEmojiInternals;
+}
+declare const $ZodEmoji: $constructor<$ZodEmoji>;
+interface $ZodNanoIDDef extends $ZodStringFormatDef<"nanoid"> {
+  length?: number | undefined;
+}
+interface $ZodNanoIDInternals extends $ZodStringFormatInternals<"nanoid"> {
+  def: $ZodNanoIDDef;
+}
+interface $ZodNanoID extends $ZodType {
+  _zod: $ZodNanoIDInternals;
+}
+declare const $ZodNanoID: $constructor<$ZodNanoID>;
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+interface $ZodCUIDDef extends $ZodStringFormatDef<"cuid"> {}
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+interface $ZodCUIDInternals extends $ZodStringFormatInternals<"cuid"> {}
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+interface $ZodCUID extends $ZodType {
+  _zod: $ZodCUIDInternals;
+}
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+declare const $ZodCUID: $constructor<$ZodCUID>;
+interface $ZodCUID2Def extends $ZodStringFormatDef<"cuid2"> {}
+interface $ZodCUID2Internals extends $ZodStringFormatInternals<"cuid2"> {}
+interface $ZodCUID2 extends $ZodType {
+  _zod: $ZodCUID2Internals;
+}
+declare const $ZodCUID2: $constructor<$ZodCUID2>;
+interface $ZodULIDDef extends $ZodStringFormatDef<"ulid"> {}
+interface $ZodULIDInternals extends $ZodStringFormatInternals<"ulid"> {}
+interface $ZodULID extends $ZodType {
+  _zod: $ZodULIDInternals;
+}
+declare const $ZodULID: $constructor<$ZodULID>;
+interface $ZodXIDDef extends $ZodStringFormatDef<"xid"> {}
+interface $ZodXIDInternals extends $ZodStringFormatInternals<"xid"> {}
+interface $ZodXID extends $ZodType {
+  _zod: $ZodXIDInternals;
+}
+declare const $ZodXID: $constructor<$ZodXID>;
+interface $ZodKSUIDDef extends $ZodStringFormatDef<"ksuid"> {}
+interface $ZodKSUIDInternals extends $ZodStringFormatInternals<"ksuid"> {}
+interface $ZodKSUID extends $ZodType {
+  _zod: $ZodKSUIDInternals;
+}
+declare const $ZodKSUID: $constructor<$ZodKSUID>;
+interface $ZodISODateTimeDef extends $ZodStringFormatDef<"datetime"> {
+  precision: number | null;
+  offset: boolean;
+  local: boolean;
+}
+interface $ZodISODateTimeInternals extends $ZodStringFormatInternals {
+  def: $ZodISODateTimeDef;
+}
+interface $ZodISODateTime extends $ZodType {
+  _zod: $ZodISODateTimeInternals;
+}
+declare const $ZodISODateTime: $constructor<$ZodISODateTime>;
+interface $ZodISODateDef extends $ZodStringFormatDef<"date"> {}
+interface $ZodISODateInternals extends $ZodStringFormatInternals<"date"> {}
+interface $ZodISODate extends $ZodType {
+  _zod: $ZodISODateInternals;
+}
+declare const $ZodISODate: $constructor<$ZodISODate>;
+interface $ZodISOTimeDef extends $ZodStringFormatDef<"time"> {
+  precision?: number | null;
+}
+interface $ZodISOTimeInternals extends $ZodStringFormatInternals<"time"> {
+  def: $ZodISOTimeDef;
+}
+interface $ZodISOTime extends $ZodType {
+  _zod: $ZodISOTimeInternals;
+}
+declare const $ZodISOTime: $constructor<$ZodISOTime>;
+interface $ZodISODurationDef extends $ZodStringFormatDef<"duration"> {}
+interface $ZodISODurationInternals extends $ZodStringFormatInternals<"duration"> {}
+interface $ZodISODuration extends $ZodType {
+  _zod: $ZodISODurationInternals;
+}
+declare const $ZodISODuration: $constructor<$ZodISODuration>;
+interface $ZodIPv4Def extends $ZodStringFormatDef<"ipv4"> {
+  version?: "v4";
+}
+interface $ZodIPv4Internals extends $ZodStringFormatInternals<"ipv4"> {
+  def: $ZodIPv4Def;
+}
+interface $ZodIPv4 extends $ZodType {
+  _zod: $ZodIPv4Internals;
+}
+declare const $ZodIPv4: $constructor<$ZodIPv4>;
+interface $ZodIPv6Def extends $ZodStringFormatDef<"ipv6"> {
+  version?: "v6";
+}
+interface $ZodIPv6Internals extends $ZodStringFormatInternals<"ipv6"> {
+  def: $ZodIPv6Def;
+}
+interface $ZodIPv6 extends $ZodType {
+  _zod: $ZodIPv6Internals;
+}
+declare function isValidIPv6(value: string): boolean;
+declare const $ZodIPv6: $constructor<$ZodIPv6>;
+interface $ZodMACDef extends $ZodStringFormatDef<"mac"> {
+  delimiter?: string;
+}
+interface $ZodMACInternals extends $ZodStringFormatInternals<"mac"> {
+  def: $ZodMACDef;
+}
+interface $ZodMAC extends $ZodType {
+  _zod: $ZodMACInternals;
+}
+declare const $ZodMAC: $constructor<$ZodMAC>;
+interface $ZodCIDRv4Def extends $ZodStringFormatDef<"cidrv4"> {
+  version?: "v4";
+}
+interface $ZodCIDRv4Internals extends $ZodStringFormatInternals<"cidrv4"> {
+  def: $ZodCIDRv4Def;
+}
+interface $ZodCIDRv4 extends $ZodType {
+  _zod: $ZodCIDRv4Internals;
+}
+declare const $ZodCIDRv4: $constructor<$ZodCIDRv4>;
+interface $ZodCIDRv6Def extends $ZodStringFormatDef<"cidrv6"> {
+  version?: "v6";
+}
+interface $ZodCIDRv6Internals extends $ZodStringFormatInternals<"cidrv6"> {
+  def: $ZodCIDRv6Def;
+}
+interface $ZodCIDRv6 extends $ZodType {
+  _zod: $ZodCIDRv6Internals;
+}
+declare function isValidCIDRv6(value: string): boolean;
+declare const $ZodCIDRv6: $constructor<$ZodCIDRv6>;
+declare function isValidBase64(data: string): boolean;
+interface $ZodBase64Def extends $ZodStringFormatDef<"base64"> {}
+interface $ZodBase64Internals extends $ZodStringFormatInternals<"base64"> {}
+interface $ZodBase64 extends $ZodType {
+  _zod: $ZodBase64Internals;
+}
+declare const base64Charset: RegExp;
+declare const $ZodBase64: $constructor<$ZodBase64>;
+declare const base64urlCharset: RegExp;
+declare function isValidBase64URL(data: string): boolean;
+interface $ZodBase64URLDef extends $ZodStringFormatDef<"base64url"> {}
+interface $ZodBase64URLInternals extends $ZodStringFormatInternals<"base64url"> {}
+interface $ZodBase64URL extends $ZodType {
+  _zod: $ZodBase64URLInternals;
+}
+declare const $ZodBase64URL: $constructor<$ZodBase64URL>;
+interface $ZodE164Def extends $ZodStringFormatDef<"e164"> {}
+interface $ZodE164Internals extends $ZodStringFormatInternals<"e164"> {}
+interface $ZodE164 extends $ZodType {
+  _zod: $ZodE164Internals;
+}
+declare const $ZodE164: $constructor<$ZodE164>;
+declare function isValidCreditCard(input: string): boolean;
+interface $ZodCreditCardDef extends $ZodStringFormatDef<"credit_card"> {}
+interface $ZodCreditCardInternals extends $ZodStringFormatInternals<"credit_card"> {
+  def: $ZodCreditCardDef;
+}
+interface $ZodCreditCard extends $ZodType {
+  _zod: $ZodCreditCardInternals;
+}
+declare const $ZodCreditCard: $constructor<$ZodCreditCard>;
+declare function isValidIBAN(input: string): boolean;
+interface $ZodIBANDef extends $ZodStringFormatDef<"iban"> {}
+interface $ZodIBANInternals extends $ZodStringFormatInternals<"iban"> {
+  def: $ZodIBANDef;
+}
+interface $ZodIBAN extends $ZodType {
+  _zod: $ZodIBANInternals;
+}
+declare const $ZodIBAN: $constructor<$ZodIBAN>;
+declare function isValidJWT(token: string, algorithm?: JWTAlgorithm | null): boolean;
+interface $ZodJWTDef extends $ZodStringFormatDef<"jwt"> {
+  alg?: JWTAlgorithm | undefined;
+}
+interface $ZodJWTInternals extends $ZodStringFormatInternals<"jwt"> {
+  def: $ZodJWTDef;
+}
+interface $ZodJWT extends $ZodType {
+  _zod: $ZodJWTInternals;
+}
+declare const $ZodJWT: $constructor<$ZodJWT>;
+interface $ZodCustomStringFormatDef<Format extends string = string> extends $ZodStringFormatDef<Format> {
+  fn: (val: string) => unknown;
+}
+interface $ZodCustomStringFormatInternals<Format extends string = string> extends $ZodStringFormatInternals<Format> {
+  def: $ZodCustomStringFormatDef<Format>;
+}
+interface $ZodCustomStringFormat<Format extends string = string> extends $ZodStringFormat<Format> {
+  _zod: $ZodCustomStringFormatInternals<Format>;
+}
+declare const $ZodCustomStringFormat: $constructor<$ZodCustomStringFormat>;
 interface $ZodNumberDef extends $ZodTypeDef {
   type: "number";
   coerce?: boolean;
@@ -842,6 +1364,15 @@ interface $ZodNumber<Input = unknown> extends $ZodType {
   _zod: $ZodNumberInternals<Input>;
 }
 declare const $ZodNumber: $constructor<$ZodNumber>;
+interface $ZodNumberFormatDef<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodNumberDef, $ZodCheckNumberFormatDef<Format> {}
+interface $ZodNumberFormatInternals<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodNumberInternals<number>, $ZodCheckNumberFormatInternals<Format> {
+  def: $ZodNumberFormatDef<Format>;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodNumberFormat<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodType {
+  _zod: $ZodNumberFormatInternals<Format>;
+}
+declare const $ZodNumberFormat: $constructor<$ZodNumberFormat>;
 interface $ZodBooleanDef extends $ZodTypeDef {
   type: "boolean";
   coerce?: boolean;
@@ -875,6 +1406,16 @@ interface $ZodBigInt<T = unknown> extends $ZodType {
   _zod: $ZodBigIntInternals<T>;
 }
 declare const $ZodBigInt: $constructor<$ZodBigInt>;
+interface $ZodBigIntFormatDef<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodBigIntDef, $ZodCheckBigIntFormatDef<Format> {
+  check: "bigint_format";
+}
+interface $ZodBigIntFormatInternals<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodBigIntInternals<bigint>, $ZodCheckBigIntFormatInternals<Format> {
+  def: $ZodBigIntFormatDef<Format>;
+}
+interface $ZodBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodType {
+  _zod: $ZodBigIntFormatInternals<Format>;
+}
+declare const $ZodBigIntFormat: $constructor<$ZodBigIntFormat>;
 interface $ZodSymbolDef extends $ZodTypeDef {
   type: "symbol";
 }
@@ -1001,6 +1542,26 @@ type $ZodObjectConfig = {
   out: Record<string, unknown>;
   in: Record<string, unknown>;
 };
+type $loose = {
+  out: Record<string, unknown>;
+  in: Record<string, unknown>;
+};
+type $strict = {
+  out: {};
+  in: {};
+};
+type $strip = {
+  out: {};
+  in: {};
+};
+type $catchall<T extends SomeType> = {
+  out: {
+    [k: string]: output<T>;
+  };
+  in: {
+    [k: string]: input<T>;
+  };
+};
 type $ZodShape = Readonly<{
   [k: string]: $ZodType;
 }>;
@@ -1026,6 +1587,7 @@ 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>;
+declare const $ZodObjectJIT: $constructor<$ZodObject>;
 type $InferUnionOutput<T extends SomeType> = T extends any ? output<T> : never;
 type $InferUnionInput<T extends SomeType> = T extends any ? input<T> : never;
 interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
@@ -1049,6 +1611,40 @@ interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends
   _zod: $ZodUnionInternals<T>;
 }
 declare const $ZodUnion: $constructor<$ZodUnion>;
+interface $ZodXorInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodUnionInternals<T> {}
+interface $ZodXor<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodXorInternals<T>> {
+  _zod: $ZodXorInternals<T>;
+}
+declare const $ZodXor: $constructor<$ZodXor>;
+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[], Disc extends string = string> extends $ZodUnionInternals<Options> {
+  def: $ZodDiscriminatedUnionDef<Options, Disc>;
+  propValues: PropValues;
+  bag: LoosePartial<{
+    optionsMap: Map<Primitive, $ZodType | null>;
+  }>;
+}
+/** The discriminator values a member of `Options` can declare. An omittable discriminator contributes `undefined`, matching what `propValues` claims for it. */
+type $DiscriminatorValue<Options extends readonly SomeType[], Disc extends string> = { [I in keyof Options]: Options[I] extends {
+  _zod: {
+    output: infer Out;
+  };
+} ? Disc extends keyof Out ? Out[Disc] : never : never; }[number];
+/** The member of `Options` that declares `V`. */
+type $DiscriminatedOption<Options extends readonly SomeType[], Disc extends string, V> = { [I in keyof Options]: Options[I] extends {
+  _zod: {
+    output: infer Out;
+  };
+} ? Disc extends keyof Out ? V extends Out[Disc] ? Options[I] : never : never : never; }[number];
+/** Returns the option whose discriminator claims `value`, or throws if ambiguous. */
+declare function getDiscriminatedOption<Options extends readonly SomeType[], Disc extends string, const V extends $DiscriminatorValue<Options, Disc>>(union: $ZodDiscriminatedUnion<Options, Disc>, value: V): $DiscriminatedOption<Options, Disc, V>;
+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 {
   type: "intersection";
   left: Left;
@@ -1066,6 +1662,13 @@ interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $
   _zod: $ZodIntersectionInternals<A, B>;
 }
 declare const $ZodIntersection: $constructor<$ZodIntersection>;
+declare function mergeValues(a: any, b: any): {
+  valid: true;
+  data: any;
+} | {
+  valid: false;
+  mergeErrorPath: (string | number)[];
+};
 interface $ZodTupleDef<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodTypeDef {
   type: "tuple";
   items: T;
@@ -1371,6 +1974,35 @@ interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType>
   _zod: $ZodPipeInternals<A, B>;
 }
 declare const $ZodPipe: $constructor<$ZodPipe>;
+interface $ZodCodecDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodPipeDef<A, B> {
+  transform: (value: output<A>, payload: ParsePayload<output<A>>) => MaybeAsync<input<B>>;
+  reverseTransform: (value: input<B>, payload: ParsePayload<input<B>>) => MaybeAsync<output<A>>;
+}
+interface $ZodCodecInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output<B>, input<A>> {
+  def: $ZodCodecDef<A, B>;
+  isst: never;
+  values: A["_zod"]["values"];
+  optin: A["_zod"]["optin"];
+  optout: B["_zod"]["optout"];
+  propValues: A["_zod"]["propValues"];
+}
+interface $ZodCodec<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodCodecInternals<A, B>;
+}
+declare const $ZodCodec: $constructor<$ZodCodec>;
+interface $ZodPreprocessDef<B extends SomeType = $ZodType, I = unknown> extends $ZodPipeDef<$ZodTransform<unknown, I>, B> {
+  in: $ZodTransform<unknown, I>;
+  out: B;
+}
+interface $ZodPreprocessInternals<B extends SomeType = $ZodType, I = unknown> extends $ZodPipeInternals<$ZodTransform<unknown, I>, B> {
+  def: $ZodPreprocessDef<B, I>;
+  optin: B["_zod"]["optin"];
+  optout: B["_zod"]["optout"];
+}
+interface $ZodPreprocess<B extends SomeType = $ZodType, I = unknown> extends $ZodPipe<$ZodTransform<unknown, I>, B> {
+  _zod: $ZodPreprocessInternals<B, I>;
+}
+declare const $ZodPreprocess: $constructor<$ZodPreprocess>;
 interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "readonly";
   innerType: T;
@@ -1408,6 +2040,12 @@ interface SchemaPart extends $ZodType {
   _zod: SchemaPartInternals;
 }
 type $ZodTemplateLiteralPart = LiteralPart | SchemaPart;
+type UndefinedToEmptyString<T> = T extends undefined ? "" : T;
+type AppendToTemplateLiteral<Template extends string, Suffix extends LiteralPart | $ZodType> = Suffix extends LiteralPart ? `${Template}${UndefinedToEmptyString<Suffix>}` : Suffix extends $ZodType ? `${Template}${output<Suffix> extends (infer T extends LiteralPart) ? UndefinedToEmptyString<T> : never}` : never;
+type ConcatenateTupleOfStrings<T extends string[]> = T extends [infer First extends string, ...infer Rest extends string[]] ? Rest extends string[] ? First extends "" ? ConcatenateTupleOfStrings<Rest> : `${First}${ConcatenateTupleOfStrings<Rest>}` : never : "";
+type ConvertPartsToStringTuple<Parts extends $ZodTemplateLiteralPart[]> = { [K in keyof Parts]: Parts[K] extends LiteralPart ? `${UndefinedToEmptyString<Parts[K]>}` : Parts[K] extends $ZodType ? `${output<Parts[K]> extends (infer T extends LiteralPart) ? UndefinedToEmptyString<T> : never}` : never; };
+type ToTemplateLiteral<Parts extends $ZodTemplateLiteralPart[]> = ConcatenateTupleOfStrings<ConvertPartsToStringTuple<Parts>>;
+type $PartsToTemplateLiteral<Parts extends $ZodTemplateLiteralPart[]> = [] extends Parts ? `` : Parts extends [...infer Rest, infer Last extends $ZodTemplateLiteralPart] ? Rest extends $ZodTemplateLiteralPart[] ? AppendToTemplateLiteral<$PartsToTemplateLiteral<Rest>, Last> : never : never;
 declare const $ZodTemplateLiteral: $constructor<$ZodTemplateLiteral>;
 type $ZodFunctionArgs = $ZodType<unknown[], unknown[]>;
 type $ZodFunctionIn = $ZodFunctionArgs;
@@ -1437,6 +2075,10 @@ interface $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns ext
   input(...args: any[]): $ZodFunction<any, Returns>;
   output<NewReturns extends $ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
 }
+interface $ZodFunctionParams<I extends $ZodFunctionIn, O extends $ZodType> {
+  input?: I;
+  output?: O;
+}
 declare const $ZodFunction: $constructor<$ZodFunction>;
 interface $ZodPromiseDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "promise";
@@ -1489,8 +2131,10 @@ interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
 }
 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@4.6.5/node_modules/zod/v4/core/checks.d.cts
+type $ZodStringFormatTypes = $ZodGUID | $ZodUUID | $ZodEmail | $ZodURL | $ZodEmoji | $ZodNanoID | $ZodCUID | $ZodCUID2 | $ZodULID | $ZodXID | $ZodKSUID | $ZodISODateTime | $ZodISODate | $ZodISOTime | $ZodISODuration | $ZodIPv4 | $ZodIPv6 | $ZodMAC | $ZodCIDRv4 | $ZodCIDRv6 | $ZodBase64 | $ZodBase64URL | $ZodE164 | $ZodCreditCard | $ZodIBAN | $ZodJWT | $ZodCustomStringFormat<"hex"> | $ZodCustomStringFormat<HashFormat> | $ZodCustomStringFormat<"hostname"> | $ZodCustomStringFormat<"currency_code">;
+declare namespace checks_d_exports {
+  export { $ZodBigIntFormats, $ZodCheck, $ZodCheckBigIntFormat, $ZodCheckBigIntFormatDef, $ZodCheckBigIntFormatInternals, $ZodCheckDef, $ZodCheckEndsWith, $ZodCheckEndsWithDef, $ZodCheckEndsWithInternals, $ZodCheckGreaterThan, $ZodCheckGreaterThanDef, $ZodCheckGreaterThanInternals, $ZodCheckIncludes, $ZodCheckIncludesDef, $ZodCheckIncludesInternals, $ZodCheckInternals, $ZodCheckLengthEquals, $ZodCheckLengthEqualsDef, $ZodCheckLengthEqualsInternals, $ZodCheckLessThan, $ZodCheckLessThanDef, $ZodCheckLessThanInternals, $ZodCheckLowerCase, $ZodCheckLowerCaseDef, $ZodCheckLowerCaseInternals, $ZodCheckMaxLength, $ZodCheckMaxLengthDef, $ZodCheckMaxLengthInternals, $ZodCheckMaxSize, $ZodCheckMaxSizeDef, $ZodCheckMaxSizeInternals, $ZodCheckMimeType, $ZodCheckMimeTypeDef, $ZodCheckMimeTypeInternals, $ZodCheckMinLength, $ZodCheckMinLengthDef, $ZodCheckMinLengthInternals, $ZodCheckMinSize, $ZodCheckMinSizeDef, $ZodCheckMinSizeInternals, $ZodCheckMultipleOf, $ZodCheckMultipleOfDef, $ZodCheckMultipleOfInternals, $ZodCheckNumberFormat, $ZodCheckNumberFormatDef, $ZodCheckNumberFormatInternals, $ZodCheckOverwrite, $ZodCheckOverwriteDef, $ZodCheckOverwriteInternals, $ZodCheckProperties, $ZodCheckPropertiesDef, $ZodCheckPropertiesInput, $ZodCheckPropertiesInternals, $ZodCheckProperty, $ZodCheckPropertyDef, $ZodCheckPropertyInternals, $ZodCheckRegex, $ZodCheckRegexDef, $ZodCheckRegexInternals, $ZodCheckSizeEquals, $ZodCheckSizeEqualsDef, $ZodCheckSizeEqualsInternals, $ZodCheckStartsWith, $ZodCheckStartsWithDef, $ZodCheckStartsWithInternals, $ZodCheckStringFormat, $ZodCheckStringFormatDef, $ZodCheckStringFormatInternals, $ZodCheckUpperCase, $ZodCheckUpperCaseDef, $ZodCheckUpperCaseInternals, $ZodChecks, $ZodNumberFormats, $ZodStringFormatChecks, $ZodStringFormats };
+}
 interface $ZodCheckDef {
   check: string;
   error?: $ZodErrorMap<never> | undefined;
@@ -1510,6 +2154,106 @@ interface $ZodCheck<in T = never> {
   _zod: $ZodCheckInternals<T>;
 }
 declare const $ZodCheck: $constructor<$ZodCheck<any>>;
+interface $ZodCheckLessThanDef extends $ZodCheckDef {
+  check: "less_than";
+  value: Numeric;
+  inclusive: boolean;
+}
+interface $ZodCheckLessThanInternals<T extends Numeric = Numeric> extends $ZodCheckInternals<T> {
+  def: $ZodCheckLessThanDef;
+  issc: $ZodIssueTooBig<T>;
+}
+interface $ZodCheckLessThan<T extends Numeric = Numeric> extends $ZodCheck<T> {
+  _zod: $ZodCheckLessThanInternals<T>;
+}
+declare const $ZodCheckLessThan: $constructor<$ZodCheckLessThan>;
+interface $ZodCheckGreaterThanDef extends $ZodCheckDef {
+  check: "greater_than";
+  value: Numeric;
+  inclusive: boolean;
+}
+interface $ZodCheckGreaterThanInternals<T extends Numeric = Numeric> extends $ZodCheckInternals<T> {
+  def: $ZodCheckGreaterThanDef;
+  issc: $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckGreaterThan<T extends Numeric = Numeric> extends $ZodCheck<T> {
+  _zod: $ZodCheckGreaterThanInternals<T>;
+}
+declare const $ZodCheckGreaterThan: $constructor<$ZodCheckGreaterThan>;
+interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {
+  check: "multiple_of";
+  value: T;
+}
+interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMultipleOfDef<T>;
+  issc: $ZodIssueNotMultipleOf;
+}
+interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {
+  _zod: $ZodCheckMultipleOfInternals<T>;
+}
+declare const $ZodCheckMultipleOf: $constructor<$ZodCheckMultipleOf<number | bigint>>;
+type $ZodNumberFormats = "int32" | "uint32" | "float32" | "float64" | "safeint";
+interface $ZodCheckNumberFormatDef<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheckDef {
+  check: "number_format";
+  format: Format;
+}
+interface $ZodCheckNumberFormatInternals<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheckInternals<number> {
+  def: $ZodCheckNumberFormatDef<Format>;
+  issc: $ZodIssueInvalidType | $ZodIssueTooBig<"number"> | $ZodIssueTooSmall<"number">;
+}
+interface $ZodCheckNumberFormat<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheck<number> {
+  _zod: $ZodCheckNumberFormatInternals<Format>;
+}
+declare const $ZodCheckNumberFormat: $constructor<$ZodCheckNumberFormat>;
+type $ZodBigIntFormats = "int64" | "uint64";
+interface $ZodCheckBigIntFormatDef<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodCheckDef {
+  check: "bigint_format";
+  format: Format;
+}
+interface $ZodCheckBigIntFormatInternals<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodCheckInternals<bigint> {
+  def: $ZodCheckBigIntFormatDef<Format>;
+  issc: $ZodIssueTooBig<"bigint"> | $ZodIssueTooSmall<"bigint">;
+}
+interface $ZodCheckBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodCheck<bigint> {
+  _zod: $ZodCheckBigIntFormatInternals<Format>;
+}
+declare const $ZodCheckBigIntFormat: $constructor<$ZodCheckBigIntFormat>;
+interface $ZodCheckMaxSizeDef extends $ZodCheckDef {
+  check: "max_size";
+  maximum: number;
+}
+interface $ZodCheckMaxSizeInternals<T extends HasSize = HasSize> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMaxSizeDef;
+  issc: $ZodIssueTooBig<T>;
+}
+interface $ZodCheckMaxSize<T extends HasSize = HasSize> extends $ZodCheck<T> {
+  _zod: $ZodCheckMaxSizeInternals<T>;
+}
+declare const $ZodCheckMaxSize: $constructor<$ZodCheckMaxSize>;
+interface $ZodCheckMinSizeDef extends $ZodCheckDef {
+  check: "min_size";
+  minimum: number;
+}
+interface $ZodCheckMinSizeInternals<T extends HasSize = HasSize> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMinSizeDef;
+  issc: $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckMinSize<T extends HasSize = HasSize> extends $ZodCheck<T> {
+  _zod: $ZodCheckMinSizeInternals<T>;
+}
+declare const $ZodCheckMinSize: $constructor<$ZodCheckMinSize>;
+interface $ZodCheckSizeEqualsDef extends $ZodCheckDef {
+  check: "size_equals";
+  size: number;
+}
+interface $ZodCheckSizeEqualsInternals<T extends HasSize = HasSize> extends $ZodCheckInternals<T> {
+  def: $ZodCheckSizeEqualsDef;
+  issc: $ZodIssueTooBig<T> | $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckSizeEquals<T extends HasSize = HasSize> extends $ZodCheck<T> {
+  _zod: $ZodCheckSizeEqualsInternals<T>;
+}
+declare const $ZodCheckSizeEquals: $constructor<$ZodCheckSizeEquals>;
 interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
   check: "max_length";
   maximum: number;
@@ -1547,8 +2291,139 @@ interface $ZodCheckLengthEquals<T extends HasLength = HasLength> extends $ZodChe
 }
 declare const $ZodCheckLengthEquals: $constructor<$ZodCheckLengthEquals>;
 type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "credit_card" | "iban" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
-//#endregion
-//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/errors.d.cts
+interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
+  check: "string_format";
+  format: Format;
+  pattern?: RegExp | undefined;
+}
+interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckStringFormatDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckStringFormat extends $ZodCheck<string> {
+  _zod: $ZodCheckStringFormatInternals;
+}
+declare const $ZodCheckStringFormat: $constructor<$ZodCheckStringFormat>;
+interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {
+  format: "regex";
+  pattern: RegExp;
+}
+interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckRegexDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckRegex extends $ZodCheck<string> {
+  _zod: $ZodCheckRegexInternals;
+}
+declare const $ZodCheckRegex: $constructor<$ZodCheckRegex>;
+interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<"lowercase"> {}
+interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckLowerCaseDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckLowerCase extends $ZodCheck<string> {
+  _zod: $ZodCheckLowerCaseInternals;
+}
+declare const $ZodCheckLowerCase: $constructor<$ZodCheckLowerCase>;
+interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<"uppercase"> {}
+interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckUpperCaseDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckUpperCase extends $ZodCheck<string> {
+  _zod: $ZodCheckUpperCaseInternals;
+}
+declare const $ZodCheckUpperCase: $constructor<$ZodCheckUpperCase>;
+interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<"includes"> {
+  includes: string;
+  position?: number | undefined;
+}
+interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckIncludesDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckIncludes extends $ZodCheck<string> {
+  _zod: $ZodCheckIncludesInternals;
+}
+declare const $ZodCheckIncludes: $constructor<$ZodCheckIncludes>;
+interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<"starts_with"> {
+  prefix: string;
+}
+interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckStartsWithDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckStartsWith extends $ZodCheck<string> {
+  _zod: $ZodCheckStartsWithInternals;
+}
+declare const $ZodCheckStartsWith: $constructor<$ZodCheckStartsWith>;
+interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<"ends_with"> {
+  suffix: string;
+}
+interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckEndsWithDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
+  _zod: $ZodCheckEndsWithInternals;
+}
+declare const $ZodCheckEndsWith: $constructor<$ZodCheckEndsWith>;
+interface $ZodCheckPropertyDef extends $ZodCheckDef {
+  check: "property";
+  property: string;
+  schema: $ZodType;
+}
+interface $ZodCheckPropertyInternals<T extends object = object> extends $ZodCheckInternals<T> {
+  def: $ZodCheckPropertyDef;
+  issc: $ZodIssue;
+}
+interface $ZodCheckProperty<T extends object = object> extends $ZodCheck<T> {
+  _zod: $ZodCheckPropertyInternals<T>;
+}
+declare const $ZodCheckProperty: $constructor<$ZodCheckProperty>;
+interface $ZodCheckPropertiesDef<Shape extends $ZodShape = $ZodShape> extends $ZodCheckDef {
+  check: "properties";
+  shape: Shape;
+}
+type $ZodCheckPropertiesInput<Shape extends $ZodShape = $ZodShape> = { -readonly [k in keyof Shape]: Widen<input<Shape[k]>>; };
+interface $ZodCheckPropertiesInternals<Shape extends $ZodShape = $ZodShape> extends $ZodCheckInternals<$ZodCheckPropertiesInput<Shape>> {
+  def: $ZodCheckPropertiesDef<Shape>;
+  issc: $ZodIssue;
+}
+interface $ZodCheckProperties<Shape extends $ZodShape = $ZodShape> extends $ZodCheck<$ZodCheckPropertiesInput<Shape>> {
+  _zod: $ZodCheckPropertiesInternals<Shape>;
+  [Symbol.iterator](): Iterator<this>;
+}
+declare const $ZodCheckProperties: $constructor<$ZodCheckProperties>;
+interface $ZodCheckMimeTypeDef extends $ZodCheckDef {
+  check: "mime_type";
+  mime: MimeTypes[];
+}
+interface $ZodCheckMimeTypeInternals<T extends File = File> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMimeTypeDef;
+  issc: $ZodIssueInvalidValue;
+}
+interface $ZodCheckMimeType<T extends File = File> extends $ZodCheck<T> {
+  _zod: $ZodCheckMimeTypeInternals<T>;
+}
+declare const $ZodCheckMimeType: $constructor<$ZodCheckMimeType>;
+interface $ZodCheckOverwriteDef<T = unknown> extends $ZodCheckDef {
+  check: "overwrite";
+  tx(value: T): T;
+}
+interface $ZodCheckOverwriteInternals<T = unknown> extends $ZodCheckInternals<T> {
+  def: $ZodCheckOverwriteDef<T>;
+  issc: never;
+}
+interface $ZodCheckOverwrite<T = unknown> extends $ZodCheck<T> {
+  _zod: $ZodCheckOverwriteInternals<T>;
+}
+declare const $ZodCheckOverwrite: $constructor<$ZodCheckOverwrite>;
+type $ZodChecks = $ZodCheckLessThan | $ZodCheckGreaterThan | $ZodCheckMultipleOf | $ZodCheckNumberFormat | $ZodCheckBigIntFormat | $ZodCheckMaxSize | $ZodCheckMinSize | $ZodCheckSizeEquals | $ZodCheckMaxLength | $ZodCheckMinLength | $ZodCheckLengthEquals | $ZodCheckStringFormat | $ZodCheckProperty | $ZodCheckMimeType | $ZodCheckOverwrite;
+type $ZodStringFormatChecks = $ZodCheckRegex | $ZodCheckLowerCase | $ZodCheckUpperCase | $ZodCheckIncludes | $ZodCheckStartsWith | $ZodCheckEndsWith | $ZodStringFormatTypes;
+declare namespace errors_d_exports {
+  export { $ZodError, $ZodErrorMap, $ZodErrorTree, $ZodFlattenedError, $ZodFormattedError, $ZodInternalIssue, $ZodInvalidTypeExpected, $ZodIssue, $ZodIssueBase, $ZodIssueCode, $ZodIssueCustom, $ZodIssueInvalidElement, $ZodIssueInvalidKey, $ZodIssueInvalidStringFormat, $ZodIssueInvalidType, $ZodIssueInvalidUnion, $ZodIssueInvalidValue, $ZodIssueNotMultipleOf, $ZodIssueStringCommonFormats, $ZodIssueStringEndsWith, $ZodIssueStringIncludes, $ZodIssueStringInvalidJWT, $ZodIssueStringInvalidRegex, $ZodIssueStringStartsWith, $ZodIssueTooBig, $ZodIssueTooSmall, $ZodIssueUnrecognizedKeys, $ZodRawIssue, $ZodRealError, $ZodStringFormatIssues, flattenError, formatError, prettifyError, toDotPath, treeifyError };
+}
 interface $ZodIssueBase {
   readonly code?: string;
   readonly input?: unknown;
@@ -1636,7 +2511,32 @@ interface $ZodIssueCustom extends $ZodIssueBase {
   readonly params?: Record<string, any> | undefined;
   readonly input?: unknown;
 }
+interface $ZodIssueStringCommonFormats extends $ZodIssueInvalidStringFormat {
+  format: Exclude<$ZodStringFormats, "regex" | "jwt" | "starts_with" | "ends_with" | "includes">;
+}
+interface $ZodIssueStringInvalidRegex extends $ZodIssueInvalidStringFormat {
+  format: "regex";
+  pattern: string;
+}
+interface $ZodIssueStringInvalidJWT extends $ZodIssueInvalidStringFormat {
+  format: "jwt";
+  algorithm?: string;
+}
+interface $ZodIssueStringStartsWith extends $ZodIssueInvalidStringFormat {
+  format: "starts_with";
+  prefix: string;
+}
+interface $ZodIssueStringEndsWith extends $ZodIssueInvalidStringFormat {
+  format: "ends_with";
+  suffix: string;
+}
+interface $ZodIssueStringIncludes extends $ZodIssueInvalidStringFormat {
+  format: "includes";
+  includes: string;
+}
+type $ZodStringFormatIssues = $ZodIssueStringCommonFormats | $ZodIssueStringInvalidRegex | $ZodIssueStringInvalidJWT | $ZodIssueStringStartsWith | $ZodIssueStringEndsWith | $ZodIssueStringIncludes;
 type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
+type $ZodIssueCode = $ZodIssue["code"];
 type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue$1<T> : never;
 type RawIssue$1<T extends $ZodIssueBase> = T extends any ? Flatten<MakePartial<T, "message" | "path"> & {
   /** The input data */
@@ -1665,19 +2565,76 @@ interface $ZodError<T = unknown> extends Error {
   name: string;
 }
 declare const $ZodError: $constructor<$ZodError>;
+interface $ZodRealError<T = any> extends $ZodError<T> {}
+declare const $ZodRealError: $constructor<$ZodRealError>;
 type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
 type _FlattenedError<T, U = string> = {
   formErrors: U[];
   fieldErrors: { [P in keyof T]?: U[]; };
 };
+declare function flattenError<T>(error: $ZodError<T>): _FlattenedError<T>;
+declare function flattenError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): _FlattenedError<T, U>;
 type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? { [K in keyof T]?: $ZodFormattedError<T[K], U>; } : T extends any[] ? {
   [k: number]: $ZodFormattedError<T[number], U>;
 } : T extends object ? Flatten<{ [K in keyof T]?: $ZodFormattedError<T[K], U>; }> : any;
 type $ZodFormattedError<T, U = string> = {
   _errors: U[];
 } & Flatten<_ZodFormattedError<T, U>>;
-//#endregion
-//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/core.d.cts
+declare function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;
+declare function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
+type $ZodErrorTree<T, U = string> = T extends Primitive ? {
+  errors: U[];
+} : T extends [any, ...any[]] ? {
+  errors: U[];
+  items?: { [K in keyof T]?: $ZodErrorTree<T[K], U>; };
+} : T extends any[] ? {
+  errors: U[];
+  items?: Array<$ZodErrorTree<T[number], U>>;
+} : T extends object ? {
+  errors: U[];
+  properties?: { [K in keyof T]?: $ZodErrorTree<T[K], U>; };
+} : {
+  errors: U[];
+};
+declare function treeifyError<T>(error: $ZodError<T>): $ZodErrorTree<T>;
+declare function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodErrorTree<T, U>;
+/** Format a ZodError as a human-readable string in the following form.
+ *
+ * From
+ *
+ * ```ts
+ * ZodError {
+ *   issues: [
+ *     {
+ *       expected: 'string',
+ *       code: 'invalid_type',
+ *       path: [ 'username' ],
+ *       message: 'Invalid input: expected string'
+ *     },
+ *     {
+ *       expected: 'number',
+ *       code: 'invalid_type',
+ *       path: [ 'favoriteNumbers', 1 ],
+ *       message: 'Invalid input: expected number'
+ *     }
+ *   ];
+ * }
+ * ```
+ *
+ * to
+ *
+ * ```
+ * username
+ *   ✖ Expected number, received string at "username
+ * favoriteNumbers[0]
+ *   ✖ Invalid input: expected number
+ * ```
+ */
+declare function toDotPath(_path: readonly (string | number | symbol | StandardSchemaV1.PathSegment)[]): string;
+declare function prettifyError(error: StandardSchemaV1.FailureResult): string;
+declare namespace core_d_exports {
+  export { $ZodAsyncError, $ZodBranded, $ZodConfig, $ZodEncodeError, $ZodNarrow, $brand, $constructor, $constructorParams, NEVER, config, globalConfig, output as infer, input, output };
+}
 type ZodTrait = {
   _zod: {
     def: any;
@@ -1691,6 +2648,8 @@ interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
 interface $constructorParams {
   Parent?: typeof Class;
 }
+/** A special constant with type `never` */
+declare const NEVER: never;
 declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void,
 /** This trait's members, installed once on every prototype that composes it. They cannot be declared in the initializer above: that runs per instance, and the prototype is shared. */
 proto?: ProtoOf<T>, params?: $constructorParams): $constructor<T, D>;
@@ -1712,6 +2671,17 @@ type $ZodBranded<T extends SomeType, Brand extends string | number | symbol, Dir
     output: output<T> & $brand<Brand>;
   };
 });
+type $ZodNarrow<T extends SomeType, Out> = T & {
+  _zod: {
+    output: Out;
+  };
+};
+declare class $ZodAsyncError extends Error {
+  constructor();
+}
+declare class $ZodEncodeError extends Error {
+  constructor(name: string);
+}
 type input<T> = T extends {
   _zod: {
     input: any;
@@ -1722,6 +2692,580 @@ type output<T> = T extends {
     output: any;
   };
 } ? T["_zod"]["output"] : unknown;
+interface $ZodConfig {
+  /** Custom error map. Overrides `config().localeError`. */
+  customError?: $ZodErrorMap | undefined;
+  /** Localized error map. Lowest priority. */
+  localeError?: $ZodErrorMap | undefined;
+  /** Disable JIT schema compilation. Useful in environments that disallow `eval`. */
+  jitless?: boolean | undefined;
+  /** Enables parsing input that contains reference cycles. Read when a schema is constructed. */
+  memoizer?: $ZodMemoizer | undefined;
+  /**
+   * Internal: post-processor invoked on every freshly-constructed schema
+   * instance, after init and deferred fns run. Set by `import "zod/compile"`
+   * to install AOT compilation. Not part of the public API.
+   * @internal
+   */
+  postProcessor?: ((inst: any) => void) | undefined;
+}
+declare const globalConfig: $ZodConfig;
+declare function config(newConfig?: Partial<$ZodConfig>): $ZodConfig;
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/parse.d.cts
+type $ZodErrorClass = {
+  new (issues: $ZodIssue[]): $ZodError;
+};
+type $ParseParams = {
+  callee?: AnyFunc;
+  Err?: $ZodErrorClass | undefined;
+};
+type $Parse = <T extends $ZodType>(schema: T, value: unknown, _ctx?: ParseContext<$ZodIssue>, _params?: $ParseParams) => output<T>;
+declare const _parse: (_Err: $ZodErrorClass) => $Parse;
+declare const parse$1: $Parse;
+type $ParseAsync = <T extends $ZodType>(schema: T, value: unknown, _ctx?: ParseContext<$ZodIssue>, _params?: $ParseParams) => Promise<output<T>>;
+declare const _parseAsync: (_Err: $ZodErrorClass) => $ParseAsync;
+declare const parseAsync$1: $ParseAsync;
+type $SafeParse = <T extends $ZodType>(schema: T, value: unknown, _ctx?: ParseContext<$ZodIssue>) => SafeParseResult<output<T>>;
+declare const _safeParse: (_Err: $ZodErrorClass) => $SafeParse;
+declare const safeParse$1: $SafeParse;
+type $SafeParseAsync = <T extends $ZodType>(schema: T, value: unknown, _ctx?: ParseContext<$ZodIssue>) => Promise<SafeParseResult<output<T>>>;
+declare const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync;
+declare const safeParseAsync$1: $SafeParseAsync;
+type $Validate = <T extends $ZodType>(schema: T, value: unknown, _ctx?: ParseContext<$ZodIssue>) => value is input<T>;
+declare const validate: $Validate;
+type $ValidateAsync = <T extends $ZodType>(schema: T, value: unknown, _ctx?: ParseContext<$ZodIssue>) => Promise<boolean>;
+declare const validateAsync: $ValidateAsync;
+type $Encode = <T extends $ZodType>(schema: T, value: output<T>, _ctx?: ParseContext<$ZodIssue>, _params?: $ParseParams) => input<T>;
+declare const _encode: (_Err: $ZodErrorClass) => $Encode;
+declare const encode$1: $Encode;
+type $Decode = <T extends $ZodType>(schema: T, value: input<T>, _ctx?: ParseContext<$ZodIssue>, _params?: $ParseParams) => output<T>;
+declare const _decode: (_Err: $ZodErrorClass) => $Decode;
+declare const decode$1: $Decode;
+type $EncodeAsync = <T extends $ZodType>(schema: T, value: output<T>, _ctx?: ParseContext<$ZodIssue>, _params?: $ParseParams) => Promise<input<T>>;
+declare const _encodeAsync: (_Err: $ZodErrorClass) => $EncodeAsync;
+declare const encodeAsync$1: $EncodeAsync;
+type $DecodeAsync = <T extends $ZodType>(schema: T, value: input<T>, _ctx?: ParseContext<$ZodIssue>, _params?: $ParseParams) => Promise<output<T>>;
+declare const _decodeAsync: (_Err: $ZodErrorClass) => $DecodeAsync;
+declare const decodeAsync$1: $DecodeAsync;
+type $SafeEncode = <T extends $ZodType>(schema: T, value: output<T>, _ctx?: ParseContext<$ZodIssue>) => SafeParseResult<input<T>>;
+declare const _safeEncode: (_Err: $ZodErrorClass) => $SafeEncode;
+declare const safeEncode$1: $SafeEncode;
+type $SafeDecode = <T extends $ZodType>(schema: T, value: input<T>, _ctx?: ParseContext<$ZodIssue>) => SafeParseResult<output<T>>;
+declare const _safeDecode: (_Err: $ZodErrorClass) => $SafeDecode;
+declare const safeDecode$1: $SafeDecode;
+type $SafeEncodeAsync = <T extends $ZodType>(schema: T, value: output<T>, _ctx?: ParseContext<$ZodIssue>) => Promise<SafeParseResult<input<T>>>;
+declare const _safeEncodeAsync: (_Err: $ZodErrorClass) => $SafeEncodeAsync;
+declare const safeEncodeAsync$1: $SafeEncodeAsync;
+type $SafeDecodeAsync = <T extends $ZodType>(schema: T, value: input<T>, _ctx?: ParseContext<$ZodIssue>) => Promise<SafeParseResult<output<T>>>;
+declare const _safeDecodeAsync: (_Err: $ZodErrorClass) => $SafeDecodeAsync;
+declare const safeDecodeAsync$1: $SafeDecodeAsync;
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/memoizer.d.cts
+declare class $ZodCyclicError extends Error {
+  constructor();
+}
+/**
+ * Whether one parse can re-enter this schema, i.e. its subtree contains a cycle.
+ * Exported for `z.compile`, which refuses to compile such a schema: cycle
+ * breaking is driven from here off state keyed on the parse context, and a
+ * generated fast path has no context to key on.
+ */
+declare function isRecursiveSchema(inst: $ZodType): boolean;
+/** The memoizer that gives containers cycle support. `zod` installs it by default; `zod/mini` opts in with `config({ memoizer: memoizer() })`. */
+declare function memoizer(): $ZodMemoizer;
+/** Whether this value is a node a back-edge resolved to before it finished. */
+declare function isBackEdge(ctx: object, value: unknown): boolean;
+declare namespace regexes_d_exports {
+  export { anyString, base64, base64url, bigint, boolean, browserEmail, cidrv4, cidrv6, creditCard, cuid, cuid2, currencyCode, date, datetime, domain, duration, e164, email, emoji, extendedDuration, guid, hex, hostname, html5Email, httpProtocol, iban, idnEmail, integer, ipv4, ipv6, ksuid, lowercase, mac, md5_base64, md5_base64url, md5_hex, nanoid, nanoidOfLength, _null$1 as null, number, rfc5322Email, sha1_base64, sha1_base64url, sha1_hex, sha256_base64, sha256_base64url, sha256_hex, sha384_base64, sha384_base64url, sha384_hex, sha512_base64, sha512_base64url, sha512_hex, string, time, ulid, _undefined$1 as undefined, unicodeEmail, uppercase, uuid, uuid4, uuid6, uuid7, xid };
+}
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link cuid2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+declare const cuid: RegExp;
+declare const cuid2: RegExp;
+declare const ulid: RegExp;
+declare const xid: RegExp;
+declare const ksuid: RegExp;
+declare const nanoid: RegExp;
+declare function nanoidOfLength(length: number): RegExp;
+/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
+declare const duration: RegExp;
+/** Implements ISO 8601-2 extensions like explicit +- prefixes, mixing weeks with other units, and fractional/negative components. */
+declare const extendedDuration: RegExp;
+/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
+declare const guid: RegExp;
+/** Returns a regex for validating an RFC 9562/4122 UUID.
+ *
+ * @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
+declare const uuid: (version?: number | undefined) => RegExp;
+declare const uuid4: RegExp;
+declare const uuid6: RegExp;
+declare const uuid7: RegExp;
+/** Practical email validation */
+declare const email: RegExp;
+/** Equivalent to the HTML5 input[type=email] validation implemented by browsers. Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email */
+declare const html5Email: RegExp;
+/** The classic emailregex.com regex for RFC 5322-compliant emails */
+declare const rfc5322Email: RegExp;
+/** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */
+declare const unicodeEmail: RegExp;
+declare const idnEmail: RegExp;
+declare const browserEmail: RegExp;
+declare function emoji(): RegExp;
+declare const ipv4: RegExp;
+declare const ipv6: RegExp;
+declare const mac: (delimiter?: string) => RegExp;
+declare const cidrv4: RegExp;
+declare const cidrv6: RegExp;
+declare const base64: RegExp;
+declare const base64url: RegExp;
+declare const hostname: RegExp;
+declare const domain: RegExp;
+declare const httpProtocol: RegExp;
+declare const e164: RegExp;
+declare const creditCard: RegExp;
+declare const currencyCode: RegExp;
+declare const iban: RegExp;
+declare const date: RegExp;
+declare function time(args: {
+  precision?: number | null;
+}): RegExp;
+declare function datetime(args: {
+  precision?: number | null;
+  offset?: boolean;
+  local?: boolean;
+}): RegExp;
+declare const anyString: RegExp;
+declare const string: (params?: {
+  minimum?: number | undefined;
+  maximum?: number | undefined;
+}) => RegExp;
+declare const bigint: RegExp;
+declare const integer: RegExp;
+declare const number: RegExp;
+declare const boolean: RegExp;
+declare const _null$1: RegExp;
+declare const _undefined$1: RegExp;
+declare const lowercase: RegExp;
+declare const uppercase: RegExp;
+declare const hex: RegExp;
+declare const md5_hex: RegExp;
+declare const md5_base64: RegExp;
+declare const md5_base64url: RegExp;
+declare const sha1_hex: RegExp;
+declare const sha1_base64: RegExp;
+declare const sha1_base64url: RegExp;
+declare const sha256_hex: RegExp;
+declare const sha256_base64: RegExp;
+declare const sha256_base64url: RegExp;
+declare const sha384_hex: RegExp;
+declare const sha384_base64: RegExp;
+declare const sha384_base64url: RegExp;
+declare const sha512_hex: RegExp;
+declare const sha512_base64: RegExp;
+declare const sha512_base64url: RegExp;
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ar.d.cts
+declare function _default$63(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/az.d.cts
+declare function _default$62(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/be.d.cts
+declare function _default$61(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/bg.d.cts
+declare function _default$60(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/bn.d.cts
+declare function _default$59(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ca.d.cts
+declare function _default$58(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ckb.d.cts
+declare function _default$57(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/cs.d.cts
+declare function _default$56(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/da.d.cts
+declare function _default$55(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/de.d.cts
+declare function _default$54(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/el.d.cts
+declare function _default$53(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/en.d.cts
+declare function _default$52(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/eo.d.cts
+declare function _default$51(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/es.d.cts
+declare function _default$50(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/fa.d.cts
+declare function _default$49(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/fi.d.cts
+declare function _default$48(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/fr.d.cts
+declare function _default$47(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/fr-CA.d.cts
+declare function _default$46(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/gu.d.cts
+declare function _default$45(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/he.d.cts
+declare function _default$44(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/hi.d.cts
+declare function _default$43(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/hr.d.cts
+declare function _default$42(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/hu.d.cts
+declare function _default$41(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/hy.d.cts
+declare function _default$40(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/id.d.cts
+declare function _default$39(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/is.d.cts
+declare function _default$38(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/it.d.cts
+declare function _default$37(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ja.d.cts
+declare function _default$36(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ka.d.cts
+declare function _default$35(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/kh.d.cts
+declare function _default$34(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/km.d.cts
+declare function _default$33(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/kn.d.cts
+declare function _default$32(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ko.d.cts
+declare function _default$31(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/lt.d.cts
+declare function _default$30(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/mk.d.cts
+declare function _default$29(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ms.d.cts
+declare function _default$28(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ne.d.cts
+declare function _default$27(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/nl.d.cts
+declare function _default$26(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/nn.d.cts
+declare function _default$25(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/no.d.cts
+declare function _default$24(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ota.d.cts
+declare function _default$23(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ps.d.cts
+declare function _default$22(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/pl.d.cts
+declare function _default$21(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/pt.d.cts
+declare function _default$20(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/pt-BR.d.cts
+declare function _default$19(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ro.d.cts
+declare function _default$18(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ru.d.cts
+declare function _default$17(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/sk.d.cts
+declare function _default$16(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/sl.d.cts
+declare function _default$15(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/sv.d.cts
+declare function _default$14(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ta.d.cts
+declare function _default$13(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/tg.d.cts
+declare function _default$12(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/th.d.cts
+declare function _default$11(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/tk.d.cts
+declare function _default$10(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/tr.d.cts
+declare function _default$9(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ua.d.cts
+declare function _default$8(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/uk.d.cts
+declare function _default$7(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ur.d.cts
+declare function _default$6(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/uz.d.cts
+declare function _default$5(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/vi.d.cts
+declare function _default$4(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/zh-CN.d.cts
+declare function _default$3(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/zh-TW.d.cts
+declare function _default$2(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/yo.d.cts
+declare function _default$1(): {
+  localeError: $ZodErrorMap;
+};
+declare namespace index_d_exports$1 {
+  export { _default$63 as ar, _default$62 as az, _default$61 as be, _default$60 as bg, _default$59 as bn, _default$58 as ca, _default$57 as ckb, _default$56 as cs, _default$55 as da, _default$54 as de, _default$53 as el, _default$52 as en, _default$51 as eo, _default$50 as es, _default$49 as fa, _default$48 as fi, _default$47 as fr, _default$46 as frCA, _default$45 as gu, _default$44 as he, _default$43 as hi, _default$42 as hr, _default$41 as hu, _default$40 as hy, _default$39 as id, _default$38 as is, _default$37 as it, _default$36 as ja, _default$35 as ka, _default$34 as kh, _default$33 as km, _default$32 as kn, _default$31 as ko, _default$30 as lt, _default$29 as mk, _default$28 as ms, _default$27 as ne, _default$26 as nl, _default$25 as nn, _default$24 as no, _default$23 as ota, _default$21 as pl, _default$22 as ps, _default$20 as pt, _default$19 as ptBR, _default$18 as ro, _default$17 as ru, _default$16 as sk, _default$15 as sl, _default$14 as sv, _default$13 as ta, _default$12 as tg, _default$11 as th, _default$10 as tk, _default$9 as tr, _default$8 as ua, _default$7 as uk, _default$6 as ur, _default$5 as uz, _default$4 as vi, _default$1 as yo, _default$3 as zhCN, _default$2 as zhTW };
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/doc.d.cts
+type ModeWriter = (doc: Doc, modes: {
+  execution: "sync" | "async";
+}) => void;
+declare class Doc {
+  args: string[];
+  /** Bindings the compiled function closes over, by name. */
+  closed: Record<string, unknown>;
+  content: string[];
+  indent: number;
+  constructor(args?: string[], closed?: Record<string, unknown>);
+  indented(fn: (doc: Doc) => void): void;
+  write(fn: ModeWriter): void;
+  write(line: string): void;
+  compile(): any;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/compile.d.cts
+/** @internal Sentinel the compiled fast path returns when validation fails. */
+declare const INVALID: unique symbol;
+/** @internal */
+type INVALID = typeof INVALID;
+interface CompileFnOptions {
+  debug?: boolean | undefined;
+  /** Emit a validator instead of a parser: skip building the output value where nothing reads it. */
+  assertOnly?: boolean | undefined;
+}
+type CompiledFn<T> = ((input: unknown) => T | INVALID) & {
+  code?: string | undefined;
+  /** False when this function's INVALID does not strictly mean "the runtime would reject". */
+  definite?: boolean | undefined;
+};
+/** Raised when the schema contains async refinements or transforms. Surfaces only under `compile(schema, { strict: true })`. */
+declare class ZodCompileAsyncError extends Error {
+  constructor(message?: string);
+}
+/**
+ * Raised when the schema contains a feature whose semantics the fast path
+ * can't fully model. Both the shim in `zod/compile` and the default
+ * `compile()` fall back to the runtime parser for that schema; only
+ * `compile(schema, { strict: true })` lets it surface.
+ */
+declare class ZodCompileUnsupportedError extends Error {
+  /** Whether a container may absorb this refusal by running the child through the runtime (see `compileChild`). False when running only that node on the runtime is not equivalent to running the whole parse there — a runtime island gets no parse context, so a node that *consumes* issues rather than propagating them would finalize them against the wrong error map and still succeed. */
+  readonly islandable: boolean;
+  constructor(feature: string, islandable?: boolean);
+}
+interface CompileOptions {
+  /** Throw the refusal instead of returning the schema uncompiled. */
+  strict?: boolean | undefined;
+}
+/**
+ * AOT-compile a Zod schema. Returns a clone whose `_zod.run` calls a generated
+ * fast path first and falls back to the original runtime parser on failure.
+ *
+ * - Forward direction only. Backward (encode), async, and `skipChecks` paths
+ *   bypass the fast path and use the runtime directly.
+ * - Never throws. A schema the fast path can't model is returned unchanged and
+ *   keeps using the runtime parser. Pass `{ strict: true }` to get the refusal
+ *   as a thrown `ZodCompileUnsupportedError` / `ZodCompileAsyncError` instead.
+ * - The original schema is unchanged. The clone shares children by reference.
+ */
+declare function compile<T extends SomeType>(schema: T, options?: CompileOptions): T;
+/**
+ * Install an already-generated parser as a schema's fast path. Returns a clone; the original is
+ * unchanged.
+ *
+ * The parser takes the input and returns the parsed value, or `INVALID` to hand the parse to the
+ * runtime. It must be synchronous and forward-direction, and it must build fresh output rather than
+ * return its input — Zod cannot check either, and a wrong *success* is returned to the caller as-is.
+ *
+ * `compile()` is the ordinary entry point. This is for a build-time or native compiler that produces
+ * a parser where `new Function` is unavailable.
+ */
+declare function withParser<T extends SomeType>(schema: T, parser: (input: unknown) => output<T> | INVALID): T;
+/**
+ * @internal Generate the standalone compiled function: a parser by default, a validator under
+ * `assertOnly`. Returns the parsed value, `true` where nothing reads the output, or `INVALID`. Consumers use `compile()`.
+ */
+declare function compileFn<T extends SomeType>(schema: T, options?: CompileFnOptions): CompiledFn<output<T>>;
 //#endregion
 //#region ../../../node_modules/.pnpm/zod@4.6.5/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<Partial<EmptyToNever<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
@@ -1734,12 +3278,283 @@ type TypeParams<T extends $ZodType = $ZodType & {
 }, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
 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 StringFormatParams<T extends $ZodStringFormat = $ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | 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 $ZodStringParams = TypeParams<$ZodString<string>, "coerce"> & {
+  checks?: readonly $ZodCheck<string>[];
+};
+declare function _string<T extends $ZodString>(Class: SchemaClass<T>, params?: string | $ZodStringParams): T;
+declare function _coercedString<T extends $ZodString>(Class: SchemaClass<T>, params?: string | $ZodStringParams): T;
+type $ZodStringFormatParams = CheckTypeParams<$ZodStringFormat, "format" | "coerce" | "when" | "pattern">;
+type $ZodCheckStringFormatParams = CheckParams<$ZodCheckStringFormat, "format">;
+type $ZodEmailParams = StringFormatParams<$ZodEmail, "when">;
+type $ZodCheckEmailParams = CheckStringFormatParams<$ZodEmail, "when">;
+declare function _email<T extends $ZodEmail>(Class: SchemaClass<T>, params?: string | $ZodEmailParams | $ZodCheckEmailParams): T;
+type $ZodGUIDParams = StringFormatParams<$ZodGUID, "pattern" | "when">;
+type $ZodCheckGUIDParams = CheckStringFormatParams<$ZodGUID, "pattern" | "when">;
+declare function _guid<T extends $ZodGUID>(Class: SchemaClass<T>, params?: string | $ZodGUIDParams | $ZodCheckGUIDParams): T;
+type $ZodUUIDParams = StringFormatParams<$ZodUUID, "pattern" | "when">;
+type $ZodCheckUUIDParams = CheckStringFormatParams<$ZodUUID, "pattern" | "when">;
+declare function _uuid<T extends $ZodUUID>(Class: SchemaClass<T>, params?: string | $ZodUUIDParams | $ZodCheckUUIDParams): T;
+type $ZodUUIDv4Params = StringFormatParams<$ZodUUID, "pattern" | "when">;
+type $ZodCheckUUIDv4Params = CheckStringFormatParams<$ZodUUID, "pattern" | "when">;
+declare function _uuidv4<T extends $ZodUUID>(Class: SchemaClass<T>, params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params): T;
+type $ZodUUIDv6Params = StringFormatParams<$ZodUUID, "pattern" | "when">;
+type $ZodCheckUUIDv6Params = CheckStringFormatParams<$ZodUUID, "pattern" | "when">;
+declare function _uuidv6<T extends $ZodUUID>(Class: SchemaClass<T>, params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params): T;
+type $ZodUUIDv7Params = StringFormatParams<$ZodUUID, "pattern" | "when">;
+type $ZodCheckUUIDv7Params = CheckStringFormatParams<$ZodUUID, "pattern" | "when">;
+declare function _uuidv7<T extends $ZodUUID>(Class: SchemaClass<T>, params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params): T;
+type $ZodURLParams = StringFormatParams<$ZodURL, "when">;
+type $ZodCheckURLParams = CheckStringFormatParams<$ZodURL, "when">;
+declare function _url<T extends $ZodURL>(Class: SchemaClass<T>, params?: string | $ZodURLParams | $ZodCheckURLParams): T;
+type $ZodEmojiParams = StringFormatParams<$ZodEmoji, "when">;
+type $ZodCheckEmojiParams = CheckStringFormatParams<$ZodEmoji, "when">;
+declare function _emoji<T extends $ZodEmoji>(Class: SchemaClass<T>, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams): T;
+type $ZodNanoIDParams = StringFormatParams<$ZodNanoID, "when" | "pattern">;
+type $ZodCheckNanoIDParams = CheckStringFormatParams<$ZodNanoID, "when" | "pattern">;
+declare function _nanoid<T extends $ZodNanoID>(Class: SchemaClass<T>, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams): T;
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link _cuid2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+type $ZodCUIDParams = StringFormatParams<$ZodCUID, "when">;
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link _cuid2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+type $ZodCheckCUIDParams = CheckStringFormatParams<$ZodCUID, "when">;
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link _cuid2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+declare function _cuid<T extends $ZodCUID>(Class: SchemaClass<T>, params?: string | $ZodCUIDParams | $ZodCheckCUIDParams): T;
+type $ZodCUID2Params = StringFormatParams<$ZodCUID2, "when">;
+type $ZodCheckCUID2Params = CheckStringFormatParams<$ZodCUID2, "when">;
+declare function _cuid2<T extends $ZodCUID2>(Class: SchemaClass<T>, params?: string | $ZodCUID2Params | $ZodCheckCUID2Params): T;
+type $ZodULIDParams = StringFormatParams<$ZodULID, "when">;
+type $ZodCheckULIDParams = CheckStringFormatParams<$ZodULID, "when">;
+declare function _ulid<T extends $ZodULID>(Class: SchemaClass<T>, params?: string | $ZodULIDParams | $ZodCheckULIDParams): T;
+type $ZodXIDParams = StringFormatParams<$ZodXID, "when">;
+type $ZodCheckXIDParams = CheckStringFormatParams<$ZodXID, "when">;
+declare function _xid<T extends $ZodXID>(Class: SchemaClass<T>, params?: string | $ZodXIDParams | $ZodCheckXIDParams): T;
+type $ZodKSUIDParams = StringFormatParams<$ZodKSUID, "when">;
+type $ZodCheckKSUIDParams = CheckStringFormatParams<$ZodKSUID, "when">;
+declare function _ksuid<T extends $ZodKSUID>(Class: SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;
+type $ZodIPv4Params = StringFormatParams<$ZodIPv4, "pattern" | "when" | "version">;
+type $ZodCheckIPv4Params = CheckStringFormatParams<$ZodIPv4, "pattern" | "when" | "version">;
+declare function _ipv4<T extends $ZodIPv4>(Class: SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;
+type $ZodIPv6Params = StringFormatParams<$ZodIPv6, "pattern" | "when" | "version">;
+type $ZodCheckIPv6Params = CheckStringFormatParams<$ZodIPv6, "pattern" | "when" | "version">;
+declare function _ipv6<T extends $ZodIPv6>(Class: SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;
+type $ZodMACParams = StringFormatParams<$ZodMAC, "pattern" | "when">;
+type $ZodCheckMACParams = CheckStringFormatParams<$ZodMAC, "pattern" | "when">;
+declare function _mac<T extends $ZodMAC>(Class: SchemaClass<T>, params?: string | $ZodMACParams | $ZodCheckMACParams): T;
+type $ZodCIDRv4Params = StringFormatParams<$ZodCIDRv4, "pattern" | "when">;
+type $ZodCheckCIDRv4Params = CheckStringFormatParams<$ZodCIDRv4, "pattern" | "when">;
+declare function _cidrv4<T extends $ZodCIDRv4>(Class: SchemaClass<T>, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params): T;
+type $ZodCIDRv6Params = StringFormatParams<$ZodCIDRv6, "pattern" | "when">;
+type $ZodCheckCIDRv6Params = CheckStringFormatParams<$ZodCIDRv6, "pattern" | "when">;
+declare function _cidrv6<T extends $ZodCIDRv6>(Class: SchemaClass<T>, params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params): T;
+type $ZodBase64Params = StringFormatParams<$ZodBase64, "pattern" | "when">;
+type $ZodCheckBase64Params = CheckStringFormatParams<$ZodBase64, "pattern" | "when">;
+declare function _base64<T extends $ZodBase64>(Class: SchemaClass<T>, params?: string | $ZodBase64Params | $ZodCheckBase64Params): T;
+type $ZodBase64URLParams = StringFormatParams<$ZodBase64URL, "pattern" | "when">;
+type $ZodCheckBase64URLParams = CheckStringFormatParams<$ZodBase64URL, "pattern" | "when">;
+declare function _base64url<T extends $ZodBase64URL>(Class: SchemaClass<T>, params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams): T;
+type $ZodE164Params = StringFormatParams<$ZodE164, "when">;
+type $ZodCheckE164Params = CheckStringFormatParams<$ZodE164, "when">;
+declare function _e164<T extends $ZodE164>(Class: SchemaClass<T>, params?: string | $ZodE164Params | $ZodCheckE164Params): T;
+type $ZodCreditCardParams = StringFormatParams<$ZodCreditCard, "pattern" | "when">;
+type $ZodCheckCreditCardParams = CheckStringFormatParams<$ZodCreditCard, "pattern" | "when">;
+declare function _creditCard<T extends $ZodCreditCard>(Class: SchemaClass<T>, params?: string | $ZodCreditCardParams | $ZodCheckCreditCardParams): T;
+type $ZodIBANParams = StringFormatParams<$ZodIBAN, "pattern" | "when">;
+type $ZodCheckIBANParams = CheckStringFormatParams<$ZodIBAN, "pattern" | "when">;
+declare function _iban<T extends $ZodIBAN>(Class: SchemaClass<T>, params?: string | $ZodIBANParams | $ZodCheckIBANParams): T;
+type $ZodJWTParams = StringFormatParams<$ZodJWT, "pattern" | "when">;
+type $ZodCheckJWTParams = CheckStringFormatParams<$ZodJWT, "pattern" | "when">;
+declare function _jwt<T extends $ZodJWT>(Class: SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;
+declare const TimePrecision: {
+  readonly Any: null;
+  readonly Minute: -1;
+  readonly Second: 0;
+  readonly Millisecond: 3;
+  readonly Microsecond: 6;
+};
+type $ZodISODateTimeParams = StringFormatParams<$ZodISODateTime, "pattern" | "when">;
+type $ZodCheckISODateTimeParams = CheckStringFormatParams<$ZodISODateTime, "pattern" | "when">;
+declare function _isoDateTime<T extends $ZodISODateTime>(Class: SchemaClass<T>, params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams): T;
+type $ZodISODateParams = StringFormatParams<$ZodISODate, "pattern" | "when">;
+type $ZodCheckISODateParams = CheckStringFormatParams<$ZodISODate, "pattern" | "when">;
+declare function _isoDate<T extends $ZodISODate>(Class: SchemaClass<T>, params?: string | $ZodISODateParams | $ZodCheckISODateParams): T;
+type $ZodISOTimeParams = StringFormatParams<$ZodISOTime, "pattern" | "when">;
+type $ZodCheckISOTimeParams = CheckStringFormatParams<$ZodISOTime, "pattern" | "when">;
+declare function _isoTime<T extends $ZodISOTime>(Class: SchemaClass<T>, params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams): T;
+type $ZodISODurationParams = StringFormatParams<$ZodISODuration, "when">;
+type $ZodCheckISODurationParams = CheckStringFormatParams<$ZodISODuration, "when">;
+declare function _isoDuration<T extends $ZodISODuration>(Class: SchemaClass<T>, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams): T;
+type $ZodNumberParams = TypeParams<$ZodNumber<number>, "coerce"> & {
+  checks?: readonly $ZodCheck<number>[];
+};
+type $ZodNumberFormatParams = CheckTypeParams<$ZodNumberFormat, "format" | "coerce">;
+type $ZodCheckNumberFormatParams = CheckParams<$ZodCheckNumberFormat, "format" | "when">;
+declare function _number<T extends $ZodNumber>(Class: SchemaClass<T>, params?: string | $ZodNumberParams): T;
+declare function _coercedNumber<T extends $ZodNumber>(Class: SchemaClass<T>, params?: string | $ZodNumberParams): T;
+declare function _int<T extends $ZodNumberFormat>(Class: SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
+declare function _float32<T extends $ZodNumberFormat>(Class: SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
+declare function _float64<T extends $ZodNumberFormat>(Class: SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
+declare function _int32<T extends $ZodNumberFormat>(Class: SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
+declare function _uint32<T extends $ZodNumberFormat>(Class: SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
+type $ZodBooleanParams = TypeParams<$ZodBoolean<boolean>, "coerce">;
+declare function _boolean<T extends $ZodBoolean>(Class: SchemaClass<T>, params?: string | $ZodBooleanParams): T;
+declare function _coercedBoolean<T extends $ZodBoolean>(Class: SchemaClass<T>, params?: string | $ZodBooleanParams): T;
+type $ZodBigIntParams = TypeParams<$ZodBigInt<bigint>>;
+type $ZodBigIntFormatParams = CheckTypeParams<$ZodBigIntFormat, "format" | "coerce">;
+type $ZodCheckBigIntFormatParams = CheckParams<$ZodCheckBigIntFormat, "format" | "when">;
+declare function _bigint<T extends $ZodBigInt>(Class: SchemaClass<T>, params?: string | $ZodBigIntParams): T;
+declare function _coercedBigint<T extends $ZodBigInt>(Class: SchemaClass<T>, params?: string | $ZodBigIntParams): T;
+declare function _int64<T extends $ZodBigIntFormat>(Class: SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;
+declare function _uint64<T extends $ZodBigIntFormat>(Class: SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;
+type $ZodSymbolParams = TypeParams<$ZodSymbol>;
+declare function _symbol<T extends $ZodSymbol>(Class: SchemaClass<T>, params?: string | $ZodSymbolParams): T;
+type $ZodUndefinedParams = TypeParams<$ZodUndefined>;
+declare function _undefined<T extends $ZodUndefined>(Class: SchemaClass<T>, params?: string | $ZodUndefinedParams): T;
+type $ZodNullParams = TypeParams<$ZodNull>;
+declare function _null<T extends $ZodNull>(Class: SchemaClass<T>, params?: string | $ZodNullParams): T;
+type $ZodAnyParams = TypeParams<$ZodAny>;
+declare function _any<T extends $ZodAny>(Class: SchemaClass<T>): T;
+type $ZodUnknownParams = TypeParams<$ZodUnknown>;
+declare function _unknown<T extends $ZodUnknown>(Class: SchemaClass<T>): T;
+type $ZodNeverParams = TypeParams<$ZodNever>;
+declare function _never<T extends $ZodNever>(Class: SchemaClass<T>, params?: string | $ZodNeverParams): T;
+type $ZodVoidParams = TypeParams<$ZodVoid>;
+declare function _void<T extends $ZodVoid>(Class: SchemaClass<T>, params?: string | $ZodVoidParams): T;
+type $ZodDateParams = TypeParams<$ZodDate, "coerce">;
+declare function _date<T extends $ZodDate>(Class: SchemaClass<T>, params?: string | $ZodDateParams): T;
+declare function _coercedDate<T extends $ZodDate>(Class: SchemaClass<T>, params?: string | $ZodDateParams): T;
+type $ZodNaNParams = TypeParams<$ZodNaN>;
+declare function _nan<T extends $ZodNaN>(Class: SchemaClass<T>, params?: string | $ZodNaNParams): T;
+type $ZodCheckLessThanParams = CheckParams<$ZodCheckLessThan, "inclusive" | "value" | "when">;
+declare function _lt(value: Numeric, params?: string | $ZodCheckLessThanParams): $ZodCheckLessThan<Numeric>;
+declare function _lte(value: Numeric, params?: string | $ZodCheckLessThanParams): $ZodCheckLessThan<Numeric>;
+type $ZodCheckGreaterThanParams = CheckParams<$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
+declare function _gt(value: Numeric, params?: string | $ZodCheckGreaterThanParams): $ZodCheckGreaterThan;
+declare function _gte(value: Numeric, params?: string | $ZodCheckGreaterThanParams): $ZodCheckGreaterThan;
+declare function _positive(params?: string | $ZodCheckGreaterThanParams): $ZodCheckGreaterThan;
+declare function _negative(params?: string | $ZodCheckLessThanParams): $ZodCheckLessThan;
+declare function _nonpositive(params?: string | $ZodCheckLessThanParams): $ZodCheckLessThan;
+declare function _nonnegative(params?: string | $ZodCheckGreaterThanParams): $ZodCheckGreaterThan;
+type $ZodCheckMultipleOfParams = CheckParams<$ZodCheckMultipleOf, "value" | "when">;
+declare function _multipleOf(value: number | bigint, params?: string | $ZodCheckMultipleOfParams): $ZodCheckMultipleOf;
+type $ZodCheckMaxSizeParams = CheckParams<$ZodCheckMaxSize, "maximum" | "when">;
+declare function _maxSize(maximum: number, params?: string | $ZodCheckMaxSizeParams): $ZodCheckMaxSize<HasSize>;
+type $ZodCheckMinSizeParams = CheckParams<$ZodCheckMinSize, "minimum" | "when">;
+declare function _minSize(minimum: number, params?: string | $ZodCheckMinSizeParams): $ZodCheckMinSize<HasSize>;
+type $ZodCheckSizeEqualsParams = CheckParams<$ZodCheckSizeEquals, "size" | "when">;
+declare function _size(size: number, params?: string | $ZodCheckSizeEqualsParams): $ZodCheckSizeEquals<HasSize>;
 type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum" | "when">;
+declare function _maxLength(maximum: number, params?: string | $ZodCheckMaxLengthParams): $ZodCheckMaxLength<HasLength>;
 type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum" | "when">;
+declare function _minLength(minimum: number, params?: string | $ZodCheckMinLengthParams): $ZodCheckMinLength<HasLength>;
 type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length" | "when">;
+declare function _length(length: number, params?: string | $ZodCheckLengthEqualsParams): $ZodCheckLengthEquals<HasLength>;
+type $ZodCheckRegexParams = CheckParams<$ZodCheckRegex, "format" | "pattern" | "when">;
+declare function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): $ZodCheckRegex;
+type $ZodCheckLowerCaseParams = CheckParams<$ZodCheckLowerCase, "format" | "when">;
+declare function _lowercase(params?: string | $ZodCheckLowerCaseParams): $ZodCheckLowerCase;
+type $ZodCheckUpperCaseParams = CheckParams<$ZodCheckUpperCase, "format" | "when">;
+declare function _uppercase(params?: string | $ZodCheckUpperCaseParams): $ZodCheckUpperCase;
+type $ZodCheckIncludesParams = CheckParams<$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
+declare function _includes(includes: string, params?: string | $ZodCheckIncludesParams): $ZodCheckIncludes;
+type $ZodCheckStartsWithParams = CheckParams<$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
+declare function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): $ZodCheckStartsWith;
+type $ZodCheckEndsWithParams = CheckParams<$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
+declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): $ZodCheckEndsWith;
+type $ZodCheckPropertyParams = CheckParams<$ZodCheckProperty, "property" | "schema" | "when">;
+declare function _property<K extends string, T extends $ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): $ZodCheckProperty<{ [k in K]: Widen<input<T>>; }>;
+type $ZodCheckPropertiesParams = CheckParams<$ZodCheckProperties, "shape" | "when">;
+declare function _properties<Shape extends $ZodShape>(shape: Shape, params?: string | $ZodCheckPropertiesParams): $ZodCheckProperties<Shape>;
+type $ZodCheckMimeTypeParams = CheckParams<$ZodCheckMimeType, "mime" | "when">;
+declare function _mime(types: MimeTypes[], params?: string | $ZodCheckMimeTypeParams): $ZodCheckMimeType;
+declare function _overwrite<T>(tx: (input: T) => T): $ZodCheckOverwrite<T>;
+declare function _normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): $ZodCheckOverwrite<string>;
+declare function _trim(): $ZodCheckOverwrite<string>;
+declare function _toLowerCase(): $ZodCheckOverwrite<string>;
+declare function _toUpperCase(): $ZodCheckOverwrite<string>;
+declare function _slugify(): $ZodCheckOverwrite<string>;
+type $ZodArrayParams = TypeParams<$ZodArray, "element">;
+declare function _array<T extends $ZodType>(Class: SchemaClass<$ZodArray>, element: T, params?: string | $ZodArrayParams): $ZodArray<T>;
+type $ZodObjectParams = TypeParams<$ZodObject, "shape" | "catchall">;
+type $ZodUnionParams = TypeParams<$ZodUnion, "options">;
+declare function _union<const T extends readonly $ZodObject[]>(Class: SchemaClass<$ZodUnion>, options: T, params?: string | $ZodUnionParams): $ZodUnion<T>;
+type $ZodXorParams = TypeParams<$ZodXor, "options">;
+declare function _xor<const T extends readonly $ZodObject[]>(Class: SchemaClass<$ZodXor>, options: T, params?: string | $ZodXorParams): $ZodXor<T>;
+interface $ZodTypeDiscriminableInternals<_Disc extends string = string> extends _$ZodTypeInternals {
+  propValues: PropValues;
+}
+interface $ZodTypeDiscriminable<_Disc extends string = string> extends SomeType {
+  _zod: $ZodTypeDiscriminableInternals;
+}
+type $ZodDiscriminatedUnionParams = TypeParams<$ZodDiscriminatedUnion, "options" | "discriminator">;
+declare function _discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]], Disc extends string>(Class: SchemaClass<$ZodDiscriminatedUnion>, discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): $ZodDiscriminatedUnion<Types, Disc>;
+type $ZodIntersectionParams = TypeParams<$ZodIntersection, "left" | "right">;
+declare function _intersection<T extends $ZodObject, U extends $ZodObject>(Class: SchemaClass<$ZodIntersection>, left: T, right: U): $ZodIntersection<T, U>;
+type $ZodTupleParams = TypeParams<$ZodTuple, "items" | "rest">;
+declare function _tuple<T extends readonly [$ZodType, ...$ZodType[]]>(Class: SchemaClass<$ZodTuple>, items: T, params?: string | $ZodTupleParams): $ZodTuple<T, null>;
+declare function _tuple<T extends readonly [$ZodType, ...$ZodType[]], Rest extends $ZodType>(Class: SchemaClass<$ZodTuple>, items: T, rest: Rest, params?: string | $ZodTupleParams): $ZodTuple<T, Rest>;
+type $ZodRecordParams = TypeParams<$ZodRecord, "keyType" | "valueType" | "partial">;
+declare function _record<Key extends $ZodRecordKey, Value extends $ZodObject>(Class: SchemaClass<$ZodRecord>, keyType: Key, valueType: Value, params?: string | $ZodRecordParams): $ZodRecord<Key, Value>;
+type $ZodMapParams = TypeParams<$ZodMap, "keyType" | "valueType">;
+declare function _map<Key extends $ZodObject, Value extends $ZodObject>(Class: SchemaClass<$ZodMap>, keyType: Key, valueType: Value, params?: string | $ZodMapParams): $ZodMap<Key, Value>;
+type $ZodSetParams = TypeParams<$ZodSet, "valueType">;
+declare function _set<Value extends $ZodObject>(Class: SchemaClass<$ZodSet>, valueType: Value, params?: string | $ZodSetParams): $ZodSet<Value>;
+type $ZodEnumParams = TypeParams<$ZodEnum, "entries">;
+declare function _enum<const T extends string[]>(Class: SchemaClass<$ZodEnum>, values: T, params?: string | $ZodEnumParams): $ZodEnum<ToEnum<T[number]>>;
+declare function _enum<T extends EnumLike>(Class: SchemaClass<$ZodEnum>, entries: T, params?: string | $ZodEnumParams): $ZodEnum<T>;
+/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
+ *
+ * ```ts
+ * enum Colors { red, green, blue }
+ * z.enum(Colors);
+ * ```
+ */
+declare function _nativeEnum<T extends EnumLike>(Class: SchemaClass<$ZodEnum>, entries: T, params?: string | $ZodEnumParams): $ZodEnum<T>;
+type $ZodLiteralParams = TypeParams<$ZodLiteral, "values">;
+declare function _literal<const T extends Array<Literal>>(Class: SchemaClass<$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): $ZodLiteral<T[number]>;
+declare function _literal<const T extends Literal>(Class: SchemaClass<$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): $ZodLiteral<T>;
+type $ZodFileParams = TypeParams<$ZodFile>;
+declare function _file(Class: SchemaClass<$ZodFile>, params?: string | $ZodFileParams): $ZodFile;
+type $ZodTransformParams = TypeParams<$ZodTransform, "transform">;
+declare function _transform<I = unknown, O = I>(Class: SchemaClass<$ZodTransform>, fn: (input: I, ctx?: ParsePayload) => O): $ZodTransform<Awaited<O>, I>;
+type $ZodOptionalParams = TypeParams<$ZodOptional, "innerType">;
+declare function _optional<T extends $ZodObject>(Class: SchemaClass<$ZodOptional>, innerType: T): $ZodOptional<T>;
+type $ZodNullableParams = TypeParams<$ZodNullable, "innerType">;
+declare function _nullable<T extends $ZodObject>(Class: SchemaClass<$ZodNullable>, innerType: T): $ZodNullable<T>;
+type $ZodDefaultParams = TypeParams<$ZodDefault, "innerType" | "defaultValue">;
+declare function _default<T extends $ZodObject>(Class: SchemaClass<$ZodDefault>, innerType: T, defaultValue: NoUndefined<output<T>> | (() => NoUndefined<output<T>>)): $ZodDefault<T>;
 type $ZodNonOptionalParams = TypeParams<$ZodNonOptional, "innerType">;
+declare function _nonoptional<T extends $ZodObject>(Class: SchemaClass<$ZodNonOptional>, innerType: T, params?: string | $ZodNonOptionalParams): $ZodNonOptional<T>;
+type $ZodSuccessParams = TypeParams<$ZodSuccess, "innerType">;
+declare function _success<T extends $ZodObject>(Class: SchemaClass<$ZodSuccess>, innerType: T): $ZodSuccess<T>;
+type $ZodCatchParams = TypeParams<$ZodCatch, "innerType" | "catchValue">;
+declare function _catch<T extends $ZodObject>(Class: SchemaClass<$ZodCatch>, innerType: T, catchValue: output<T> | ((ctx: $ZodCatchCtx) => output<T>)): $ZodCatch<T>;
+type $ZodPipeParams = TypeParams<$ZodPipe, "in" | "out">;
+declare function _pipe<const A extends $ZodType, B extends $ZodType<unknown, output<A>> = $ZodType<unknown, output<A>>>(Class: SchemaClass<$ZodPipe>, in_: A, out: B | $ZodType<unknown, output<A>>): $ZodPipe<A, B>;
+type $ZodReadonlyParams = TypeParams<$ZodReadonly, "innerType">;
+declare function _readonly<T extends $ZodObject>(Class: SchemaClass<$ZodReadonly>, innerType: T): $ZodReadonly<T>;
+type $ZodTemplateLiteralParams = TypeParams<$ZodTemplateLiteral, "parts">;
+declare function _templateLiteral<const Parts extends $ZodTemplateLiteralPart[]>(Class: SchemaClass<$ZodTemplateLiteral>, parts: Parts, params?: string | $ZodTemplateLiteralParams): $ZodTemplateLiteral<$PartsToTemplateLiteral<Parts>>;
+type $ZodLazyParams = TypeParams<$ZodLazy, "getter">;
+declare function _lazy<T extends $ZodType>(Class: SchemaClass<$ZodLazy>, getter: () => T): $ZodLazy<T>;
+type $ZodPromiseParams = TypeParams<$ZodPromise, "innerType">;
+declare function _promise<T extends $ZodObject>(Class: SchemaClass<$ZodPromise>, innerType: T): $ZodPromise<T>;
 type $ZodCustomParams = CheckTypeParams<$ZodCustom, "fn">;
+declare function _custom<O = unknown, I = O>(Class: SchemaClass<$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): $ZodCustom<O, I>;
+declare function _refine<O = unknown, I = O>(Class: SchemaClass<$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): $ZodCustom<O, I>;
 type $ZodSuperRefineIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
 type RawIssue<T extends $ZodIssueBase> = T extends any ? Flatten<MakePartial<T, "message" | "path"> & {
   /** The schema or check that originated this issue. */
@@ -1754,6 +3569,99 @@ interface $ZodSuperRefineParams {
   /** If provided, the refinement runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
   when?: ((payload: ParsePayload) => boolean) | undefined;
 }
+declare function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>, params?: $ZodSuperRefineParams): $ZodCheck<T>;
+declare function _check<O = unknown>(fn: CheckFn<O>, params?: string | $ZodCustomParams): $ZodCheck<O>;
+declare function describe<T>(description: string): $ZodCheck<T>;
+declare function meta$1<T>(metadata: GlobalMeta): $ZodCheck<T>;
+interface $ZodStringBoolParams extends TypeParams {
+  truthy?: string[];
+  falsy?: string[];
+  /**
+   * Options: `"sensitive"`, `"insensitive"`
+   *
+   * @default `"insensitive"`
+   */
+  case?: "sensitive" | "insensitive" | undefined;
+}
+declare function _stringbool(Classes: {
+  Codec?: typeof $ZodCodec;
+  Boolean?: typeof $ZodBoolean;
+  String?: typeof $ZodString;
+}, _params?: string | $ZodStringBoolParams): $ZodCodec<$ZodString, $ZodBoolean>;
+declare function _stringFormat<Format extends string>(Class: typeof $ZodCustomStringFormat, format: Format, fnOrRegex: ((arg: string) => MaybeAsync<unknown>) | RegExp, _params?: string | $ZodStringFormatParams): $ZodCustomStringFormat<Format>;
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/json-schema-processors.d.cts
+declare function toJSONSchema<T extends $ZodType>(schema: T, params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<T>;
+declare function toJSONSchema(registry: $ZodRegistry<{
+  id?: string | undefined;
+}>, params?: RegistryToJSONSchemaParams): {
+  schemas: Record<string, ZodStandardJSONSchemaPayload<$ZodType>>;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/json-schema-generator.d.cts
+/**
+ * Parameters for the emit method of JSONSchemaGenerator.
+ * @deprecated Use toJSONSchema function instead
+ */
+type EmitParams = Pick<JSONSchemaGeneratorParams, "cycles" | "reused" | "external">;
+/**
+ * Parameters for JSONSchemaGenerator constructor.
+ * @deprecated Use toJSONSchema function instead
+ */
+type JSONSchemaGeneratorConstructorParams = Pick<JSONSchemaGeneratorParams, "metadata" | "target" | "unrepresentable" | "override" | "io">;
+/**
+ * Legacy class-based interface for JSON Schema generation.
+ * This class wraps the new functional implementation to provide backward compatibility.
+ *
+ * @deprecated Use the `toJSONSchema` function instead for new code.
+ *
+ * @example
+ * ```typescript
+ * // Legacy usage (still supported)
+ * const gen = new JSONSchemaGenerator({ target: "draft-07" });
+ * gen.process(schema);
+ * const result = gen.emit(schema);
+ *
+ * // Preferred modern usage
+ * const result = toJSONSchema(schema, { target: "draft-07" });
+ * ```
+ */
+declare class JSONSchemaGenerator {
+  private ctx;
+  /** @deprecated Access via ctx instead */
+  get metadataRegistry(): $ZodRegistry<Record<string, any>>;
+  /** @deprecated Access via ctx instead */
+  get target(): ({} & string) | "draft-2020-12" | "draft-07" | "openapi-3.0" | "draft-04";
+  /** @deprecated Access via ctx instead */
+  get unrepresentable(): ToJSONSchemaContext["unrepresentable"];
+  /** @deprecated Access via ctx instead */
+  get override(): (ctx: {
+    zodSchema: $ZodType;
+    jsonSchema: BaseSchema;
+    path: (string | number)[];
+  }) => void;
+  /** @deprecated Access via ctx instead */
+  get io(): "input" | "output";
+  /** @deprecated Access via ctx instead */
+  get counter(): number;
+  set counter(value: number);
+  /** @deprecated Access via ctx instead */
+  get seen(): Map<$ZodType, Seen>;
+  constructor(params?: JSONSchemaGeneratorConstructorParams);
+  /**
+   * Process a schema to prepare it for JSON Schema generation.
+   * This must be called before emit().
+   */
+  process(schema: $ZodType, _params?: ProcessParams): BaseSchema;
+  /**
+   * Emit the final JSON Schema after processing.
+   * Must call process() first.
+   */
+  emit(schema: $ZodType, _params?: EmitParams): BaseSchema;
+}
+declare namespace index_d_exports {
+  export { $Decode, $DecodeAsync, $DiscriminatedOption, $DiscriminatorValue, $Encode, $EncodeAsync, $InferEnumInput, $InferEnumOutput, $InferInnerFunctionType, $InferInnerFunctionTypeAsync, $InferObjectInput, $InferObjectOutput, $InferOuterFunctionType, $InferOuterFunctionTypeAsync, $InferTupleInputType, $InferTupleOutputType, $InferUnionInput, $InferUnionOutput, $InferZodRecordInput, $InferZodRecordOutput, $Parse, $ParseAsync, $PartsToTemplateLiteral, $RefinementCtx, $SafeDecode, $SafeDecodeAsync, $SafeEncode, $SafeEncodeAsync, $SafeParse, $SafeParseAsync, $Validate, $ValidateAsync, $ZodAny, $ZodAnyDef, $ZodAnyInternals, $ZodAnyParams, $ZodArray, $ZodArrayDef, $ZodArrayInternals, $ZodArrayParams, $ZodAsyncError, $ZodBase64, $ZodBase64Def, $ZodBase64Internals, $ZodBase64Params, $ZodBase64URL, $ZodBase64URLDef, $ZodBase64URLInternals, $ZodBase64URLParams, $ZodBigInt, $ZodBigIntDef, $ZodBigIntFormat, $ZodBigIntFormatDef, $ZodBigIntFormatInternals, $ZodBigIntFormatParams, $ZodBigIntFormats, $ZodBigIntInternals, $ZodBigIntParams, $ZodBoolean, $ZodBooleanDef, $ZodBooleanInternals, $ZodBooleanParams, $ZodBranded, $ZodCIDRv4, $ZodCIDRv4Def, $ZodCIDRv4Internals, $ZodCIDRv4Params, $ZodCIDRv6, $ZodCIDRv6Def, $ZodCIDRv6Internals, $ZodCIDRv6Params, $ZodCUID, $ZodCUID2, $ZodCUID2Def, $ZodCUID2Internals, $ZodCUID2Params, $ZodCUIDDef, $ZodCUIDInternals, $ZodCUIDParams, $ZodCatch, $ZodCatchCtx, $ZodCatchDef, $ZodCatchInternals, $ZodCatchParams, $ZodCheck, $ZodCheckBase64Params, $ZodCheckBase64URLParams, $ZodCheckBigIntFormat, $ZodCheckBigIntFormatDef, $ZodCheckBigIntFormatInternals, $ZodCheckBigIntFormatParams, $ZodCheckCIDRv4Params, $ZodCheckCIDRv6Params, $ZodCheckCUID2Params, $ZodCheckCUIDParams, $ZodCheckCreditCardParams, $ZodCheckDef, $ZodCheckE164Params, $ZodCheckEmailParams, $ZodCheckEmojiParams, $ZodCheckEndsWith, $ZodCheckEndsWithDef, $ZodCheckEndsWithInternals, $ZodCheckEndsWithParams, $ZodCheckGUIDParams, $ZodCheckGreaterThan, $ZodCheckGreaterThanDef, $ZodCheckGreaterThanInternals, $ZodCheckGreaterThanParams, $ZodCheckIBANParams, $ZodCheckIPv4Params, $ZodCheckIPv6Params, $ZodCheckISODateParams, $ZodCheckISODateTimeParams, $ZodCheckISODurationParams, $ZodCheckISOTimeParams, $ZodCheckIncludes, $ZodCheckIncludesDef, $ZodCheckIncludesInternals, $ZodCheckIncludesParams, $ZodCheckInternals, $ZodCheckJWTParams, $ZodCheckKSUIDParams, $ZodCheckLengthEquals, $ZodCheckLengthEqualsDef, $ZodCheckLengthEqualsInternals, $ZodCheckLengthEqualsParams, $ZodCheckLessThan, $ZodCheckLessThanDef, $ZodCheckLessThanInternals, $ZodCheckLessThanParams, $ZodCheckLowerCase, $ZodCheckLowerCaseDef, $ZodCheckLowerCaseInternals, $ZodCheckLowerCaseParams, $ZodCheckMACParams, $ZodCheckMaxLength, $ZodCheckMaxLengthDef, $ZodCheckMaxLengthInternals, $ZodCheckMaxLengthParams, $ZodCheckMaxSize, $ZodCheckMaxSizeDef, $ZodCheckMaxSizeInternals, $ZodCheckMaxSizeParams, $ZodCheckMimeType, $ZodCheckMimeTypeDef, $ZodCheckMimeTypeInternals, $ZodCheckMimeTypeParams, $ZodCheckMinLength, $ZodCheckMinLengthDef, $ZodCheckMinLengthInternals, $ZodCheckMinLengthParams, $ZodCheckMinSize, $ZodCheckMinSizeDef, $ZodCheckMinSizeInternals, $ZodCheckMinSizeParams, $ZodCheckMultipleOf, $ZodCheckMultipleOfDef, $ZodCheckMultipleOfInternals, $ZodCheckMultipleOfParams, $ZodCheckNanoIDParams, $ZodCheckNumberFormat, $ZodCheckNumberFormatDef, $ZodCheckNumberFormatInternals, $ZodCheckNumberFormatParams, $ZodCheckOverwrite, $ZodCheckOverwriteDef, $ZodCheckOverwriteInternals, $ZodCheckProperties, $ZodCheckPropertiesDef, $ZodCheckPropertiesInput, $ZodCheckPropertiesInternals, $ZodCheckPropertiesParams, $ZodCheckProperty, $ZodCheckPropertyDef, $ZodCheckPropertyInternals, $ZodCheckPropertyParams, $ZodCheckRegex, $ZodCheckRegexDef, $ZodCheckRegexInternals, $ZodCheckRegexParams, $ZodCheckSizeEquals, $ZodCheckSizeEqualsDef, $ZodCheckSizeEqualsInternals, $ZodCheckSizeEqualsParams, $ZodCheckStartsWith, $ZodCheckStartsWithDef, $ZodCheckStartsWithInternals, $ZodCheckStartsWithParams, $ZodCheckStringFormat, $ZodCheckStringFormatDef, $ZodCheckStringFormatInternals, $ZodCheckStringFormatParams, $ZodCheckULIDParams, $ZodCheckURLParams, $ZodCheckUUIDParams, $ZodCheckUUIDv4Params, $ZodCheckUUIDv6Params, $ZodCheckUUIDv7Params, $ZodCheckUpperCase, $ZodCheckUpperCaseDef, $ZodCheckUpperCaseInternals, $ZodCheckUpperCaseParams, $ZodCheckXIDParams, $ZodChecks, $ZodCodec, $ZodCodecDef, $ZodCodecInternals, $ZodConfig, $ZodCreditCard, $ZodCreditCardDef, $ZodCreditCardInternals, $ZodCreditCardParams, $ZodCustom, $ZodCustomDef, $ZodCustomInternals, $ZodCustomParams, $ZodCustomStringFormat, $ZodCustomStringFormatDef, $ZodCustomStringFormatInternals, $ZodCyclicError, $ZodDate, $ZodDateDef, $ZodDateInternals, $ZodDateParams, $ZodDefault, $ZodDefaultDef, $ZodDefaultInternals, $ZodDefaultParams, $ZodDiscriminatedUnion, $ZodDiscriminatedUnionDef, $ZodDiscriminatedUnionInternals, $ZodDiscriminatedUnionParams, $ZodE164, $ZodE164Def, $ZodE164Internals, $ZodE164Params, $ZodEmail, $ZodEmailDef, $ZodEmailInternals, $ZodEmailParams, $ZodEmoji, $ZodEmojiDef, $ZodEmojiInternals, $ZodEmojiParams, $ZodEncodeError, $ZodEnum, $ZodEnumDef, $ZodEnumInternals, $ZodEnumParams, $ZodError, $ZodErrorClass, $ZodErrorMap, $ZodErrorTree, $ZodExactOptional, $ZodExactOptionalDef, $ZodExactOptionalInternals, $ZodFile, $ZodFileDef, $ZodFileInternals, $ZodFileParams, $ZodFlattenedError, $ZodFormattedError, $ZodFunction, $ZodFunctionArgs, $ZodFunctionDef, $ZodFunctionIn, $ZodFunctionInternals, $ZodFunctionOut, $ZodFunctionParams, $ZodGUID, $ZodGUIDDef, $ZodGUIDInternals, $ZodGUIDParams, $ZodIBAN, $ZodIBANDef, $ZodIBANInternals, $ZodIBANParams, $ZodIPv4, $ZodIPv4Def, $ZodIPv4Internals, $ZodIPv4Params, $ZodIPv6, $ZodIPv6Def, $ZodIPv6Internals, $ZodIPv6Params, $ZodISODate, $ZodISODateDef, $ZodISODateInternals, $ZodISODateParams, $ZodISODateTime, $ZodISODateTimeDef, $ZodISODateTimeInternals, $ZodISODateTimeParams, $ZodISODuration, $ZodISODurationDef, $ZodISODurationInternals, $ZodISODurationParams, $ZodISOTime, $ZodISOTimeDef, $ZodISOTimeInternals, $ZodISOTimeParams, $ZodInternalIssue, $ZodIntersection, $ZodIntersectionDef, $ZodIntersectionInternals, $ZodIntersectionParams, $ZodInvalidTypeExpected, $ZodIssue, $ZodIssueBase, $ZodIssueCode, $ZodIssueCustom, $ZodIssueInvalidElement, $ZodIssueInvalidKey, $ZodIssueInvalidStringFormat, $ZodIssueInvalidType, $ZodIssueInvalidUnion, $ZodIssueInvalidValue, $ZodIssueNotMultipleOf, $ZodIssueStringCommonFormats, $ZodIssueStringEndsWith, $ZodIssueStringIncludes, $ZodIssueStringInvalidJWT, $ZodIssueStringInvalidRegex, $ZodIssueStringStartsWith, $ZodIssueTooBig, $ZodIssueTooSmall, $ZodIssueUnrecognizedKeys, $ZodJWT, $ZodJWTDef, $ZodJWTInternals, $ZodJWTParams, $ZodKSUID, $ZodKSUIDDef, $ZodKSUIDInternals, $ZodKSUIDParams, $ZodLazy, $ZodLazyDef, $ZodLazyInternals, $ZodLazyParams, $ZodLiteral, $ZodLiteralDef, $ZodLiteralInternals, $ZodLiteralParams, $ZodLooseShape, $ZodMAC, $ZodMACDef, $ZodMACInternals, $ZodMACParams, $ZodMap, $ZodMapDef, $ZodMapInternals, $ZodMapParams, $ZodMemoizer, $ZodNaN, $ZodNaNDef, $ZodNaNInternals, $ZodNaNParams, $ZodNanoID, $ZodNanoIDDef, $ZodNanoIDInternals, $ZodNanoIDParams, $ZodNarrow, $ZodNever, $ZodNeverDef, $ZodNeverInternals, $ZodNeverParams, $ZodNonOptional, $ZodNonOptionalDef, $ZodNonOptionalInternals, $ZodNonOptionalParams, $ZodNull, $ZodNullDef, $ZodNullInternals, $ZodNullParams, $ZodNullable, $ZodNullableDef, $ZodNullableInternals, $ZodNullableParams, $ZodNumber, $ZodNumberDef, $ZodNumberFormat, $ZodNumberFormatDef, $ZodNumberFormatInternals, $ZodNumberFormatParams, $ZodNumberFormats, $ZodNumberInternals, $ZodNumberParams, $ZodObject, $ZodObjectConfig, $ZodObjectDef, $ZodObjectInternals, $ZodObjectJIT, $ZodObjectParams, $ZodOptional, $ZodOptionalDef, $ZodOptionalInternals, $ZodOptionalParams, $ZodPipe, $ZodPipeDef, $ZodPipeInternals, $ZodPipeParams, $ZodPrefault, $ZodPrefaultDef, $ZodPrefaultInternals, $ZodPreprocess, $ZodPreprocessDef, $ZodPreprocessInternals, $ZodPromise, $ZodPromiseDef, $ZodPromiseInternals, $ZodPromiseParams, $ZodRawIssue, $ZodReadonly, $ZodReadonlyDef, $ZodReadonlyInternals, $ZodReadonlyParams, $ZodRealError, $ZodRecord, $ZodRecordDef, $ZodRecordInternals, $ZodRecordKey, $ZodRecordParams, $ZodRegistry, $ZodSet, $ZodSetDef, $ZodSetInternals, $ZodSetParams, $ZodShape, $ZodStandardSchema, $ZodString, $ZodStringBoolParams, $ZodStringDef, $ZodStringFormat, $ZodStringFormatChecks, $ZodStringFormatDef, $ZodStringFormatInternals, $ZodStringFormatIssues, $ZodStringFormatParams, $ZodStringFormatTypes, $ZodStringFormats, $ZodStringInternals, $ZodStringParams, $ZodSuccess, $ZodSuccessDef, $ZodSuccessInternals, $ZodSuccessParams, $ZodSuperRefineIssue, $ZodSuperRefineParams, $ZodSymbol, $ZodSymbolDef, $ZodSymbolInternals, $ZodSymbolParams, $ZodTemplateLiteral, $ZodTemplateLiteralDef, $ZodTemplateLiteralInternals, $ZodTemplateLiteralParams, $ZodTemplateLiteralPart, $ZodTransform, $ZodTransformDef, $ZodTransformInternals, $ZodTransformParams, $ZodTuple, $ZodTupleDef, $ZodTupleInternals, $ZodTupleParams, $ZodType, $ZodTypeDef, $ZodTypeDiscriminable, $ZodTypeDiscriminableInternals, $ZodTypeInternals, $ZodTypes, $ZodULID, $ZodULIDDef, $ZodULIDInternals, $ZodULIDParams, $ZodURL, $ZodURLDef, $ZodURLInternals, $ZodURLParams, $ZodUUID, $ZodUUIDDef, $ZodUUIDInternals, $ZodUUIDParams, $ZodUUIDv4Params, $ZodUUIDv6Params, $ZodUUIDv7Params, $ZodUndefined, $ZodUndefinedDef, $ZodUndefinedInternals, $ZodUndefinedParams, $ZodUnion, $ZodUnionDef, $ZodUnionInternals, $ZodUnionParams, $ZodUnknown, $ZodUnknownDef, $ZodUnknownInternals, $ZodUnknownParams, $ZodVoid, $ZodVoidDef, $ZodVoidInternals, $ZodVoidParams, $ZodXID, $ZodXIDDef, $ZodXIDInternals, $ZodXIDParams, $ZodXor, $ZodXorInternals, $ZodXorParams, $brand, $catchall, $constructor, $constructorParams, $input, $loose, $output, $partial, $replace, $strict, $strip, CheckFn, CheckParams, CheckStringFormatParams, CheckTypeParams, CompileOptions, ConcatenateTupleOfStrings, ConvertPartsToStringTuple, Doc, File, GlobalMeta, INVALID, json_schema_d_exports as JSONSchema, JSONSchemaGenerator, JSONSchemaGeneratorParams, JSONSchemaMeta, NEVER, Params, ParseContext, ParseContextInternal, ParsePayload, ProcessParams, Processor, RegistryToJSONSchemaParams, Seen, SomeType, StringFormatParams, TimePrecision, ToJSONSchemaContext, ToJSONSchemaParams, ToTemplateLiteral, TypeParams, URL_BAD_FORMAT, URL_UNPARSEABLE, UnrepresentableHandler, ZodCompileAsyncError, ZodCompileUnsupportedError, ZodStandardJSONSchemaPayload, ZodStandardSchemaWithJSON$1 as ZodStandardSchemaWithJSON, _$ZodType, _$ZodTypeInternals, _any, _array, _base64, _base64url, _bigint, _boolean, _catch, _check, _cidrv4, _cidrv6, _coercedBigint, _coercedBoolean, _coercedDate, _coercedNumber, _coercedString, _creditCard, _cuid, _cuid2, _custom, _date, _decode, _decodeAsync, _default, _discriminatedUnion, _e164, _email, _emoji, _encode, _encodeAsync, _endsWith, _enum, _file, _float32, _float64, _gt, _gte, _guid, _iban, _includes, _int, _int32, _int64, _intersection, _ipv4, _ipv6, _isoDate, _isoDateTime, _isoDuration, _isoTime, _jwt, _ksuid, _lazy, _length, _literal, _lowercase, _lt, _lte, _mac, _map, _lte as _max, _maxLength, _maxSize, _mime, _gte as _min, _minLength, _minSize, _multipleOf, _nan, _nanoid, _nativeEnum, _negative, _never, _nonnegative, _nonoptional, _nonpositive, _normalize, _null, _nullable, _number, _optional, _overwrite, _parse, _parseAsync, _pipe, _positive, _promise, _properties, _property, _readonly, _record, _refine, _regex, _safeDecode, _safeDecodeAsync, _safeEncode, _safeEncodeAsync, _safeParse, _safeParseAsync, _set, _size, _slugify, _startsWith, _string, _stringFormat, _stringbool, _success, _superRefine, _symbol, _templateLiteral, _toLowerCase, _toUpperCase, _transform, _trim, _tuple, _uint32, _uint64, _ulid, _undefined, _union, _unknown, _uppercase, _url, _uuid, _uuidv4, _uuidv6, _uuidv7, _void, _xid, _xor, base64Charset, base64urlCharset, canParseURL, clone, compile, compileFn, config, createStandardJSONSchemaMethod, createToJSONSchemaMethod, decode$1 as decode, decodeAsync$1 as decodeAsync, describe, encode$1 as encode, encodeAsync$1 as encodeAsync, extractDefs, finalize, flattenError, formatError, getDiscriminatedOption, globalConfig, globalRegistry, handleUnrepresentable, output as infer, initializeContext, input, isBackEdge, isRecursiveSchema, isValidBase64, isValidBase64URL, isValidCIDRv6, isValidCreditCard, isValidIBAN, isValidIPv6, isValidJWT, index_d_exports$1 as locales, memoizer, mergeValues, meta$1 as meta, output, parse$1 as parse, parseAsync$1 as parseAsync, parseURLObject, prettifyError, processSchema as process, processSchema, regexes_d_exports as regexes, registry, safeDecode$1 as safeDecode, safeDecodeAsync$1 as safeDecodeAsync, safeEncode$1 as safeEncode, safeEncodeAsync$1 as safeEncodeAsync, safeParse$1 as safeParse, safeParseAsync$1 as safeParseAsync, standardProps, stripTabAndNewline, toDotPath, toJSONSchema, toZod, treeifyError, urlHostnameOk, urlProtocolOk, util_d_exports as util, validate, validateAsync, validateURL, version, withParser };
+}
 //#endregion
 //#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/errors.d.cts
 /** An Error-like class used to store Zod validation issues.  */
@@ -1772,8 +3680,9 @@ interface ZodError<T = unknown> extends $ZodError<T> {
   isEmpty: boolean;
 }
 declare const ZodError: $constructor<ZodError>;
-//#endregion
-//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/parse.d.cts
+declare namespace parse_d_exports {
+  export { ZodSafeParseError, ZodSafeParseResult, ZodSafeParseSuccess, decode, decodeAsync, encode, encodeAsync, parse, parseAsync, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync, validate, validateAsync };
+}
 type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
 type ZodSafeParseSuccess<T> = {
   success: true;
@@ -1785,6 +3694,36 @@ type ZodSafeParseError<T> = {
   data?: never;
   error: ZodError<T>;
 };
+declare const parse: <T extends $ZodType>(schema: T, value: unknown, _ctx?: ParseContext<$ZodIssue>, _params?: {
+  callee?: AnyFunc;
+  Err?: $ZodErrorClass;
+}) => output<T>;
+declare const parseAsync: <T extends $ZodType>(schema: T, value: unknown, _ctx?: ParseContext<$ZodIssue>, _params?: {
+  callee?: AnyFunc;
+  Err?: $ZodErrorClass;
+}) => Promise<output<T>>;
+declare const safeParse: <T extends $ZodType>(schema: T, value: unknown, _ctx?: ParseContext<$ZodIssue>) => ZodSafeParseResult<output<T>>;
+declare const safeParseAsync: <T extends $ZodType>(schema: T, value: unknown, _ctx?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<output<T>>>;
+declare const encode: <T extends $ZodType>(schema: T, value: output<T>, _ctx?: ParseContext<$ZodIssue>, _params?: {
+  callee?: AnyFunc;
+  Err?: $ZodErrorClass;
+}) => input<T>;
+declare const decode: <T extends $ZodType>(schema: T, value: input<T>, _ctx?: ParseContext<$ZodIssue>, _params?: {
+  callee?: AnyFunc;
+  Err?: $ZodErrorClass;
+}) => output<T>;
+declare const encodeAsync: <T extends $ZodType>(schema: T, value: output<T>, _ctx?: ParseContext<$ZodIssue>, _params?: {
+  callee?: AnyFunc;
+  Err?: $ZodErrorClass;
+}) => Promise<input<T>>;
+declare const decodeAsync: <T extends $ZodType>(schema: T, value: input<T>, _ctx?: ParseContext<$ZodIssue>, _params?: {
+  callee?: AnyFunc;
+  Err?: $ZodErrorClass;
+}) => Promise<output<T>>;
+declare const safeEncode: <T extends $ZodType>(schema: T, value: output<T>, _ctx?: ParseContext<$ZodIssue>) => ZodSafeParseResult<input<T>>;
+declare const safeDecode: <T extends $ZodType>(schema: T, value: input<T>, _ctx?: ParseContext<$ZodIssue>) => ZodSafeParseResult<output<T>>;
+declare const safeEncodeAsync: <T extends $ZodType>(schema: T, value: output<T>, _ctx?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<input<T>>>;
+declare const safeDecodeAsync: <T extends $ZodType>(schema: T, value: input<T>, _ctx?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<output<T>>>;
 //#endregion
 //#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/schemas.d.cts
 type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<input<T>, output<T>>;
@@ -2423,7 +4362,7 @@ interface Config$2 {
   /** Per-domain overrides: domain name → backend name. */
   routes?: Record<string, string>;
 }
-declare const Config$2: Schema<Config$2>;
+declare const Config$2: Schema$1<Config$2>;
 /**
  * The mounted domain facility. Opens declared domains over routed backends;
  * one facility instance owns the open-domain table and enforces single-open
@@ -2497,7 +4436,7 @@ interface Config$1 {
   /** Longest time (milliseconds) a dirty checkpoint may stay unwritten between mandatory points. */
   writeIntervalMs: number;
 }
-declare const Config$1: Schema<Config$1>;
+declare const Config$1: Schema$1<Config$1>;
 /**
  * The persisted projection cache service. Opens the `session_projcache`
  * domain at init, checkpoints live sessions on a throttled write-behind
@@ -2510,7 +4449,7 @@ declare const Config$1: Schema<Config$1>;
 declare class SessionProjectionCache extends Service {
   config: Config$1;
   static inject: string[];
-  static Config: Schema<Config$1>;
+  static Config: Schema$1<Config$1>;
   private table?;
   private readonly dirty;
   constructor(ctx: Context, config: Config$1);
@@ -2996,29 +4935,37 @@ declare class WorkspaceRegistry extends Service {
 }
 //#endregion
 //#region ../session-rdb/src/import.d.ts
-declare function parseJsonlArtifact(content: string): SessionStorageMetadata & {
+export declare function parseJsonlArtifact(content: string): SessionStorageMetadata & {
   events: SessionEvent$1[];
 };
 //#endregion
 //#region ../session-rdb/src/testing/contract.d.ts
-declare function meta(id: string, cwd?: string): SessionHeader$1;
-declare function oneTurnLog(): SessionEvent$1[];
+export declare function meta(id: string, cwd?: string): SessionHeader$1;
+export declare function oneTurnLog(): SessionEvent$1[];
 //#endregion
 //#region src/shared.d.ts
-declare const SESSION_EDITOR_PATH = "/session-editor";
+export declare const SESSION_EDITOR_PATHS: {
+  readonly edit: "/api/morlay/v1/session/edit";
+  readonly reroll: "/api/morlay/v1/session/reroll";
+  readonly retry: "/api/morlay/v1/session/retry";
+  readonly rewind: "/api/morlay/v1/session/rewind";
+  readonly recall: "/api/morlay/v1/session/recall";
+  readonly fork: "/api/morlay/v1/session/fork";
+};
+type SessionEditorAction = keyof typeof SESSION_EDITOR_PATHS;
 //#endregion
 //#region src/testing.d.ts
-interface Harness {
+export interface Harness {
   ctx: Context;
   editor: SessionEditor;
   dispose: () => Promise<void>;
 }
-declare function harness(provide?: (ctx: Context) => void): Promise<Harness>;
-declare function twoTurnLog(): SessionEvent[];
-declare function createPersisted(ctx: Context, id: string, events: readonly SessionEvent[], header?: SessionHeader): Promise<void>;
-declare function userMessage(seq: number, id: string, text: string, time?: number): SessionEvent;
-declare function assistantMessage(seq: number, turn: number, step: number, id: string, text: string, time?: number): SessionEvent;
-declare function turnLog(base: number, turn: number, opts?: {
+export declare function harness(provide?: (ctx: Context) => void): Promise<Harness>;
+export declare function twoTurnLog(): SessionEvent[];
+export declare function createPersisted(ctx: Context, id: string, events: readonly SessionEvent[], header?: SessionHeader): Promise<void>;
+export declare function userMessage(seq: number, id: string, text: string, time?: number): SessionEvent;
+export declare function assistantMessage(seq: number, turn: number, step: number, id: string, text: string, time?: number): SessionEvent;
+export declare function turnLog(base: number, turn: number, opts?: {
   users?: Array<{
     id: string;
     text: string;
@@ -3027,4 +4974,4 @@ declare function turnLog(base: number, turn: number, opts?: {
   time?: number;
 }): SessionEvent[];
 //#endregion
-export { Harness, SESSION_EDITOR_PATH, Session, type SessionEvent, type SessionHeader, SessionIdBrand, SessionSeq, SessionStore, TokenMeter, assistantMessage, createPersisted, harness, meta, oneTurnLog, parseJsonlArtifact, turnLog, twoTurnLog, userMessage };
+export { Session, type SessionEditorAction, type SessionEvent, type SessionHeader, SessionIdBrand, SessionSeq, SessionStore, TokenMeter };