@morlay/session-rdb 0.1.1 → 0.1.3

package/dist/{log-CUjKQbOR.d.mts → log-DYyxRh7j.d.mts}

@@ -6,7 +6,10 @@ import { KvUnit } from "@deepseek-ai/dsh-storage";
 import { Context, Service } from "@deepseek-ai/cordis";
 import { SessionId as SessionId$1 } from "@deepseek-ai/dsh-session/types";
 import { Volatile } from "@deepseek-ai/cosmokit";
-//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/json-schema.d.cts
+declare namespace json_schema_d_exports {
+  export { ArraySchema, BaseSchema, BooleanSchema, IntegerSchema, JSONSchema, NullSchema, NumberSchema, ObjectSchema, Schema$1 as Schema, SchemaType, StringSchema, _JSONSchema };
+}
+type Schema$1 = ObjectSchema | ArraySchema | StringSchema | NumberSchema | IntegerSchema | BooleanSchema | NullSchema;
 type _JSONSchema = boolean | JSONSchema;
 type SchemaType = "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
 type JSONSchema = {
@@ -74,6 +77,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. */
@@ -193,13 +217,14 @@ 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;
 type $input = typeof $input;
-type $replace<Meta, S extends $ZodType> = Meta extends $output ? output<S> : Meta extends $input ? input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends ((...args: infer P) => infer R) ? (...args: { [K in keyof P]: $replace<P[K], S>; }) => $replace<R, S> : Meta extends object ? { [K in keyof Meta]: $replace<Meta[K], S>; } : Meta;
+type $replace<Meta, S extends $ZodType> = Meta extends $output ? output$1<S> : Meta extends $input ? input$1<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends ((...args: infer P) => infer R) ? (...args: { [K in keyof P]: $replace<P[K], S>; }) => $replace<R, S> : Meta extends object ? { [K in keyof Meta]: $replace<Meta[K], S>; } : Meta;
 type MetadataType = object | undefined;
 declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
   _meta: Meta;
@@ -220,6 +245,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;
@@ -275,6 +302,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)[];
@@ -338,24 +371,81 @@ interface ToJSONSchemaContext {
     defs: Record<string, BaseSchema>;
   } | undefined;
 }
-type ZodStandardSchemaWithJSON$1<T> = StandardSchemaWithJSONProps<input<T>, output<T>>;
+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$1<T>, output$1<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, 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$1 as 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;
@@ -363,28 +453,179 @@ type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T e
 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$1(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<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: {
@@ -392,8 +633,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$1 {
+  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>;
@@ -410,6 +652,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[];
@@ -483,7 +731,7 @@ interface $ZodTypeInternals<out O = unknown, out I = unknown> extends _$ZodTypeI
   /** @internal The inferred input type */
   input: I;
 }
-type $ZodStandardSchema<T> = StandardSchemaV1.Props<input<T>, output<T>>;
+type $ZodStandardSchema<T> = StandardSchemaV1.Props<input$1<T>, output$1<T>>;
 type SomeType = {
   _zod: _$ZodTypeInternals;
 };
@@ -493,6 +741,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;
@@ -524,6 +773,7 @@ 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;
@@ -539,6 +789,7 @@ 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;
@@ -555,7 +806,20 @@ interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
 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;
@@ -571,6 +835,12 @@ 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.
@@ -591,21 +861,25 @@ interface $ZodCUID extends $ZodType {
  * 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;
@@ -623,6 +897,7 @@ 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;
@@ -638,6 +913,7 @@ 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;
@@ -662,7 +938,18 @@ interface $ZodIPv6Internals extends $ZodStringFormatInternals<"ipv6"> {
 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";
 }
@@ -682,22 +969,49 @@ interface $ZodCIDRv6Internals extends $ZodStringFormatInternals<"cidrv6"> {
 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;
 }
@@ -708,6 +1022,16 @@ 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;
@@ -731,6 +1055,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;
@@ -764,6 +1097,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";
 }
@@ -869,8 +1212,8 @@ interface $ZodArrayDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
 interface $ZodArrayInternals<T extends SomeType = $ZodType> extends _$ZodTypeInternals {
   def: $ZodArrayDef<T>;
   isst: $ZodIssueInvalidType;
-  output: output<T>[];
-  input: input<T>[];
+  output: output$1<T>[];
+  input: input$1<T>[];
 }
 interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType<any, any, $ZodArrayInternals<T>> {}
 declare const $ZodArray: $constructor<$ZodArray>;
@@ -884,8 +1227,8 @@ type OptionalInSchema = {
     optin: "optional" | "defaulted";
   };
 };
-type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? IsAny<T[keyof T]> extends true ? Record<string, unknown> : { [k in string]: output<T[keyof T]>; } : keyof (T & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_zod"]["output"]; } & { -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_zod"]["output"]; } & Extra>;
-type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? IsAny<T[keyof T]> extends true ? Record<string, unknown> : { [k in string]: input<T[keyof T]>; } : keyof (T & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k]["_zod"]["input"]; } & { -readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k]["_zod"]["input"]; } & Extra>;
+type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? IsAny<T[keyof T]> extends true ? Record<string, unknown> : { [k in string]: output$1<T[keyof T]>; } : keyof (T & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_zod"]["output"]; } & { -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_zod"]["output"]; } & Extra>;
+type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? IsAny<T[keyof T]> extends true ? Record<string, unknown> : { [k in string]: input$1<T[keyof T]>; } : keyof (T & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k]["_zod"]["input"]; } & { -readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k]["_zod"]["input"]; } & Extra>;
 type $ZodObjectConfig = {
   out: Record<string, unknown>;
   in: Record<string, unknown>;
@@ -904,10 +1247,10 @@ type $strip = {
 };
 type $catchall<T extends SomeType> = {
   out: {
-    [k: string]: output<T>;
+    [k: string]: output$1<T>;
   };
   in: {
-    [k: string]: input<T>;
+    [k: string]: input$1<T>;
   };
 };
 type $ZodShape = Readonly<{
@@ -935,8 +1278,9 @@ interface $ZodObject<
 /** @ts-ignore Cast variance */
 out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {}
 declare const $ZodObject: $constructor<$ZodObject>;
-type $InferUnionOutput<T extends SomeType> = T extends any ? output<T> : never;
-type $InferUnionInput<T extends SomeType> = T extends any ? input<T> : never;
+declare const $ZodObjectJIT: $constructor<$ZodObject>;
+type $InferUnionOutput<T extends SomeType> = T extends any ? output$1<T> : never;
+type $InferUnionInput<T extends SomeType> = T extends any ? input$1<T> : never;
 interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
   type: "union";
   options: Options;
@@ -958,6 +1302,11 @@ 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;
@@ -969,6 +1318,20 @@ interface $ZodDiscriminatedUnionInternals<Options extends readonly SomeType[] =
     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>;
 }
@@ -983,24 +1346,31 @@ interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends Som
   isst: never;
   optin: A["_zod"]["optin"] | B["_zod"]["optin"];
   optout: A["_zod"]["optout"] | B["_zod"]["optout"];
-  output: output<A> & output<B>;
-  input: input<A> & input<B>;
+  output: output$1<A> & output$1<B>;
+  input: input$1<A> & input$1<B>;
 }
 interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
   _zod: $ZodIntersectionInternals<A, B>;
 }
 declare const $ZodIntersection: $constructor<$ZodIntersection>;
+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;
   rest: Rest;
 }
-type $InferTupleInputType<T extends TupleItems, Rest extends SomeType | null> = [...TupleInputTypeWithOptionals<T>, ...(Rest extends SomeType ? input<Rest>[] : [])];
-type TupleInputTypeNoOptionals<T extends TupleItems> = { [k in keyof T]: input<T[k]>; };
-type TupleInputTypeWithOptionals<T extends TupleItems> = T extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optin"] extends "optional" | "defaulted" ? [...TupleInputTypeWithOptionals<Prefix>, input<Tail>?] : TupleInputTypeNoOptionals<T> : [];
-type $InferTupleOutputType<T extends TupleItems, Rest extends SomeType | null> = [...TupleOutputTypeWithOptionals<T>, ...(Rest extends SomeType ? output<Rest>[] : [])];
-type TupleOutputTypeNoOptionals<T extends TupleItems> = { [k in keyof T]: output<T[k]>; };
-type TupleOutputTypeWithOptionals<T extends TupleItems> = T extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, output<Tail>?] : TupleOutputTypeNoOptionals<T> : [];
+type $InferTupleInputType<T extends TupleItems, Rest extends SomeType | null> = [...TupleInputTypeWithOptionals<T>, ...(Rest extends SomeType ? input$1<Rest>[] : [])];
+type TupleInputTypeNoOptionals<T extends TupleItems> = { [k in keyof T]: input$1<T[k]>; };
+type TupleInputTypeWithOptionals<T extends TupleItems> = T extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optin"] extends "optional" | "defaulted" ? [...TupleInputTypeWithOptionals<Prefix>, input$1<Tail>?] : TupleInputTypeNoOptionals<T> : [];
+type $InferTupleOutputType<T extends TupleItems, Rest extends SomeType | null> = [...TupleOutputTypeWithOptionals<T>, ...(Rest extends SomeType ? output$1<Rest>[] : [])];
+type TupleOutputTypeNoOptionals<T extends TupleItems> = { [k in keyof T]: output$1<T[k]>; };
+type TupleOutputTypeWithOptionals<T extends TupleItems> = T extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, output$1<Tail>?] : TupleOutputTypeNoOptionals<T> : [];
 interface $ZodTupleInternals<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends _$ZodTypeInternals {
   def: $ZodTupleDef<T, Rest>;
   isst: $ZodIssueInvalidType | $ZodIssueTooBig<unknown[]> | $ZodIssueTooSmall<unknown[]>;
@@ -1020,8 +1390,8 @@ interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value extends
   mode?: "strict" | "loose";
   partial?: boolean;
 }
-type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<output<Key>, output<Value>>> : Record<output<Key>, output<Value>>;
-type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<input<Key> & PropertyKey, input<Value>>> : [Value] extends [OptionalInSchema] ? Partial<Record<input<Key> & PropertyKey, input<Value>>> : Record<input<Key> & PropertyKey, input<Value>>;
+type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<output$1<Key>, output$1<Value>>> : Record<output$1<Key>, output$1<Value>>;
+type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<input$1<Key> & PropertyKey, input$1<Value>>> : [Value] extends [OptionalInSchema] ? Partial<Record<input$1<Key> & PropertyKey, input$1<Value>>> : Record<input$1<Key> & PropertyKey, input$1<Value>>;
 interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
   def: $ZodRecordDef<Key, Value>;
   isst: $ZodIssueInvalidType | $ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
@@ -1040,7 +1410,7 @@ interface $ZodMapDef<Key extends SomeType = $ZodType, Value extends SomeType = $
   keyType: Key;
   valueType: Value;
 }
-interface $ZodMapInternals<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeInternals<Map<output<Key>, output<Value>>, Map<input<Key>, input<Value>>> {
+interface $ZodMapInternals<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeInternals<Map<output$1<Key>, output$1<Value>>, Map<input$1<Key>, input$1<Value>>> {
   def: $ZodMapDef<Key, Value>;
   isst: $ZodIssueInvalidType | $ZodIssueInvalidKey | $ZodIssueInvalidElement<unknown>;
   optin?: "optional" | undefined;
@@ -1054,7 +1424,7 @@ interface $ZodSetDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "set";
   valueType: T;
 }
-interface $ZodSetInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Set<output<T>>, Set<input<T>>> {
+interface $ZodSetInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Set<output$1<T>>, Set<input$1<T>>> {
   def: $ZodSetDef<T>;
   isst: $ZodIssueInvalidType;
   optin?: "optional" | undefined;
@@ -1138,7 +1508,7 @@ interface $ZodOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "optional";
   innerType: T;
 }
-interface $ZodOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T> | undefined, input<T> | undefined> {
+interface $ZodOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output$1<T> | undefined, input$1<T> | undefined> {
   def: $ZodOptionalDef<T>;
   optin: "optional" | "defaulted";
   optout: "optional";
@@ -1153,8 +1523,8 @@ declare const $ZodOptional: $constructor<$ZodOptional>;
 interface $ZodExactOptionalDef<T extends SomeType = $ZodType> extends $ZodOptionalDef<T> {}
 interface $ZodExactOptionalInternals<T extends SomeType = $ZodType> extends $ZodOptionalInternals<T> {
   def: $ZodExactOptionalDef<T>;
-  output: output<T>;
-  input: input<T>;
+  output: output$1<T>;
+  input: input$1<T>;
 }
 interface $ZodExactOptional<T extends SomeType = $ZodType> extends $ZodType {
   _zod: $ZodExactOptionalInternals<T>;
@@ -1164,7 +1534,7 @@ interface $ZodNullableDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "nullable";
   innerType: T;
 }
-interface $ZodNullableInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T> | null, input<T> | null> {
+interface $ZodNullableInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output$1<T> | null, input$1<T> | null> {
   def: $ZodNullableDef<T>;
   optin: T["_zod"]["optin"];
   optout: T["_zod"]["optout"];
@@ -1180,9 +1550,9 @@ interface $ZodDefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "default";
   innerType: T;
   /** The default value. May be a getter. */
-  defaultValue: NoUndefined<output<T>>;
+  defaultValue: NoUndefined<output$1<T>>;
 }
-interface $ZodDefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, input<T> | undefined> {
+interface $ZodDefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output$1<T>>, input$1<T> | undefined> {
   def: $ZodDefaultDef<T>;
   optin: "defaulted";
   optout?: "optional" | undefined;
@@ -1197,9 +1567,9 @@ interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "prefault";
   innerType: T;
   /** The default value. May be a getter. */
-  defaultValue: input<T>;
+  defaultValue: input$1<T>;
 }
-interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, input<T> | undefined> {
+interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output$1<T>, input$1<T> | undefined> {
   def: $ZodPrefaultDef<T>;
   optin: "defaulted";
   optout?: "optional" | undefined;
@@ -1214,7 +1584,7 @@ interface $ZodNonOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef
   type: "nonoptional";
   innerType: T;
 }
-interface $ZodNonOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, NoUndefined<input<T>>> {
+interface $ZodNonOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output$1<T>>, NoUndefined<input$1<T>>> {
   def: $ZodNonOptionalDef<T>;
   isst: $ZodIssueInvalidType;
   values: T["_zod"]["values"];
@@ -1229,7 +1599,7 @@ interface $ZodSuccessDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "success";
   innerType: T;
 }
-interface $ZodSuccessInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, input<T>> {
+interface $ZodSuccessInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, input$1<T>> {
   def: $ZodSuccessDef<T>;
   isst: never;
   optin: T["_zod"]["optin"];
@@ -1252,7 +1622,7 @@ interface $ZodCatchDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
   innerType: T;
   catchValue: (ctx: $ZodCatchCtx) => unknown;
 }
-interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, input<T>> {
+interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output$1<T>, input$1<T>> {
   def: $ZodCatchDef<T>;
   optin: T["_zod"]["optin"];
   optout: T["_zod"]["optout"];
@@ -1279,11 +1649,11 @@ interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodTy
   in: A;
   out: B;
   /** Only defined inside $ZodCodec instances. */
-  transform?: (value: output<A>, payload: ParsePayload<output<A>>) => MaybeAsync<input<B>>;
+  transform?: (value: output$1<A>, payload: ParsePayload<output$1<A>>) => MaybeAsync<input$1<B>>;
   /** Only defined inside $ZodCodec instances. */
-  reverseTransform?: (value: input<B>, payload: ParsePayload<input<B>>) => MaybeAsync<output<A>>;
+  reverseTransform?: (value: input$1<B>, payload: ParsePayload<input$1<B>>) => MaybeAsync<output$1<A>>;
 }
-interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output<B>, input<A>> {
+interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output$1<B>, input$1<A>> {
   def: $ZodPipeDef<A, B>;
   isst: never;
   values: A["_zod"]["values"];
@@ -1295,11 +1665,40 @@ 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$1<A>, payload: ParsePayload<output$1<A>>) => MaybeAsync<input$1<B>>;
+  reverseTransform: (value: input$1<B>, payload: ParsePayload<input$1<B>>) => MaybeAsync<output$1<A>>;
+}
+interface $ZodCodecInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output$1<B>, input$1<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;
 }
-interface $ZodReadonlyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<MakeReadonly<output<T>>, MakeReadonly<input<T>>> {
+interface $ZodReadonlyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<MakeReadonly<output$1<T>>, MakeReadonly<input$1<T>>> {
   def: $ZodReadonlyDef<T>;
   optin: T["_zod"]["optin"];
   optout: T["_zod"]["optout"];
@@ -1332,14 +1731,20 @@ 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$1<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$1<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;
 type $ZodFunctionOut = $ZodType;
-type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => input<Returns>;
-type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => MaybeAsync<input<Returns>>;
-type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => output<Returns>;
-type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => Promise<output<Returns>>;
+type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output$1<Args>) => input$1<Returns>;
+type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output$1<Args>) => MaybeAsync<input$1<Returns>>;
+type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input$1<Args>) => output$1<Returns>;
+type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input$1<Args>) => Promise<output$1<Returns>>;
 interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodTypeDef {
   type: "function";
   input: In;
@@ -1361,12 +1766,16 @@ 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";
   innerType: T;
 }
-interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<output<T>>, MaybeAsync<input<T>>> {
+interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<output$1<T>>, MaybeAsync<input$1<T>>> {
   def: $ZodPromiseDef<T>;
   isst: never;
 }
@@ -1378,7 +1787,7 @@ interface $ZodLazyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "lazy";
   getter: () => T;
 }
-interface $ZodLazyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, input<T>> {
+interface $ZodLazyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output$1<T>, input$1<T>> {
   def: $ZodLazyDef<T>;
   isst: never;
   /** Auto-cached way to retrieve the inner schema */
@@ -1413,8 +1822,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;
@@ -1485,6 +1896,55 @@ interface $ZodCheckNumberFormat<Format extends $ZodNumberFormats = $ZodNumberFor
   _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;
@@ -1531,6 +1991,10 @@ 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;
@@ -1595,8 +2059,62 @@ interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
   _zod: $ZodCheckEndsWithInternals;
 }
 declare const $ZodCheckEndsWith: $constructor<$ZodCheckEndsWith>;
-//#endregion
-//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/errors.d.cts
+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$1<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;
@@ -1684,7 +2202,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 */
@@ -1713,19 +2256,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$1 as infer, input$1 as input, output$1 as output };
+}
 type ZodTrait = {
   _zod: {
     def: any;
@@ -1736,40 +2336,627 @@ interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
   new (def: D): T;
   init(inst: T, def: D): asserts inst is T;
 }
-interface $constructorParams {
-  Parent?: typeof Class;
+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>;
+declare const $brand: unique symbol;
+type $brand<T extends string | number | symbol = string | number | symbol> = {
+  [$brand]: { [k in T]: true; };
+};
+type $ZodBranded<T extends SomeType, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T & (Dir extends "inout" ? {
+  _zod: {
+    input: input$1<T> & $brand<Brand>;
+    output: output$1<T> & $brand<Brand>;
+  };
+} : Dir extends "in" ? {
+  _zod: {
+    input: input$1<T> & $brand<Brand>;
+  };
+} : {
+  _zod: {
+    output: output$1<T> & $brand<Brand>;
+  };
+});
+type $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$1<T> = T extends {
+  _zod: {
+    input: any;
+  };
+} ? T["_zod"]["input"] : unknown;
+type output$1<T> = T extends {
+  _zod: {
+    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$1<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$1<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$1<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$1<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$1<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$1<T>, _ctx?: ParseContext<$ZodIssue>, _params?: $ParseParams) => input$1<T>;
+declare const _encode: (_Err: $ZodErrorClass) => $Encode;
+declare const encode$1: $Encode;
+type $Decode = <T extends $ZodType>(schema: T, value: input$1<T>, _ctx?: ParseContext<$ZodIssue>, _params?: $ParseParams) => output$1<T>;
+declare const _decode: (_Err: $ZodErrorClass) => $Decode;
+declare const decode$1: $Decode;
+type $EncodeAsync = <T extends $ZodType>(schema: T, value: output$1<T>, _ctx?: ParseContext<$ZodIssue>, _params?: $ParseParams) => Promise<input$1<T>>;
+declare const _encodeAsync: (_Err: $ZodErrorClass) => $EncodeAsync;
+declare const encodeAsync$1: $EncodeAsync;
+type $DecodeAsync = <T extends $ZodType>(schema: T, value: input$1<T>, _ctx?: ParseContext<$ZodIssue>, _params?: $ParseParams) => Promise<output$1<T>>;
+declare const _decodeAsync: (_Err: $ZodErrorClass) => $DecodeAsync;
+declare const decodeAsync$1: $DecodeAsync;
+type $SafeEncode = <T extends $ZodType>(schema: T, value: output$1<T>, _ctx?: ParseContext<$ZodIssue>) => SafeParseResult<input$1<T>>;
+declare const _safeEncode: (_Err: $ZodErrorClass) => $SafeEncode;
+declare const safeEncode$1: $SafeEncode;
+type $SafeDecode = <T extends $ZodType>(schema: T, value: input$1<T>, _ctx?: ParseContext<$ZodIssue>) => SafeParseResult<output$1<T>>;
+declare const _safeDecode: (_Err: $ZodErrorClass) => $SafeDecode;
+declare const safeDecode$1: $SafeDecode;
+type $SafeEncodeAsync = <T extends $ZodType>(schema: T, value: output$1<T>, _ctx?: ParseContext<$ZodIssue>) => Promise<SafeParseResult<input$1<T>>>;
+declare const _safeEncodeAsync: (_Err: $ZodErrorClass) => $SafeEncodeAsync;
+declare const safeEncodeAsync$1: $SafeEncodeAsync;
+type $SafeDecodeAsync = <T extends $ZodType>(schema: T, value: input$1<T>, _ctx?: ParseContext<$ZodIssue>) => Promise<SafeParseResult<output$1<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$1 as base64, base64url$1 as base64url, bigint$2 as bigint, boolean$2 as boolean, browserEmail, cidrv4$1 as cidrv4, cidrv6$1 as cidrv6, creditCard$1 as creditCard, cuid$1 as cuid, cuid2$1 as cuid2, currencyCode$1 as currencyCode, date$3 as date, datetime$1 as datetime, domain, duration$1 as duration, e164$1 as e164, email$1 as email, emoji$1 as emoji, extendedDuration, guid$1 as guid, hex$1 as hex, hostname$1 as hostname, html5Email, httpProtocol, iban$1 as iban, idnEmail, integer, ipv4$1 as ipv4, ipv6$1 as ipv6, ksuid$1 as ksuid, lowercase, mac$1 as mac, md5_base64, md5_base64url, md5_hex, nanoid$1 as nanoid, nanoidOfLength, _null$2 as null, number$2 as 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$2 as string, time$1 as time, ulid$1 as ulid, _undefined$2 as undefined, unicodeEmail, uppercase, uuid$1 as uuid, uuid4, uuid6, uuid7, xid$1 as 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$1: RegExp;
+declare const cuid2$1: RegExp;
+declare const ulid$1: RegExp;
+declare const xid$1: RegExp;
+declare const ksuid$1: RegExp;
+declare const nanoid$1: 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$1: 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$1: 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$1: (version?: number | undefined) => RegExp;
+declare const uuid4: RegExp;
+declare const uuid6: RegExp;
+declare const uuid7: RegExp;
+/** Practical email validation */
+declare const email$1: 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$1(): RegExp;
+declare const ipv4$1: RegExp;
+declare const ipv6$1: RegExp;
+declare const mac$1: (delimiter?: string) => RegExp;
+declare const cidrv4$1: RegExp;
+declare const cidrv6$1: RegExp;
+declare const base64$1: RegExp;
+declare const base64url$1: RegExp;
+declare const hostname$1: RegExp;
+declare const domain: RegExp;
+declare const httpProtocol: RegExp;
+declare const e164$1: RegExp;
+declare const creditCard$1: RegExp;
+declare const currencyCode$1: RegExp;
+declare const iban$1: RegExp;
+declare const date$3: RegExp;
+declare function time$1(args: {
+  precision?: number | null;
+}): RegExp;
+declare function datetime$1(args: {
+  precision?: number | null;
+  offset?: boolean;
+  local?: boolean;
+}): RegExp;
+declare const anyString: RegExp;
+declare const string$2: (params?: {
+  minimum?: number | undefined;
+  maximum?: number | undefined;
+}) => RegExp;
+declare const bigint$2: RegExp;
+declare const integer: RegExp;
+declare const number$2: RegExp;
+declare const boolean$2: RegExp;
+declare const _null$2: RegExp;
+declare const _undefined$2: RegExp;
+declare const lowercase: RegExp;
+declare const uppercase: RegExp;
+declare const hex$1: 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$64(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/az.d.cts
+declare function _default$63(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/be.d.cts
+declare function _default$62(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/bg.d.cts
+declare function _default$61(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/bn.d.cts
+declare function _default$60(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ca.d.cts
+declare function _default$59(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ckb.d.cts
+declare function _default$58(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/cs.d.cts
+declare function _default$57(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/da.d.cts
+declare function _default$56(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/de.d.cts
+declare function _default$55(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/el.d.cts
+declare function _default$54(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/en.d.cts
+declare function _default$53(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/eo.d.cts
+declare function _default$52(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/es.d.cts
+declare function _default$51(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/fa.d.cts
+declare function _default$50(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/fi.d.cts
+declare function _default$49(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/fr.d.cts
+declare function _default$48(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/fr-CA.d.cts
+declare function _default$47(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/gu.d.cts
+declare function _default$46(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/he.d.cts
+declare function _default$45(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/hi.d.cts
+declare function _default$44(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/hr.d.cts
+declare function _default$43(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/hu.d.cts
+declare function _default$42(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/hy.d.cts
+declare function _default$41(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/id.d.cts
+declare function _default$40(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/is.d.cts
+declare function _default$39(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/it.d.cts
+declare function _default$38(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ja.d.cts
+declare function _default$37(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ka.d.cts
+declare function _default$36(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/kh.d.cts
+declare function _default$35(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/km.d.cts
+declare function _default$34(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/kn.d.cts
+declare function _default$33(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ko.d.cts
+declare function _default$32(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/lt.d.cts
+declare function _default$31(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/mk.d.cts
+declare function _default$30(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ms.d.cts
+declare function _default$29(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ne.d.cts
+declare function _default$28(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/nl.d.cts
+declare function _default$27(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/nn.d.cts
+declare function _default$26(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/no.d.cts
+declare function _default$25(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ota.d.cts
+declare function _default$24(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ps.d.cts
+declare function _default$23(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/pl.d.cts
+declare function _default$22(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/pt.d.cts
+declare function _default$21(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/pt-BR.d.cts
+declare function _default$20(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ro.d.cts
+declare function _default$19(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ru.d.cts
+declare function _default$18(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/sk.d.cts
+declare function _default$17(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/sl.d.cts
+declare function _default$16(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/sv.d.cts
+declare function _default$15(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ta.d.cts
+declare function _default$14(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/tg.d.cts
+declare function _default$13(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/th.d.cts
+declare function _default$12(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/tk.d.cts
+declare function _default$11(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/tr.d.cts
+declare function _default$10(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ua.d.cts
+declare function _default$9(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/uk.d.cts
+declare function _default$8(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ur.d.cts
+declare function _default$7(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/uz.d.cts
+declare function _default$6(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/vi.d.cts
+declare function _default$5(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/zh-CN.d.cts
+declare function _default$4(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/zh-TW.d.cts
+declare function _default$3(): {
+  localeError: $ZodErrorMap;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/yo.d.cts
+declare function _default$2(): {
+  localeError: $ZodErrorMap;
+};
+declare namespace index_d_exports$1 {
+  export { _default$64 as ar, _default$63 as az, _default$62 as be, _default$61 as bg, _default$60 as bn, _default$59 as ca, _default$58 as ckb, _default$57 as cs, _default$56 as da, _default$55 as de, _default$54 as el, _default$53 as en, _default$52 as eo, _default$51 as es, _default$50 as fa, _default$49 as fi, _default$48 as fr, _default$47 as frCA, _default$46 as gu, _default$45 as he, _default$44 as hi, _default$43 as hr, _default$42 as hu, _default$41 as hy, _default$40 as id, _default$39 as is, _default$38 as it, _default$37 as ja, _default$36 as ka, _default$35 as kh, _default$34 as km, _default$33 as kn, _default$32 as ko, _default$31 as lt, _default$30 as mk, _default$29 as ms, _default$28 as ne, _default$27 as nl, _default$26 as nn, _default$25 as no, _default$24 as ota, _default$22 as pl, _default$23 as ps, _default$21 as pt, _default$20 as ptBR, _default$19 as ro, _default$18 as ru, _default$17 as sk, _default$16 as sl, _default$15 as sv, _default$14 as ta, _default$13 as tg, _default$12 as th, _default$11 as tk, _default$10 as tr, _default$9 as ua, _default$8 as uk, _default$7 as ur, _default$6 as uz, _default$5 as vi, _default$2 as yo, _default$4 as zhCN, _default$3 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;
 }
-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>;
-declare const $brand: unique symbol;
-type $brand<T extends string | number | symbol = string | number | symbol> = {
-  [$brand]: { [k in T]: true; };
-};
-type $ZodBranded<T extends SomeType, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T & (Dir extends "inout" ? {
-  _zod: {
-    input: input<T> & $brand<Brand>;
-    output: output<T> & $brand<Brand>;
-  };
-} : Dir extends "in" ? {
-  _zod: {
-    input: input<T> & $brand<Brand>;
-  };
-} : {
-  _zod: {
-    output: output<T> & $brand<Brand>;
-  };
-});
-type input<T> = T extends {
-  _zod: {
-    input: any;
-  };
-} ? T["_zod"]["input"] : unknown;
-type output<T> = T extends {
-  _zod: {
-    output: any;
-  };
-} ? T["_zod"]["output"] : unknown;
+/**
+ * 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$1<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$1<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] ? {} : {
@@ -1782,52 +2969,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$1<T extends $ZodUndefined>(Class: SchemaClass<T>, params?: string | $ZodUndefinedParams): T;
+type $ZodNullParams = TypeParams<$ZodNull>;
+declare function _null$1<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$1<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$1<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$1<const T extends string[]>(Class: SchemaClass<$ZodEnum>, values: T, params?: string | $ZodEnumParams): $ZodEnum<ToEnum<T[number]>>;
+declare function _enum$1<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$1<T extends $ZodObject>(Class: SchemaClass<$ZodDefault>, innerType: T, defaultValue: NoUndefined<output$1<T>> | (() => NoUndefined<output$1<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$1<T extends $ZodObject>(Class: SchemaClass<$ZodCatch>, innerType: T, catchValue: output$1<T> | ((ctx: $ZodCatchCtx) => output$1<T>)): $ZodCatch<T>;
+type $ZodPipeParams = TypeParams<$ZodPipe, "in" | "out">;
+declare function _pipe<const A extends $ZodType, B extends $ZodType<unknown, output$1<A>> = $ZodType<unknown, output$1<A>>>(Class: SchemaClass<$ZodPipe>, in_: A, out: B | $ZodType<unknown, output$1<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. */
@@ -1842,8 +3260,103 @@ 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$1<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$1 as _catch, _check, _cidrv4, _cidrv6, _coercedBigint, _coercedBoolean, _coercedDate, _coercedNumber, _coercedString, _creditCard, _cuid, _cuid2, _custom, _date, _decode, _decodeAsync, _default$1 as _default, _discriminatedUnion, _e164, _email, _emoji, _encode, _encodeAsync, _endsWith, _enum$1 as _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$1 as _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$1 as _undefined, _union, _unknown, _uppercase, _url, _uuid, _uuidv4, _uuidv6, _uuidv7, _void$1 as _void, _xid, _xor, base64Charset, base64urlCharset, canParseURL, clone, compile, compileFn, config, createStandardJSONSchemaMethod, createToJSONSchemaMethod, decode$1 as decode, decodeAsync$1 as decodeAsync, describe$1 as describe, encode$1 as encode, encodeAsync$1 as encodeAsync, extractDefs, finalize, flattenError, formatError, getDiscriminatedOption, globalConfig, globalRegistry, handleUnrepresentable, output$1 as infer, initializeContext, input$1 as input, isBackEdge, isRecursiveSchema, isValidBase64, isValidBase64URL, isValidCIDRv6, isValidCreditCard, isValidIBAN, isValidIPv6, isValidJWT, index_d_exports$1 as locales, memoizer, mergeValues, meta$1 as meta, output$1 as 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
+/** @deprecated Use `z.core.$ZodIssue` from `@zod/core` instead, especially if you are building a library on top of Zod. */
+type ZodIssue = $ZodIssue;
 /** An Error-like class used to store Zod validation issues.  */
 interface ZodError<T = unknown> extends $ZodError<T> {
   /** @deprecated Use the `z.treeifyError(err)` function instead. */
@@ -1860,8 +3373,18 @@ 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 const ZodRealError: $constructor<ZodError>;
+/** @deprecated Use `z.core.$ZodFlattenedError` instead. */
+type ZodFlattenedError<T, U = string> = $ZodFlattenedError<T, U>;
+/** @deprecated Use `z.core.$ZodFormattedError` instead. */
+type ZodFormattedError<T, U = string> = $ZodFormattedError<T, U>;
+/** @deprecated Use `z.core.$ZodErrorMap` instead. */
+type ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> = $ZodErrorMap<T>;
+/** @deprecated Use `z.core.$ZodRawIssue` instead. */
+type IssueData = $ZodRawIssue;
+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;
@@ -1873,9 +3396,40 @@ type ZodSafeParseError<T> = {
   data?: never;
   error: ZodError<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>>;
+declare const parse: <T extends $ZodType>(schema: T, value: unknown, _ctx?: ParseContext<$ZodIssue>, _params?: {
+  callee?: AnyFunc;
+  Err?: $ZodErrorClass;
+}) => output$1<T>;
+declare const parseAsync: <T extends $ZodType>(schema: T, value: unknown, _ctx?: ParseContext<$ZodIssue>, _params?: {
+  callee?: AnyFunc;
+  Err?: $ZodErrorClass;
+}) => Promise<output$1<T>>;
+declare const safeParse: <T extends $ZodType>(schema: T, value: unknown, _ctx?: ParseContext<$ZodIssue>) => ZodSafeParseResult<output$1<T>>;
+declare const safeParseAsync: <T extends $ZodType>(schema: T, value: unknown, _ctx?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<output$1<T>>>;
+declare const encode: <T extends $ZodType>(schema: T, value: output$1<T>, _ctx?: ParseContext<$ZodIssue>, _params?: {
+  callee?: AnyFunc;
+  Err?: $ZodErrorClass;
+}) => input$1<T>;
+declare const decode: <T extends $ZodType>(schema: T, value: input$1<T>, _ctx?: ParseContext<$ZodIssue>, _params?: {
+  callee?: AnyFunc;
+  Err?: $ZodErrorClass;
+}) => output$1<T>;
+declare const encodeAsync: <T extends $ZodType>(schema: T, value: output$1<T>, _ctx?: ParseContext<$ZodIssue>, _params?: {
+  callee?: AnyFunc;
+  Err?: $ZodErrorClass;
+}) => Promise<input$1<T>>;
+declare const decodeAsync: <T extends $ZodType>(schema: T, value: input$1<T>, _ctx?: ParseContext<$ZodIssue>, _params?: {
+  callee?: AnyFunc;
+  Err?: $ZodErrorClass;
+}) => Promise<output$1<T>>;
+declare const safeEncode: <T extends $ZodType>(schema: T, value: output$1<T>, _ctx?: ParseContext<$ZodIssue>) => ZodSafeParseResult<input$1<T>>;
+declare const safeDecode: <T extends $ZodType>(schema: T, value: input$1<T>, _ctx?: ParseContext<$ZodIssue>) => ZodSafeParseResult<output$1<T>>;
+declare const safeEncodeAsync: <T extends $ZodType>(schema: T, value: output$1<T>, _ctx?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<input$1<T>>>;
+declare const safeDecodeAsync: <T extends $ZodType>(schema: T, value: input$1<T>, _ctx?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<output$1<T>>>;
+declare namespace schemas_d_exports {
+  export { SafeExtendShape, ZodAny, ZodArray, ZodBase64, ZodBase64URL, ZodBigInt, ZodBigIntFormat, ZodBoolean, ZodCIDRv4, ZodCIDRv6, ZodCUID, ZodCUID2, ZodCatch, ZodCodec, ZodCreditCard, ZodCustom, ZodCustomStringFormat, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodE164, ZodEmail, ZodEmoji, ZodEnum, ZodExactOptional, ZodFile, ZodFloat32, ZodFloat64, ZodFunction, ZodGUID, ZodIBAN, ZodIPv4, ZodIPv6, ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime, ZodInstanceOf, ZodInt, ZodInt32, ZodInt64, ZodIntersection, ZodJSONSchema, ZodJSONSchemaInternals, ZodJWT, ZodKSUID, ZodLazy, ZodLiteral, ZodMAC, ZodMap, ZodNaN, ZodNanoID, ZodNever, ZodNonOptional, ZodNull, ZodNullable, ZodNumber, ZodNumberFormat, ZodObject, ZodOptional, ZodPipe, ZodPrefault, ZodPreprocess, ZodPromise, ZodReadonly, ZodRecord, ZodSet, ZodStandardSchemaWithJSON, ZodString, ZodStringFormat, ZodSuccess, ZodSymbol, ZodTemplateLiteral, ZodTransform, ZodTuple, ZodType, ZodUInt32, ZodUInt64, ZodULID, ZodURL, ZodUUID, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, ZodXID, ZodXor, _ZodBigInt, _ZodBoolean, _ZodDate, _ZodNumber, _ZodString, _ZodType, _default, _function, any, array, base64, base64url, bigint$1 as bigint, boolean$1 as boolean, _catch as catch, check, cidrv4, cidrv6, codec, creditCard, cuid, cuid2, currencyCode, custom, date$2 as date, describe, discriminatedUnion, e164, email, emoji, _enum as enum, exactOptional, file, float32, float64, _function as function, guid, hash, hex, hostname, httpUrl, iban, _instanceof as instanceof, int, int32, int64, intersection, invertCodec, ipv4, ipv6, json, jwt, keyof, ksuid, lazy, literal, looseObject, looseRecord, mac, map, meta, nan, nanoid, nativeEnum, never, nonoptional, _null as null, nullable, nullish, number$1 as number, object, optional, partialRecord, pipe, prefault, preprocess, promise, readonly, record, refine, set, strictObject, string$1 as string, stringFormat, stringbool, success, superRefine, symbol, templateLiteral, transform, tuple, uint32, uint64, ulid, _undefined as undefined, union, unknown, url, uuid, uuidv4, uuidv6, uuidv7, _void as void, xid, xor };
+}
+type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<input$1<T>, output$1<T>>;
 interface ZodType<out Output = unknown, out Input = unknown, out Internals extends $ZodTypeInternals<Output, Input> = $ZodTypeInternals<Output, Input>> extends $ZodType<Output, Input, Internals> {
   def: Internals["def"];
   type: Internals["def"]["type"];
@@ -1888,47 +3442,47 @@ interface ZodType<out Output = unknown, out Input = unknown, out Internals exten
   "~standard": ZodStandardSchemaWithJSON<this>;
   /** Converts this schema to a JSON Schema representation. */
   toJSONSchema(params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<this>;
-  check(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
-  with(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
+  check(...checks: (CheckFn<output$1<this>> | $ZodCheck<output$1<this>>)[]): this;
+  with(...checks: (CheckFn<output$1<this>> | $ZodCheck<output$1<this>>)[]): this;
   clone(def?: Internals["def"], params?: {
     parent: boolean;
   }): this;
   register<R extends $ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [$replace<R["_meta"], this>?] : [$replace<R["_meta"], this>] : ["Incompatible schema"]): this;
   brand<T extends PropertyKey = PropertyKey, Dir extends "in" | "out" | "inout" = "out">(value?: T): PropertyKey extends T ? this : $ZodBranded<this, T, Dir>;
-  parse(data: unknown, params?: ParseContext<$ZodIssue>): output<this>;
-  safeParse(data: unknown, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
-  parseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
-  safeParseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
-  spa: (data: unknown, params?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<output<this>>>;
-  validate(data: unknown, params?: ParseContext<$ZodIssue>): data is input<this>;
+  parse(data: unknown, params?: ParseContext<$ZodIssue>): output$1<this>;
+  safeParse(data: unknown, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output$1<this>>;
+  parseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<output$1<this>>;
+  safeParseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output$1<this>>>;
+  spa: (data: unknown, params?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<output$1<this>>>;
+  validate(data: unknown, params?: ParseContext<$ZodIssue>): data is input$1<this>;
   validateAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<boolean>;
-  encode(data: output<this>, params?: ParseContext<$ZodIssue>): input<this>;
-  decode(data: input<this>, params?: ParseContext<$ZodIssue>): output<this>;
-  encodeAsync(data: output<this>, params?: ParseContext<$ZodIssue>): Promise<input<this>>;
-  decodeAsync(data: input<this>, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
-  safeEncode(data: output<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<input<this>>;
-  safeDecode(data: input<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
-  safeEncodeAsync(data: output<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<input<this>>>;
-  safeDecodeAsync(data: input<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
-  refine<Ch extends (arg: output<this>) => unknown | Promise<unknown>>(check: Ch, params?: string | $ZodCustomParams): Ch extends ((arg: any) => arg is infer R) ? this & ZodType<R, input<this>> : this;
-  superRefine(refinement: (arg: output<this>, ctx: $RefinementCtx<output<this>>) => void | Promise<void>, params?: $ZodSuperRefineParams): this;
-  overwrite(fn: (x: output<this>) => output<this>): this;
+  encode(data: output$1<this>, params?: ParseContext<$ZodIssue>): input$1<this>;
+  decode(data: input$1<this>, params?: ParseContext<$ZodIssue>): output$1<this>;
+  encodeAsync(data: output$1<this>, params?: ParseContext<$ZodIssue>): Promise<input$1<this>>;
+  decodeAsync(data: input$1<this>, params?: ParseContext<$ZodIssue>): Promise<output$1<this>>;
+  safeEncode(data: output$1<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<input$1<this>>;
+  safeDecode(data: input$1<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output$1<this>>;
+  safeEncodeAsync(data: output$1<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<input$1<this>>>;
+  safeDecodeAsync(data: input$1<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output$1<this>>>;
+  refine<Ch extends (arg: output$1<this>) => unknown | Promise<unknown>>(check: Ch, params?: string | $ZodCustomParams): Ch extends ((arg: any) => arg is infer R) ? this & ZodType<R, input$1<this>> : this;
+  superRefine(refinement: (arg: output$1<this>, ctx: $RefinementCtx<output$1<this>>) => void | Promise<void>, params?: $ZodSuperRefineParams): this;
+  overwrite(fn: (x: output$1<this>) => output$1<this>): this;
   optional(): ZodOptional<this>;
   exactOptional(): ZodExactOptional<this>;
   nonoptional(params?: string | $ZodNonOptionalParams): ZodNonOptional<this>;
   nullable(): ZodNullable<this>;
   nullish(): ZodOptional<ZodNullable<this>>;
-  default(def: NoUndefined<output<this>>): ZodDefault<this>;
-  default(def: () => NoUndefined<output<this>>): ZodDefault<this>;
-  prefault(def: () => input<this>): ZodPrefault<this>;
-  prefault(def: input<this>): ZodPrefault<this>;
+  default(def: NoUndefined<output$1<this>>): ZodDefault<this>;
+  default(def: () => NoUndefined<output$1<this>>): ZodDefault<this>;
+  prefault(def: () => input$1<this>): ZodPrefault<this>;
+  prefault(def: input$1<this>): ZodPrefault<this>;
   array(): ZodArray<this>;
   or<T extends SomeType>(option: T): ZodUnion<[this, T]>;
   and<T extends SomeType>(incoming: T): ZodIntersection<this, T>;
-  transform<NewOut>(transform: (arg: output<this>, ctx: $RefinementCtx<output<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, output<this>>>;
-  catch(def: output<this>): ZodCatch<this>;
-  catch(def: (ctx: $ZodCatchCtx) => output<this>): ZodCatch<this>;
-  pipe<T extends $ZodType<any, output<this>>>(target: T | $ZodType<any, output<this>>): ZodPipe<this, T>;
+  transform<NewOut>(transform: (arg: output$1<this>, ctx: $RefinementCtx<output$1<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, output$1<this>>>;
+  catch(def: output$1<this>): ZodCatch<this>;
+  catch(def: (ctx: $ZodCatchCtx) => output$1<this>): ZodCatch<this>;
+  pipe<T extends $ZodType<any, output$1<this>>>(target: T | $ZodType<any, output$1<this>>): ZodPipe<this, T>;
   readonly(): ZodReadonly<this>;
   /** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */
   describe(description: string): this;
@@ -2041,6 +3595,169 @@ interface ZodString extends _ZodString<$ZodStringInternals<string>> {
   duration(params?: string | $ZodCheckISODurationParams): this;
 }
 declare const ZodString: $constructor<ZodString>;
+declare function string$1(params?: string | $ZodStringParams): ZodString;
+declare function string$1<T extends string>(params?: string | $ZodStringParams): $ZodType<T, T>;
+interface ZodStringFormat<Format extends string = string> extends _ZodString<$ZodStringFormatInternals<Format>> {}
+declare const ZodStringFormat: $constructor<ZodStringFormat>;
+interface ZodISODateTime extends ZodStringFormat {
+  _zod: $ZodISODateTimeInternals;
+}
+declare const ZodISODateTime: $constructor<ZodISODateTime>;
+interface ZodISODate extends ZodStringFormat {
+  _zod: $ZodISODateInternals;
+}
+declare const ZodISODate: $constructor<ZodISODate>;
+interface ZodISOTime extends ZodStringFormat {
+  _zod: $ZodISOTimeInternals;
+}
+declare const ZodISOTime: $constructor<ZodISOTime>;
+interface ZodISODuration extends ZodStringFormat {
+  _zod: $ZodISODurationInternals;
+}
+declare const ZodISODuration: $constructor<ZodISODuration>;
+interface ZodEmail extends ZodStringFormat<"email"> {
+  _zod: $ZodEmailInternals;
+}
+declare const ZodEmail: $constructor<ZodEmail>;
+declare function email(params?: string | $ZodEmailParams): ZodEmail;
+interface ZodGUID extends ZodStringFormat<"guid"> {
+  _zod: $ZodGUIDInternals;
+}
+declare const ZodGUID: $constructor<ZodGUID>;
+declare function guid(params?: string | $ZodGUIDParams): ZodGUID;
+interface ZodUUID extends ZodStringFormat<"uuid"> {
+  _zod: $ZodUUIDInternals;
+}
+declare const ZodUUID: $constructor<ZodUUID>;
+declare function uuid(params?: string | $ZodUUIDParams): ZodUUID;
+declare function uuidv4(params?: string | $ZodUUIDv4Params): ZodUUID;
+declare function uuidv6(params?: string | $ZodUUIDv6Params): ZodUUID;
+declare function uuidv7(params?: string | $ZodUUIDv7Params): ZodUUID;
+interface ZodURL extends ZodStringFormat<"url"> {
+  _zod: $ZodURLInternals;
+}
+declare const ZodURL: $constructor<ZodURL>;
+declare function url(params?: string | $ZodURLParams): ZodURL;
+declare function httpUrl(params?: string | Omit<$ZodURLParams, "protocol" | "hostname">): ZodURL;
+interface ZodEmoji extends ZodStringFormat<"emoji"> {
+  _zod: $ZodEmojiInternals;
+}
+declare const ZodEmoji: $constructor<ZodEmoji>;
+declare function emoji(params?: string | $ZodEmojiParams): ZodEmoji;
+interface ZodNanoID extends ZodStringFormat<"nanoid"> {
+  _zod: $ZodNanoIDInternals;
+}
+declare const ZodNanoID: $constructor<ZodNanoID>;
+declare function nanoid(params?: string | $ZodNanoIDParams): 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 ZodCUID extends ZodStringFormat<"cuid"> {
+  _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>;
+/**
+ * Validates a CUID v1 string.
+ *
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link cuid2 | `z.cuid2()`} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+declare function cuid(params?: string | $ZodCUIDParams): ZodCUID;
+interface ZodCUID2 extends ZodStringFormat<"cuid2"> {
+  _zod: $ZodCUID2Internals;
+}
+declare const ZodCUID2: $constructor<ZodCUID2>;
+declare function cuid2(params?: string | $ZodCUID2Params): ZodCUID2;
+interface ZodULID extends ZodStringFormat<"ulid"> {
+  _zod: $ZodULIDInternals;
+}
+declare const ZodULID: $constructor<ZodULID>;
+declare function ulid(params?: string | $ZodULIDParams): ZodULID;
+interface ZodXID extends ZodStringFormat<"xid"> {
+  _zod: $ZodXIDInternals;
+}
+declare const ZodXID: $constructor<ZodXID>;
+declare function xid(params?: string | $ZodXIDParams): ZodXID;
+interface ZodKSUID extends ZodStringFormat<"ksuid"> {
+  _zod: $ZodKSUIDInternals;
+}
+declare const ZodKSUID: $constructor<ZodKSUID>;
+declare function ksuid(params?: string | $ZodKSUIDParams): ZodKSUID;
+interface ZodIPv4 extends ZodStringFormat<"ipv4"> {
+  _zod: $ZodIPv4Internals;
+}
+declare const ZodIPv4: $constructor<ZodIPv4>;
+declare function ipv4(params?: string | $ZodIPv4Params): ZodIPv4;
+interface ZodMAC extends ZodStringFormat<"mac"> {
+  _zod: $ZodMACInternals;
+}
+declare const ZodMAC: $constructor<ZodMAC>;
+declare function mac(params?: string | $ZodMACParams): ZodMAC;
+interface ZodIPv6 extends ZodStringFormat<"ipv6"> {
+  _zod: $ZodIPv6Internals;
+}
+declare const ZodIPv6: $constructor<ZodIPv6>;
+declare function ipv6(params?: string | $ZodIPv6Params): ZodIPv6;
+interface ZodCIDRv4 extends ZodStringFormat<"cidrv4"> {
+  _zod: $ZodCIDRv4Internals;
+}
+declare const ZodCIDRv4: $constructor<ZodCIDRv4>;
+declare function cidrv4(params?: string | $ZodCIDRv4Params): ZodCIDRv4;
+interface ZodCIDRv6 extends ZodStringFormat<"cidrv6"> {
+  _zod: $ZodCIDRv6Internals;
+}
+declare const ZodCIDRv6: $constructor<ZodCIDRv6>;
+declare function cidrv6(params?: string | $ZodCIDRv6Params): ZodCIDRv6;
+interface ZodBase64 extends ZodStringFormat<"base64"> {
+  _zod: $ZodBase64Internals;
+}
+declare const ZodBase64: $constructor<ZodBase64>;
+declare function base64(params?: string | $ZodBase64Params): ZodBase64;
+interface ZodBase64URL extends ZodStringFormat<"base64url"> {
+  _zod: $ZodBase64URLInternals;
+}
+declare const ZodBase64URL: $constructor<ZodBase64URL>;
+declare function base64url(params?: string | $ZodBase64URLParams): ZodBase64URL;
+interface ZodE164 extends ZodStringFormat<"e164"> {
+  _zod: $ZodE164Internals;
+}
+declare const ZodE164: $constructor<ZodE164>;
+declare function e164(params?: string | $ZodE164Params): ZodE164;
+interface ZodCreditCard extends ZodStringFormat<"credit_card"> {
+  _zod: $ZodCreditCardInternals;
+}
+declare const ZodCreditCard: $constructor<ZodCreditCard>;
+declare function creditCard(params?: string | $ZodCreditCardParams): ZodCreditCard;
+interface ZodIBAN extends ZodStringFormat<"iban"> {
+  _zod: $ZodIBANInternals;
+}
+declare const ZodIBAN: $constructor<ZodIBAN>;
+declare function iban(params?: string | $ZodIBANParams): ZodIBAN;
+interface ZodJWT extends ZodStringFormat<"jwt"> {
+  _zod: $ZodJWTInternals;
+}
+declare const ZodJWT: $constructor<ZodJWT>;
+declare function jwt(params?: string | $ZodJWTParams): ZodJWT;
+interface ZodCustomStringFormat<Format extends string = string> extends ZodStringFormat<Format>, $ZodCustomStringFormat<Format> {
+  _zod: $ZodCustomStringFormatInternals<Format>;
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodCustomStringFormat: $constructor<ZodCustomStringFormat>;
+declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => MaybeAsync<unknown>) | RegExp, _params?: string | $ZodStringFormatParams): ZodCustomStringFormat<Format>;
+declare function hostname(_params?: string | $ZodStringFormatParams): ZodCustomStringFormat<"hostname">;
+declare function hex(_params?: string | $ZodStringFormatParams): ZodCustomStringFormat<"hex">;
+declare function currencyCode(_params?: string | $ZodStringFormatParams): ZodCustomStringFormat<"currency_code">;
+declare function hash<Alg extends HashAlgorithm, Enc extends HashEncoding = "hex">(alg: Alg, params?: {
+  enc?: Enc;
+} & $ZodStringFormatParams): ZodCustomStringFormat<`${Alg}_${Enc}`>;
 interface _ZodNumber<Internals extends $ZodNumberInternals = $ZodNumberInternals> extends _ZodType<Internals> {
   gt(value: number, params?: string | $ZodCheckGreaterThanParams): this;
   /** Identical to .min() */
@@ -2073,9 +3790,86 @@ interface _ZodNumber<Internals extends $ZodNumberInternals = $ZodNumberInternals
 }
 interface ZodNumber extends _ZodNumber<$ZodNumberInternals<number>> {}
 declare const ZodNumber: $constructor<ZodNumber>;
+declare function number$1(params?: string | $ZodNumberParams): ZodNumber;
+interface ZodNumberFormat<Format extends $ZodNumberFormats = $ZodNumberFormats> extends ZodNumber {
+  _zod: $ZodNumberFormatInternals<Format>;
+}
+declare const ZodNumberFormat: $constructor<ZodNumberFormat>;
+interface ZodInt extends ZodNumberFormat<"safeint"> {}
+declare function int(params?: string | $ZodCheckNumberFormatParams): ZodInt;
+interface ZodFloat32 extends ZodNumberFormat<"float32"> {}
+declare function float32(params?: string | $ZodCheckNumberFormatParams): ZodFloat32;
+interface ZodFloat64 extends ZodNumberFormat<"float64"> {}
+declare function float64(params?: string | $ZodCheckNumberFormatParams): ZodFloat64;
+interface ZodInt32 extends ZodNumberFormat<"int32"> {}
+declare function int32(params?: string | $ZodCheckNumberFormatParams): ZodInt32;
+interface ZodUInt32 extends ZodNumberFormat<"uint32"> {}
+declare function uint32(params?: string | $ZodCheckNumberFormatParams): ZodUInt32;
 interface _ZodBoolean<T extends $ZodBooleanInternals = $ZodBooleanInternals> extends _ZodType<T> {}
 interface ZodBoolean extends _ZodBoolean<$ZodBooleanInternals<boolean>> {}
 declare const ZodBoolean: $constructor<ZodBoolean>;
+declare function boolean$1(params?: string | $ZodBooleanParams): ZodBoolean;
+interface _ZodBigInt<T extends $ZodBigIntInternals = $ZodBigIntInternals> extends _ZodType<T> {
+  gte(value: bigint, params?: string | $ZodCheckGreaterThanParams): this;
+  /** Alias of `.gte()` */
+  min(value: bigint, params?: string | $ZodCheckGreaterThanParams): this;
+  gt(value: bigint, params?: string | $ZodCheckGreaterThanParams): this;
+  /** Alias of `.lte()` */
+  lte(value: bigint, params?: string | $ZodCheckLessThanParams): this;
+  max(value: bigint, params?: string | $ZodCheckLessThanParams): this;
+  lt(value: bigint, params?: string | $ZodCheckLessThanParams): this;
+  positive(params?: string | $ZodCheckGreaterThanParams): this;
+  negative(params?: string | $ZodCheckLessThanParams): this;
+  nonpositive(params?: string | $ZodCheckLessThanParams): this;
+  nonnegative(params?: string | $ZodCheckGreaterThanParams): this;
+  multipleOf(value: bigint, params?: string | $ZodCheckMultipleOfParams): this;
+  minValue: bigint | null;
+  maxValue: bigint | null;
+  format: string | null;
+}
+interface ZodBigInt extends _ZodBigInt<$ZodBigIntInternals<bigint>> {}
+declare const ZodBigInt: $constructor<ZodBigInt>;
+declare function bigint$1(params?: string | $ZodBigIntParams): ZodBigInt;
+interface ZodBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends ZodBigInt {
+  _zod: $ZodBigIntFormatInternals<Format>;
+}
+declare const ZodBigIntFormat: $constructor<ZodBigIntFormat>;
+interface ZodInt64 extends ZodBigIntFormat<"int64"> {}
+declare function int64(params?: string | $ZodBigIntFormatParams): ZodInt64;
+interface ZodUInt64 extends ZodBigIntFormat<"uint64"> {}
+declare function uint64(params?: string | $ZodBigIntFormatParams): ZodUInt64;
+interface ZodSymbol extends _ZodType<$ZodSymbolInternals> {}
+declare const ZodSymbol: $constructor<ZodSymbol>;
+declare function symbol(params?: string | $ZodSymbolParams): ZodSymbol;
+interface ZodUndefined extends _ZodType<$ZodUndefinedInternals> {}
+declare const ZodUndefined: $constructor<ZodUndefined>;
+declare function _undefined(params?: string | $ZodUndefinedParams): ZodUndefined;
+interface ZodNull extends _ZodType<$ZodNullInternals> {}
+declare const ZodNull: $constructor<ZodNull>;
+declare function _null(params?: string | $ZodNullParams): ZodNull;
+interface ZodAny extends _ZodType<$ZodAnyInternals> {}
+declare const ZodAny: $constructor<ZodAny>;
+declare function any(): ZodAny;
+interface ZodUnknown extends _ZodType<$ZodUnknownInternals> {}
+declare const ZodUnknown: $constructor<ZodUnknown>;
+declare function unknown(): ZodUnknown;
+interface ZodNever extends _ZodType<$ZodNeverInternals> {}
+declare const ZodNever: $constructor<ZodNever>;
+declare function never(params?: string | $ZodNeverParams): ZodNever;
+interface ZodVoid extends _ZodType<$ZodVoidInternals> {}
+declare const ZodVoid: $constructor<ZodVoid>;
+declare function _void(params?: string | $ZodVoidParams): ZodVoid;
+interface _ZodDate<T extends $ZodDateInternals = $ZodDateInternals> extends _ZodType<T> {
+  min(value: number | Date, params?: string | $ZodCheckGreaterThanParams): this;
+  max(value: number | Date, params?: string | $ZodCheckLessThanParams): this;
+  /** @deprecated Not recommended. */
+  minDate: Date | null;
+  /** @deprecated Not recommended. */
+  maxDate: Date | null;
+}
+interface ZodDate extends _ZodDate<$ZodDateInternals<Date>> {}
+declare const ZodDate: $constructor<ZodDate>;
+declare function date$2(params?: string | $ZodDateParams): ZodDate;
 interface ZodArray<T extends SomeType = $ZodType> extends _ZodType<$ZodArrayInternals<T>>, $ZodArray<T> {
   element: T;
   min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
@@ -2086,7 +3880,9 @@ interface ZodArray<T extends SomeType = $ZodType> extends _ZodType<$ZodArrayInte
   "~standard": ZodStandardSchemaWithJSON<this>;
 }
 declare const ZodArray: $constructor<ZodArray>;
-type SafeExtendShape<Base extends $ZodShape, Ext extends $ZodLooseShape> = { [K in keyof Ext]: K extends keyof Base ? output<Ext[K]> extends output<Base[K]> ? input<Ext[K]> extends input<Base[K]> ? Ext[K] : never : never : Ext[K]; };
+declare function array<T extends SomeType>(element: T, params?: string | $ZodArrayParams): ZodArray<T>;
+declare function keyof<T extends ZodObject>(schema: T): ZodEnum<KeysEnum<T["_zod"]["output"]>>;
+type SafeExtendShape<Base extends $ZodShape, Ext extends $ZodLooseShape> = { [K in keyof Ext]: K extends keyof Base ? output$1<Ext[K]> extends output$1<Base[K]> ? input$1<Ext[K]> extends input$1<Base[K]> ? Ext[K] : never : never : Ext[K]; };
 interface ZodObject<
 /** @ts-ignore Cast variance */
 out Shape extends $ZodShape = $ZodLooseShape, out Config extends $ZodObjectConfig = $strip> extends _ZodType<$ZodObjectInternals<Shape, Config>>, $ZodObject<Shape, Config> {
@@ -2119,21 +3915,74 @@ out Shape extends $ZodShape = $ZodLooseShape, out Config extends $ZodObjectConfi
   required<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{ -readonly [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k]> : Shape[k]; }, Config>;
 }
 declare const ZodObject: $constructor<ZodObject>;
+declare function object<T extends $ZodLooseShape = Partial<Record<never, SomeType>>>(shape?: T, params?: string | $ZodObjectParams): ZodObject<Writeable<T>, $strip>;
+declare function strictObject<T extends $ZodLooseShape>(shape: T, params?: string | $ZodObjectParams): ZodObject<Writeable<T>, $strict>;
+declare function looseObject<T extends $ZodLooseShape>(shape: T, params?: string | $ZodObjectParams): ZodObject<Writeable<T>, $loose>;
 interface ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends _ZodType<$ZodUnionInternals<T>>, $ZodUnion<T> {
   "~standard": ZodStandardSchemaWithJSON<this>;
   options: T;
 }
 declare const ZodUnion: $constructor<ZodUnion>;
+declare function union<const T extends readonly SomeType[]>(options: T, params?: string | $ZodUnionParams): ZodUnion<T>;
+interface ZodXor<T extends readonly SomeType[] = readonly $ZodType[]> extends _ZodType<$ZodXorInternals<T>>, $ZodXor<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  options: T;
+}
+declare const ZodXor: $constructor<ZodXor>;
+/** Creates an exclusive union (XOR) where exactly one option must match.
+ * Unlike regular unions that succeed when any option matches, xor fails if
+ * zero or more than one option matches the input. */
+declare function xor<const T extends readonly SomeType[]>(options: T, params?: string | $ZodXorParams): ZodXor<T>;
 interface ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends ZodUnion<Options>, $ZodDiscriminatedUnion<Options, Disc> {
   "~standard": ZodStandardSchemaWithJSON<this>;
   _zod: $ZodDiscriminatedUnionInternals<Options, Disc>;
   def: $ZodDiscriminatedUnionDef<Options, Disc>;
 }
 declare const ZodDiscriminatedUnion: $constructor<ZodDiscriminatedUnion>;
+declare function discriminatedUnion<Types extends readonly [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc>;
 interface ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodIntersectionInternals<A, B>>, $ZodIntersection<A, B> {
   "~standard": ZodStandardSchemaWithJSON<this>;
 }
 declare const ZodIntersection: $constructor<ZodIntersection>;
+declare function intersection<T extends SomeType, U extends SomeType>(left: T, right: U): ZodIntersection<T, U>;
+interface ZodTuple<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends _ZodType<$ZodTupleInternals<T, Rest>>, $ZodTuple<T, Rest> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  rest<Rest extends SomeType = $ZodType>(rest: Rest): ZodTuple<T, Rest>;
+  partial(): ZodTuple<{ -readonly [k in keyof T]: ZodOptional<T[k]>; }, Rest>;
+}
+declare const ZodTuple: $constructor<ZodTuple>;
+declare function tuple<T extends readonly [SomeType, ...SomeType[]]>(items: T, params?: string | $ZodTupleParams): ZodTuple<T, null>;
+declare function tuple<T extends readonly [SomeType, ...SomeType[]], Rest extends SomeType>(items: T, rest: Rest, params?: string | $ZodTupleParams): ZodTuple<T, Rest>;
+declare function tuple(items: [], params?: string | $ZodTupleParams): ZodTuple<[], null>;
+interface ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends _ZodType<$ZodRecordInternals<Key, Value>>, $ZodRecord<Key, Value> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  keyType: Key;
+  valueType: Value;
+}
+declare const ZodRecord: $constructor<ZodRecord>;
+declare function record<Key extends $ZodRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | $ZodRecordParams): ZodRecord<Key, Value>;
+declare function partialRecord<Key extends $ZodRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | $ZodRecordParams): ZodRecord<Key & $partial, Value>;
+declare function looseRecord<Key extends $ZodRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | $ZodRecordParams): ZodRecord<Key, Value>;
+interface ZodMap<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends _ZodType<$ZodMapInternals<Key, Value>>, $ZodMap<Key, Value> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  keyType: Key;
+  valueType: Value;
+  min(minSize: number, params?: string | $ZodCheckMinSizeParams): this;
+  nonempty(params?: string | $ZodCheckMinSizeParams): this;
+  max(maxSize: number, params?: string | $ZodCheckMaxSizeParams): this;
+  size(size: number, params?: string | $ZodCheckSizeEqualsParams): this;
+}
+declare const ZodMap: $constructor<ZodMap>;
+declare function map<Key extends SomeType, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | $ZodMapParams): ZodMap<Key, Value>;
+interface ZodSet<T extends SomeType = $ZodType> extends _ZodType<$ZodSetInternals<T>>, $ZodSet<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  min(minSize: number, params?: string | $ZodCheckMinSizeParams): this;
+  nonempty(params?: string | $ZodCheckMinSizeParams): this;
+  max(maxSize: number, params?: string | $ZodCheckMaxSizeParams): this;
+  size(size: number, params?: string | $ZodCheckSizeEqualsParams): this;
+}
+declare const ZodSet: $constructor<ZodSet>;
+declare function set<Value extends SomeType>(valueType: Value, params?: string | $ZodSetParams): ZodSet<Value>;
 interface ZodEnum<
 /** @ts-ignore Cast variance */
 out T extends EnumLike = EnumLike> extends _ZodType<$ZodEnumInternals<T>>, $ZodEnum<T> {
@@ -2144,6 +3993,16 @@ out T extends EnumLike = EnumLike> extends _ZodType<$ZodEnumInternals<T>>, $ZodE
   exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Omit<T, U[number]>>>;
 }
 declare const ZodEnum: $constructor<ZodEnum>;
+declare function _enum<const T extends readonly string[]>(values: T, params?: string | $ZodEnumParams): ZodEnum<ToEnum<T[number]>>;
+declare function _enum<const T extends EnumLike>(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>(entries: T, params?: string | $ZodEnumParams): ZodEnum<T>;
 interface ZodLiteral<T extends Literal = Literal> extends _ZodType<$ZodLiteralInternals<T>>, $ZodLiteral<T> {
   "~standard": ZodStandardSchemaWithJSON<this>;
   values: Set<T>;
@@ -2151,25 +4010,40 @@ interface ZodLiteral<T extends Literal = Literal> extends _ZodType<$ZodLiteralIn
   value: T;
 }
 declare const ZodLiteral: $constructor<ZodLiteral>;
+declare function literal<const T extends ReadonlyArray<Literal>>(value: T, params?: string | $ZodLiteralParams): ZodLiteral<T[number]>;
+declare function literal<const T extends Literal>(value: T, params?: string | $ZodLiteralParams): ZodLiteral<T>;
+interface ZodFile extends _ZodType<$ZodFileInternals>, $ZodFile {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  min(size: number, params?: string | $ZodCheckMinSizeParams): this;
+  max(size: number, params?: string | $ZodCheckMaxSizeParams): this;
+  mime(types: MimeTypes | Array<MimeTypes>, params?: string | $ZodCheckMimeTypeParams): this;
+}
+declare const ZodFile: $constructor<ZodFile>;
+declare function file(params?: string | $ZodFileParams): ZodFile;
 interface ZodTransform<O = unknown, I = unknown> extends _ZodType<$ZodTransformInternals<O, I>>, $ZodTransform<O, I> {
   "~standard": ZodStandardSchemaWithJSON<this>;
 }
 declare const ZodTransform: $constructor<ZodTransform>;
+declare function transform<I = unknown, O = I>(fn: (input: I, ctx: $RefinementCtx) => O): ZodTransform<Awaited<O>, I>;
 interface ZodOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodOptionalInternals<T>>, $ZodOptional<T> {
   "~standard": ZodStandardSchemaWithJSON<this>;
   unwrap(): T;
 }
 declare const ZodOptional: $constructor<ZodOptional>;
+declare function optional<T extends SomeType>(innerType: T): ZodOptional<T>;
 interface ZodExactOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodExactOptionalInternals<T>>, $ZodExactOptional<T> {
   "~standard": ZodStandardSchemaWithJSON<this>;
   unwrap(): T;
 }
 declare const ZodExactOptional: $constructor<ZodExactOptional>;
+declare function exactOptional<T extends SomeType>(innerType: T): ZodExactOptional<T>;
 interface ZodNullable<T extends SomeType = $ZodType> extends _ZodType<$ZodNullableInternals<T>>, $ZodNullable<T> {
   "~standard": ZodStandardSchemaWithJSON<this>;
   unwrap(): T;
 }
 declare const ZodNullable: $constructor<ZodNullable>;
+declare function nullable<T extends SomeType>(innerType: T): ZodNullable<T>;
+declare function nullish<T extends SomeType>(innerType: T): ZodOptional<ZodNullable<T>>;
 interface ZodDefault<T extends SomeType = $ZodType> extends _ZodType<$ZodDefaultInternals<T>>, $ZodDefault<T> {
   "~standard": ZodStandardSchemaWithJSON<this>;
   unwrap(): T;
@@ -2177,16 +4051,25 @@ interface ZodDefault<T extends SomeType = $ZodType> extends _ZodType<$ZodDefault
   removeDefault(): T;
 }
 declare const ZodDefault: $constructor<ZodDefault>;
+declare function _default<T extends SomeType>(innerType: T, defaultValue: NoUndefined<output$1<T>> | (() => NoUndefined<output$1<T>>)): ZodDefault<T>;
 interface ZodPrefault<T extends SomeType = $ZodType> extends _ZodType<$ZodPrefaultInternals<T>>, $ZodPrefault<T> {
   "~standard": ZodStandardSchemaWithJSON<this>;
   unwrap(): T;
 }
 declare const ZodPrefault: $constructor<ZodPrefault>;
+declare function prefault<T extends SomeType>(innerType: T, defaultValue: input$1<T> | (() => input$1<T>)): ZodPrefault<T>;
 interface ZodNonOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodNonOptionalInternals<T>>, $ZodNonOptional<T> {
   "~standard": ZodStandardSchemaWithJSON<this>;
   unwrap(): T;
 }
 declare const ZodNonOptional: $constructor<ZodNonOptional>;
+declare function nonoptional<T extends SomeType>(innerType: T, params?: string | $ZodNonOptionalParams): ZodNonOptional<T>;
+interface ZodSuccess<T extends SomeType = $ZodType> extends _ZodType<$ZodSuccessInternals<T>>, $ZodSuccess<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodSuccess: $constructor<ZodSuccess>;
+declare function success<T extends SomeType>(innerType: T): ZodSuccess<T>;
 interface ZodCatch<T extends SomeType = $ZodType> extends _ZodType<$ZodCatchInternals<T>>, $ZodCatch<T> {
   "~standard": ZodStandardSchemaWithJSON<this>;
   unwrap(): T;
@@ -2194,17 +4077,207 @@ interface ZodCatch<T extends SomeType = $ZodType> extends _ZodType<$ZodCatchInte
   removeCatch(): T;
 }
 declare const ZodCatch: $constructor<ZodCatch>;
+declare function _catch<T extends SomeType>(innerType: T, catchValue: output$1<T> | ((ctx: $ZodCatchCtx) => output$1<T>)): ZodCatch<T>;
+interface ZodNaN extends _ZodType<$ZodNaNInternals>, $ZodNaN {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodNaN: $constructor<ZodNaN>;
+declare function nan(params?: string | $ZodNaNParams): ZodNaN;
 interface ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodPipeInternals<A, B>>, $ZodPipe<A, B> {
   "~standard": ZodStandardSchemaWithJSON<this>;
   in: A;
   out: B;
 }
 declare const ZodPipe: $constructor<ZodPipe>;
+declare function pipe<const A extends SomeType, B extends $ZodType<unknown, output$1<A>> = $ZodType<unknown, output$1<A>>>(in_: A, out: B | $ZodType<unknown, output$1<A>>): ZodPipe<A, B>;
+interface ZodCodec<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends ZodPipe<A, B>, $ZodCodec<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  _zod: $ZodCodecInternals<A, B>;
+  def: $ZodCodecDef<A, B>;
+}
+declare const ZodCodec: $constructor<ZodCodec>;
+declare function codec<const A extends SomeType, B extends SomeType = $ZodType>(in_: A, out: B, params: {
+  decode: (value: output$1<A>, payload: ParsePayload<output$1<A>>) => MaybeAsync<input$1<B>>;
+  encode: (value: input$1<B>, payload: ParsePayload<input$1<B>>) => MaybeAsync<output$1<A>>;
+}): ZodCodec<A, B>;
+declare function invertCodec<A extends SomeType, B extends SomeType>(codec: ZodCodec<A, B>): ZodCodec<B, A>;
+interface ZodPreprocess<B extends SomeType = $ZodType, I = unknown> extends ZodPipe<$ZodTransform<unknown, I>, B>, $ZodPreprocess<B, I> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  _zod: $ZodPreprocessInternals<B, I>;
+  def: $ZodPreprocessDef<B, I>;
+}
+declare const ZodPreprocess: $constructor<ZodPreprocess>;
 interface ZodReadonly<T extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T>>, $ZodReadonly<T> {
   "~standard": ZodStandardSchemaWithJSON<this>;
   unwrap(): T;
 }
 declare const ZodReadonly: $constructor<ZodReadonly>;
+declare function readonly<T extends SomeType>(innerType: T): ZodReadonly<T>;
+interface ZodTemplateLiteral<Template extends string = string> extends _ZodType<$ZodTemplateLiteralInternals<Template>>, $ZodTemplateLiteral<Template> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodTemplateLiteral: $constructor<ZodTemplateLiteral>;
+declare function templateLiteral<const Parts extends $ZodTemplateLiteralPart[]>(parts: Parts, params?: string | $ZodTemplateLiteralParams): ZodTemplateLiteral<$PartsToTemplateLiteral<Parts>>;
+interface ZodLazy<T extends SomeType = $ZodType> extends _ZodType<$ZodLazyInternals<T>>, $ZodLazy<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodLazy: $constructor<ZodLazy>;
+declare function lazy<T extends SomeType>(getter: () => T): ZodLazy<T>;
+interface ZodPromise<T extends SomeType = $ZodType> extends _ZodType<$ZodPromiseInternals<T>>, $ZodPromise<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodPromise: $constructor<ZodPromise>;
+declare function promise<T extends SomeType>(innerType: T): ZodPromise<T>;
+interface ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> extends _ZodType<$ZodFunctionInternals<Args, Returns>>, $ZodFunction<Args, Returns> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  _def: $ZodFunctionDef<Args, Returns>;
+  _input: $InferInnerFunctionType<Args, Returns>;
+  _output: $InferOuterFunctionType<Args, Returns>;
+  input<const Items extends TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest): ZodFunction<$ZodTuple<Items, Rest>, Returns>;
+  input<NewArgs extends $ZodFunctionIn>(args: NewArgs): ZodFunction<NewArgs, Returns>;
+  input(...args: any[]): ZodFunction<any, Returns>;
+  output<NewReturns extends $ZodType>(output: NewReturns): ZodFunction<Args, NewReturns>;
+}
+declare const ZodFunction: $constructor<ZodFunction>;
+declare function _function(): ZodFunction;
+declare function _function<const In extends ReadonlyArray<$ZodType>>(params: {
+  input: In;
+}): ZodFunction<ZodTuple<In, null>, $ZodFunctionOut>;
+declare function _function<const In extends ReadonlyArray<$ZodType>, const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
+  input: In;
+  output: Out;
+}): ZodFunction<ZodTuple<In, null>, Out>;
+declare function _function<const In extends $ZodFunctionIn = $ZodFunctionIn>(params: {
+  input: In;
+}): ZodFunction<In, $ZodFunctionOut>;
+declare function _function<const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
+  output: Out;
+}): ZodFunction<$ZodFunctionIn, Out>;
+declare function _function<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodType = $ZodType>(params?: {
+  input: In;
+  output: Out;
+}): ZodFunction<In, Out>;
+interface ZodCustom<O = unknown, I = unknown> extends _ZodType<$ZodCustomInternals<O, I>>, $ZodCustom<O, I> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodCustom: $constructor<ZodCustom>;
+declare function check<O = unknown>(fn: CheckFn<O>): $ZodCheck<O>;
+declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | $ZodCustomParams | undefined): ZodCustom<O, O>;
+declare function refine<T>(fn: (arg: NoInfer<T>) => MaybeAsync<unknown>, _params?: string | $ZodCustomParams): $ZodCheck<T>;
+declare function superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>, params?: $ZodSuperRefineParams): $ZodCheck<T>;
+declare const describe: typeof describe$1;
+declare const meta: typeof meta$1;
+type ZodInstanceOfParams = Params<ZodCustom, $ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
+interface ZodInstanceOf<T = unknown> extends ZodCustom<T, T> {
+  properties<Shape extends { [k in keyof T as T[k] extends Function ? never : k]?: $ZodType<unknown, T[k]>; }>(shape: Shape, params?: string | $ZodCheckPropertiesParams): ZodInstanceOf<T & $InferObjectInput<Shape, {}>>;
+}
+declare const ZodInstanceOf: $constructor<ZodInstanceOf>;
+declare function _instanceof<T extends typeof Class>(cls: T, params?: ZodInstanceOfParams): ZodInstanceOf<InstanceType<T>>;
+declare const stringbool: (_params?: string | $ZodStringBoolParams) => ZodCodec<ZodString, ZodBoolean>;
+type _ZodJSONSchema = ZodUnion<[ZodString, ZodNumber, ZodBoolean, ZodNull, ZodArray<ZodJSONSchema>, ZodRecord<ZodString, ZodJSONSchema>]>;
+type _ZodJSONSchemaInternals = _ZodJSONSchema["_zod"];
+interface ZodJSONSchemaInternals extends _ZodJSONSchemaInternals {
+  output: JSONType;
+  input: JSONType;
+}
+interface ZodJSONSchema extends _ZodJSONSchema {
+  _zod: ZodJSONSchemaInternals;
+}
+declare function json(params?: string | $ZodCustomParams): ZodJSONSchema;
+declare function preprocess<A, U extends SomeType, B = unknown>(fn: (arg: B, ctx: $RefinementCtx) => A, schema: U): ZodPreprocess<U, B>;
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/compat.d.cts
+/** @deprecated Use `z.output<T>` instead. */
+type TypeOf<T> = output$1<T>;
+/** @deprecated Use `z.output<T>` instead. */
+type Infer<T> = output$1<T>;
+/** @deprecated Use `z.core.$ZodTypes` instead */
+type ZodFirstPartySchemaTypes = $ZodTypes;
+/** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
+declare const ZodIssueCode: {
+  readonly invalid_type: "invalid_type";
+  readonly too_big: "too_big";
+  readonly too_small: "too_small";
+  readonly invalid_format: "invalid_format";
+  readonly not_multiple_of: "not_multiple_of";
+  readonly unrecognized_keys: "unrecognized_keys";
+  readonly invalid_union: "invalid_union";
+  readonly invalid_key: "invalid_key";
+  readonly invalid_element: "invalid_element";
+  readonly invalid_value: "invalid_value";
+  readonly custom: "custom";
+};
+/** @deprecated Use `z.core.$ZodFlattenedError<z.output<T>>` instead; it takes an inferred type, not a schema. */
+type inferFlattenedErrors<T extends $ZodType, U = string> = $ZodFlattenedError<output$1<T>, U>;
+/** @deprecated Use `z.core.$ZodFormattedError<z.output<T>>` instead; it takes an inferred type, not a schema. */
+type inferFormattedError<T extends $ZodType<any, any>, U = string> = $ZodFormattedError<output$1<T>, U>;
+/** Use `z.$brand` instead */
+type BRAND$1<T extends string | number | symbol = string | number | symbol> = {
+  [$brand]: { [k in T]: true; };
+};
+/** @deprecated Use `z.config(params)` instead. */
+declare function setErrorMap(map: $ZodErrorMap): void;
+/** @deprecated Use `z.config()` instead. */
+declare function getErrorMap(): $ZodErrorMap<$ZodIssue> | undefined;
+/** @deprecated Use z.ZodType (without generics) instead. */
+type ZodTypeAny<Output = unknown, Input = unknown, Internals extends $ZodTypeInternals<Output, Input> = $ZodTypeInternals<Output, Input>> = ZodType<Output, Input, Internals>;
+/** @deprecated Use `z.ZodType` */
+type ZodSchema<Output = unknown, Input = unknown, Internals extends $ZodTypeInternals<Output, Input> = $ZodTypeInternals<Output, Input>> = ZodType<Output, Input, Internals>;
+/** @deprecated Use `z.ZodType` */
+type Schema<Output = unknown, Input = unknown, Internals extends $ZodTypeInternals<Output, Input> = $ZodTypeInternals<Output, Input>> = ZodType<Output, Input, Internals>;
+/** Included for Zod 3 compatibility */
+type ZodRawShape = $ZodShape;
+/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
+declare enum ZodFirstPartyTypeKind {}
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/from-json-schema.d.cts
+type JSONSchemaVersion = "draft-2020-12" | "draft-7" | "draft-4" | "openapi-3.0";
+interface FromJSONSchemaParams {
+  defaultTarget?: JSONSchemaVersion;
+  registry?: $ZodRegistry<any>;
+}
+/**
+ * Converts a JSON Schema to a Zod schema. This function should be considered semi-experimental. It's behavior is liable to change. */
+declare function fromJSONSchema(schema: JSONSchema | boolean, params?: FromJSONSchemaParams): ZodType;
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/deep-partial.d.cts
+/** Distributes `.partial()` through every object in a schema type, preserving the wrappers around them. */
+type DeepPartial<T extends SomeType> = T extends ZodObject<infer Shape, infer Config> ? ZodObject<{ -readonly [K in keyof Shape]: ZodOptional<DeepPartial<Shape[K]>>; }, Config> : T extends ZodDiscriminatedUnion<infer Options, any> ? ZodUnion<{ -readonly [I in keyof Options]: Options[I] extends SomeType ? DeepPartial<Options[I]> : Options[I]; }> : T extends ZodUnion<infer Options> ? ZodUnion<{ -readonly [I in keyof Options]: Options[I] extends SomeType ? DeepPartial<Options[I]> : Options[I]; }> : T extends ZodArray<infer El> ? ZodArray<DeepPartial<El>> : T extends ZodTuple<infer Items, infer Rest> ? ZodTuple<{ -readonly [K in keyof Items]: Items[K] extends SomeType ? DeepPartial<Items[K]> : Items[K]; }, Rest extends SomeType ? DeepPartial<Rest> : Rest> : T extends ZodIntersection<infer A, infer B> ? ZodIntersection<DeepPartial<A>, DeepPartial<B>> : T extends ZodRecord<infer K, infer V> ? ZodRecord<K, DeepPartial<V>> : T extends ZodMap<infer K, infer V> ? ZodMap<K, DeepPartial<V>> : T extends ZodSet<infer El> ? ZodSet<DeepPartial<El>> : T extends ZodOptional<infer Inner> ? ZodOptional<DeepPartial<Inner>> : T extends ZodNullable<infer Inner> ? ZodNullable<DeepPartial<Inner>> : T extends ZodDefault<infer Inner> ? ZodDefault<DeepPartial<Inner>> : T extends ZodPrefault<infer Inner> ? ZodPrefault<DeepPartial<Inner>> : T extends ZodNonOptional<infer Inner> ? ZodNonOptional<DeepPartial<Inner>> : T extends ZodCatch<infer Inner> ? ZodCatch<DeepPartial<Inner>> : T extends ZodReadonly<infer Inner> ? ZodReadonly<DeepPartial<Inner>> : T extends ZodSuccess<infer Inner> ? ZodSuccess<DeepPartial<Inner>> : T extends ZodPromise<infer Inner> ? ZodPromise<DeepPartial<Inner>> : T extends ZodCodec<infer A, infer B> ? ZodCodec<DeepPartial<A>, DeepPartial<B>> : T extends ZodPreprocess<infer B> ? ZodPreprocess<DeepPartial<B>> : T extends ZodPipe<infer A, infer B> ? ZodPipe<DeepPartial<A>, DeepPartial<B>> : T extends ZodLazy<infer Inner> ? ZodLazy<DeepPartial<Inner>> : T;
+/** Returns a copy of the schema with every nested object's properties made optional. */
+declare function deepPartial<T extends SomeType>(schema: T): DeepPartial<T>;
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/in-out.d.cts
+type input<T> = input$1<T>;
+type output<T> = output$1<T>;
+/** Returns a copy of the schema with every pipe replaced by its input side. A codec's checks are dropped: they constrain the decoded value the input side never produces. */
+declare function input<T extends $ZodType>(schema: T): ZodType<input$1<T>, input$1<T>>;
+/** Returns a copy of the schema with every pipe replaced by its output side, carrying over the pipe's own checks. */
+declare function output<T extends $ZodType>(schema: T): ZodType<output$1<T>, output$1<T>>;
+declare namespace iso_d_exports {
+  export { ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime, date$1 as date, datetime, duration, time };
+}
+declare function datetime(params?: string | $ZodISODateTimeParams): ZodISODateTime;
+declare function date$1(params?: string | $ZodISODateParams): ZodISODate;
+declare function time(params?: string | $ZodISOTimeParams): ZodISOTime;
+declare function duration(params?: string | $ZodISODurationParams): ZodISODuration;
+declare namespace coerce_d_exports {
+  export { ZodCoercedBigInt, ZodCoercedBoolean, ZodCoercedDate, ZodCoercedNumber, ZodCoercedString, bigint, boolean, date, number, string };
+}
+interface ZodCoercedString<T = unknown> extends _ZodString<$ZodStringInternals<T>> {}
+declare function string<T = unknown>(params?: string | $ZodStringParams): ZodCoercedString<T>;
+interface ZodCoercedNumber<T = unknown> extends _ZodNumber<$ZodNumberInternals<T>> {}
+declare function number<T = unknown>(params?: string | $ZodNumberParams): ZodCoercedNumber<T>;
+interface ZodCoercedBoolean<T = unknown> extends _ZodBoolean<$ZodBooleanInternals<T>> {}
+declare function boolean<T = unknown>(params?: string | $ZodBooleanParams): ZodCoercedBoolean<T>;
+interface ZodCoercedBigInt<T = unknown> extends _ZodBigInt<$ZodBigIntInternals<T>> {}
+declare function bigint<T = unknown>(params?: string | $ZodBigIntParams): ZodCoercedBigInt<T>;
+interface ZodCoercedDate<T = unknown> extends _ZodDate<$ZodDateInternals<T>> {}
+declare function date<T = unknown>(params?: string | $ZodDateParams): ZodCoercedDate<T>;
+declare namespace external_d_exports {
+  export { $brand, $input, $output, BRAND$1 as BRAND, CompileOptions, GlobalMeta, INVALID, Infer, IssueData, JSONType, NEVER, $RefinementCtx as RefinementCtx, SafeExtendShape, Schema, TimePrecision, TypeOf, ZodAny, ZodArray, ZodBase64, ZodBase64URL, ZodBigInt, ZodBigIntFormat, ZodBoolean, ZodCIDRv4, ZodCIDRv6, ZodCUID, ZodCUID2, ZodCatch, ZodCodec, ZodCoercedBigInt, ZodCoercedBoolean, ZodCoercedDate, ZodCoercedNumber, ZodCoercedString, ZodCompileAsyncError, ZodCompileUnsupportedError, ZodCreditCard, ZodCustom, ZodCustomStringFormat, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodE164, ZodEmail, ZodEmoji, ZodEnum, ZodError, ZodErrorMap, ZodExactOptional, ZodFile, ZodFirstPartySchemaTypes, ZodFirstPartyTypeKind, ZodFlattenedError, ZodFloat32, ZodFloat64, ZodFormattedError, ZodFunction, ZodGUID, ZodIBAN, ZodIPv4, ZodIPv6, ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime, ZodInstanceOf, ZodInt, ZodInt32, ZodInt64, ZodIntersection, ZodIssue, ZodIssueCode, ZodJSONSchema, ZodJSONSchemaInternals, ZodJWT, ZodKSUID, ZodLazy, ZodLiteral, ZodMAC, ZodMap, ZodNaN, ZodNanoID, ZodNever, ZodNonOptional, ZodNull, ZodNullable, ZodNumber, ZodNumberFormat, ZodObject, ZodOptional, ZodPipe, ZodPrefault, ZodPreprocess, ZodPromise, ZodRawShape, ZodReadonly, ZodRealError, ZodRecord, ZodSafeParseError, ZodSafeParseResult, ZodSafeParseSuccess, ZodSchema, ZodSet, ZodStandardSchemaWithJSON, ZodString, ZodStringFormat, ZodSuccess, ZodSymbol, ZodTemplateLiteral, ZodTransform, ZodTuple, ZodType, ZodTypeAny, ZodUInt32, ZodUInt64, ZodULID, ZodURL, ZodUUID, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, ZodXID, ZodXor, _ZodBigInt, _ZodBoolean, _ZodDate, _ZodNumber, _ZodString, _ZodType, _default, _function, any, array, base64, base64url, bigint$1 as bigint, boolean$1 as boolean, _catch as catch, check, cidrv4, cidrv6, clone, codec, coerce_d_exports as coerce, compile, config, index_d_exports as core, creditCard, cuid, cuid2, currencyCode, custom, date$2 as date, decode, decodeAsync, deepPartial, describe, discriminatedUnion, e164, email, emoji, encode, encodeAsync, _endsWith as endsWith, _enum as enum, exactOptional, file, flattenError, float32, float64, formatError, fromJSONSchema, _function as function, getDiscriminatedOption, getErrorMap, globalRegistry, _gt as gt, _gte as gte, guid, hash, hex, hostname, httpUrl, iban, _includes as includes, output$1 as infer, inferFlattenedErrors, inferFormattedError, input, _instanceof as instanceof, int, int32, int64, intersection, invertCodec, ipv4, ipv6, iso_d_exports as iso, json, jwt, keyof, ksuid, lazy, _length as length, literal, index_d_exports$1 as locales, looseObject, looseRecord, _lowercase as lowercase, _lt as lt, _lte as lte, mac, map, _maxLength as maxLength, _maxSize as maxSize, memoizer, meta, _mime as mime, _minLength as minLength, _minSize as minSize, _multipleOf as multipleOf, nan, nanoid, nativeEnum, _negative as negative, never, _nonnegative as nonnegative, nonoptional, _nonpositive as nonpositive, _normalize as normalize, _null as null, nullable, nullish, number$1 as number, object, optional, output, _overwrite as overwrite, parse, parseAsync, partialRecord, pipe, _positive as positive, prefault, preprocess, prettifyError, promise, _properties as properties, _property as property, readonly, record, refine, _regex as regex, regexes_d_exports as regexes, registry, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync, set, setErrorMap, _size as size, _slugify as slugify, _startsWith as startsWith, strictObject, string$1 as string, stringFormat, stringbool, success, superRefine, symbol, templateLiteral, toJSONSchema, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, toZod, transform, treeifyError, _trim as trim, tuple, uint32, uint64, ulid, _undefined as undefined, union, unknown, _uppercase as uppercase, url, util_d_exports as util, uuid, uuidv4, uuidv6, uuidv7, validate, validateAsync, _void as void, withParser, xid, xor };
+}
 //#endregion
 //#region ../../../vendor/deepseek-harness/packages/session/session-projection/lib/types/types.d.ts
 /**
@@ -2863,7 +4936,7 @@ declare const checkpointIdentity: ZodObject<{
   inheritedEventCount: ZodOptional<ZodPipe<ZodNumber, ZodTransform<SessionLogOffset, number>>>;
 }, $strip>;
 /** The identity fields a record is bound to, inferred from {@link checkpointIdentity}. */
-type CheckpointIdentity = output<typeof checkpointIdentity>;
+type CheckpointIdentity = output$1<typeof checkpointIdentity>;
 //#endregion
 //#region ../../../vendor/deepseek-harness/packages/session/session-projection-cache/lib/types/index.d.ts
 declare module '@deepseek-ai/cordis' {
@@ -3163,7 +5236,7 @@ declare const workspaceRecord: ZodObject<{
   updatedAt: ZodString;
 }, $strip>;
 /** One stored workspace record, inferred from {@link workspaceRecord}. */
-type WorkspaceRecord = output<typeof workspaceRecord>;
+type WorkspaceRecord = output$1<typeof workspaceRecord>;
 /**
  * Durable registry state. `initialized` distinguishes a valid empty registry
  * from one that still needs the header-only history bootstrap;
@@ -3191,7 +5264,7 @@ declare const workspaceDomainState: ZodObject<{
   }, $strip>], "operation">>;
 }, $strip>;
 /** Durable registry state inferred from {@link workspaceDomainState}. */
-type WorkspaceDomainState = output<typeof workspaceDomainState>;
+type WorkspaceDomainState = output$1<typeof workspaceDomainState>;
 //#endregion
 //#region ../../../vendor/deepseek-harness/packages/workspace/workspace/lib/types/index.d.ts
 /** Identifies one workspace record (see `src/types.ts` for the brand rationale). */
@@ -3444,7 +5517,6 @@ interface StorageRepository {
   readWorkspaceState(): Promise<WorkspaceDomainState | null>;
   writeWorkspaceState(state: WorkspaceDomainState): Promise<void>;
   loadProjcache(): Promise<StoredProjcacheEntry[]>;
-  /** 不经 await、直接读的路径（供同步的 `cachedSnapshot` 消费）；宿主提供不了则缺省。 */
   readProjcacheDirect?(sessionId: string): StoredProjcacheEntry | undefined;
   readSessionTitleDirect?(sessionId: string): {
     title: string;
@@ -3454,11 +5526,18 @@ interface StorageRepository {
   pruneStaleProjcache(): Promise<number>;
 }
 //#endregion
+//#region src/routes.d.ts
+declare const SESSION_ROWS_PATH = "/api/morlay/v1/session/rows";
+declare const SESSION_EXPORT_PATH = "/api/morlay/v1/session/export";
+declare const SESSION_IMPORT_PATH = "/api/morlay/v1/session/import";
+declare const SESSION_DELETE_PATH = "/api/morlay/v1/session/delete";
+declare const SESSION_GC_PATH = "/api/morlay/v1/session/gc";
+declare const SESSION_USAGE_PATH = "/api/morlay/v1/session/usage";
+//#endregion
 //#region src/write-guard.d.ts
 declare class WriteGuard {
   private readonly headSeqs;
   confirmHead(id: SessionId, head: number): void;
-  /** 本实例有没有这条会话的 head 记录（迁移重写用它决定是"登记基准"还是"严格比较"）。 */
   has(id: SessionId): boolean;
   assertNoConcurrentWriter(id: SessionId, storedHead: number): void;
 }
@@ -3496,30 +5575,18 @@ declare function eventDimensions(event: SessionEvent): {
 };
 //#endregion
 //#region src/rows.d.ts
-/**
- * 管理面的会话列表：**我们自己的**一条路由（完整语料，含归档），与官方 `session/list` 分开。
- *
- * 官方那条（`session/list` → `ctx.sessionQuery.listSessions`）按部署策略默认排除已归档——那是给上游
- * UI 用的。归档集的管理动作要有完整列表，所以这里单独给一条：标题直接从会话列取，最后活动时间用
- * 该会话最后一个事件的时间。
- */
-declare const SESSION_ROWS_PATH = "/api/session.rows";
 interface SessionRowsItem {
   sessionId: string;
   title: string | null;
-  /** 会话 header 的 origin（`subagent` 表示子代理会话）。 */
   origin: string | null;
   cwd: string | null;
   createdAt: number;
-  /** 最后一个事件的时间（无事件时等于 `createdAt`）。 */
   updatedAt: number;
   archived: boolean;
-  /** 所属工作区标题；不属于任何工作区时为 null。 */
   workspace: string | null;
 }
 interface SessionRowsValue {
   items: SessionRowsItem[];
-  /** 过滤后的总数（分页前），前端据此算页数。 */
   total: number;
   page: number;
   pageSize: number;
@@ -3600,7 +5667,6 @@ interface SessionPersistenceRdbInternals {
   listSnapshots(signal?: AbortSignal): Promise<SessionPersistenceSnapshot[]>;
   readStoredRevision(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionPersistenceRevision | undefined>;
   registerReuseEventIds(childId: SessionId, map: ReadonlyMap<number, string>): void;
-  /** fork 失败时丢弃还没被消费的映射。 */
   dropReuseEventIds(childId: SessionId): void;
 }
 interface ProjectionCacheOptions {
@@ -3619,7 +5685,6 @@ type Config$1 = {
   schema?: string | undefined;
   projectionCache?: ProjectionCacheOptions | undefined;
 };
-/** schema 解析之后的形状：整段 Config 是 **volatile 稳定引用**（页面可编辑），读它要过 `.get()`。 */
 type ResolvedConfig = Volatile<Config$1>;
 type SessionDeletionErrorCode = "SESSION_NOT_FOUND" | "SESSION_NOT_ARCHIVED" | "SESSION_LIVE";
 declare class SessionDeletionError extends Error {
@@ -3705,7 +5770,6 @@ declare class SessionPersistenceRdb extends SessionPersistence {
   private readonly reuseEventIds;
   private readonly liveBuffers;
   private readonly liveReady;
-  /** 本次装配用的配置快照（整段 Config 是 volatile，重挂会给新的）。 */
   readonly config: Config$1;
   constructor(ctx: Context, config: ResolvedConfig, injectedBackend?: Backend);
   private init;
@@ -3715,13 +5779,9 @@ declare class SessionPersistenceRdb extends SessionPersistence {
   stat(id: SessionId, options?: SessionPersistenceStatOptions): Promise<SessionPersistenceSnapshot | undefined>;
   list(options?: SessionPersistenceListOptions): Promise<readonly SessionPersistenceSnapshot[]>;
   deleteSession(id: SessionId, signal?: AbortSignal): Promise<void>;
-  /** GC 通道：回收已无桥接行引用的事件行（孤儿），返回删除行数。 */
   collectOrphans(): Promise<number>;
-  /** GC 通道：回收父已不存在的 subagent 会话（live 的跳过），返回删除的会话数。 */
   collectOrphanSessions(): Promise<number>;
-  /** 用量统计：SQL 聚合的按天 × 模型桶与按会话行（事件行去重、排除孤儿行）。 */
   usageReport(sinceMs?: number): Promise<UsageAggregate>;
-  /** GC 通道：VACUUM；调用方需先停止运行中的写路径（见 `registerSessionGc`）。 */
   vacuum(): Promise<void>;
   private unarchiveBeforeDeletion;
   readRaw(id: SessionId, signal?: AbortSignal): Promise<{
@@ -3744,18 +5804,9 @@ declare class SessionPersistenceRdb extends SessionPersistence {
     storedCount: number;
     migrated: boolean;
   } | undefined>;
-  /**
-   * 统计衍生表的**旁路累加**：不在写事务里、失败只 warn——两张会话汇总表都是可销毁重建的
-   * 派生表，丢几次累加不影响可用性（需要时用 `rebuildSessionStats` 重算）。
-   * token 走写路径已折好的用量行，活动计数走本批事件类型。
-   */
   private recordSessionStats;
-  /**
-   * 重算一个会话的统计（rewind / fork 之后；best-effort，同 `recordSessionStats`）：
-   * 两张汇总表按会话重算，用量行的引用标记全量重算（引用可能跨会话消失）。
-   */
   rebuildSessionStats(id: SessionId): Promise<void>;
-  /** 会话删除时清掉它的汇总行，并重算用量行的引用标记（被删会话引用的行要立刻退出统计）。 */
+  private refreshEventUsageFlags;
   private dropSessionStats;
   private rewriteMigratedLog;
   listSnapshots(signal?: AbortSignal): Promise<Array<SessionPersistenceSnapshot & {
@@ -3772,7 +5823,6 @@ declare class SessionPersistenceRdb extends SessionPersistence {
   }>;
   close(): Promise<void>;
   registerReuseEventIds(childId: SessionId, map: ReadonlyMap<number, string>): void;
-  /** 丢弃一个还没被消费的复用映射（fork 失败时）：留着会让同一个 childId 之后的落写复用父会话的事件行。 */
   dropReuseEventIds(childId: SessionId): void;
   internals(): SessionPersistenceRdbInternals;
   private rowRevision;
@@ -3784,22 +5834,8 @@ declare class SessionPersistenceRdb extends SessionPersistence {
 }
 //#endregion
 //#region src/usage.d.ts
-declare const SESSION_USAGE_PATH = "/api/session.usage";
-/**
- * 时间范围的语义键：`all` 不限；`day` / `week` 是**本地自然日 / 自然周**（周一起算）；
- * `7d` / `30d` / `90d` 是**最近 N 个自然日**（含今天）。
- */
 type UsageRangeKey = "all" | "day" | "week" | "7d" | "30d" | "90d";
-/**
- * 范围起点（含），不限时为 undefined。**所有起点都对齐到 host 本地时区的零点**——`day` / `week` 是
- * 今天 / 本周一的零点，`7d` / `30d` / `90d` 是「今天零点往前 N-1 天」（含今天共 N 个自然日）。
- * 对齐的意义：事件级表按毫秒过滤、会话汇总表按本地日过滤，两者因此严格等价。
- * @param range - 语义键。
- * @param now - 当前时刻。
- * @returns 起点毫秒时间戳，或 undefined。
- */
 declare function resolveUsageSince(range: UsageRangeKey, now: number): number | undefined;
-/** 一段 token 用量（字段直接取事件里模型报的 usage）。 */
 interface UsageTokenTotals {
   inputTokens: number;
   outputTokens: number;
@@ -3807,36 +5843,25 @@ interface UsageTokenTotals {
   reasoningTokens: number;
   totalTokens: number;
 }
-/**
- * 活动计数：与 token 用量同一时间范围、同一去重口径（只算被会话引用的事件行），
- * 按事件类型数出来——「轮次 / 步骤 / 用户输入 / 工具调用」比「事件行数」有信息量。
- */
 interface UsageActivityTotals {
   turns: number;
   steps: number;
   userInputs: number;
   toolCalls: number;
 }
-/** 总量与按会话行用的一整套指标（token + 活动）。 */
 interface UsageTotals extends UsageTokenTotals, UsageActivityTotals {}
-/**
- * 一天 × 一个模型 × 是否子代理 的用量桶：总览、按天、按模型都由它折叠。
- * 只有 token 用量——活动计数没有模型归属（一个轮次可能跨模型），挂在总量与按会话行上。
- */
 interface UsageBucket extends UsageTokenTotals {
   day: string;
   provider: string | null;
   model: string | null;
   subagent: boolean;
 }
-/** 一条会话的用量行。 */
 interface UsageSessionRow extends UsageTotals {
   sessionId: string;
   title: string | null;
   subagent: boolean;
   archived: boolean;
 }
-/** 后端的原始聚合结果（总量 / 其中子代理 / 人类、按天×模型的桶、按会话的行）。 */
 interface UsageAggregate {
   totals: UsageTotals;
   subagent: UsageTotals;
@@ -3844,23 +5869,14 @@ interface UsageAggregate {
   buckets: UsageBucket[];
   sessions: UsageSessionRow[];
 }
-/** 一次统计请求的完整回报。 */
 type SessionUsageReport = UsageAggregate;
-/** 计入活动计数的事件类型（轮次 / 步骤 / 用户输入 / 工具调用）。 */
 declare const COUNTED_EVENT_TYPES: readonly ["turn/start", "step/start", "user/message", "tool/call"];
-/** 按事件类型把计数累加到活动指标上（表里按类型存，读的时候折成四项）。 */
 declare function addActivityCount(target: UsageActivityTotals, type: string, count: number): UsageActivityTotals;
-/** 毫秒时间戳 → host 本地日（`YYYY-MM-DD`，与 SQL 的 localtime 口径一致）。 */
 declare function localDayKey(ms: number): string;
 declare function emptyTotals(): UsageTotals;
 declare function addTokenTotals(target: UsageTokenTotals, row: UsageTokenTotals): UsageTokenTotals;
 declare function addActivityTotals(target: UsageActivityTotals, row: UsageActivityTotals): UsageActivityTotals;
-/** 把一行的整套指标累加进目标（后端合并「是否子代理」两组时用）。 */
 declare function addTotals(target: UsageTotals, row: UsageTotals): UsageTotals;
-/**
- * 用量统计通道：一次请求回报总览（含 subagent 拆分）、按天 × 模型的桶与按会话的行。
- * 聚合只算被会话引用的事件行——fork 共享行因此只计一次，已删会话留下的孤儿行不计。
- */
 declare function registerSessionUsage(ctx: Context, persistence: SessionPersistenceRdb): void;
 //#endregion
 //#region src/backend.d.ts
@@ -3912,10 +5928,6 @@ interface BackendTx {
   getSeedLength(id: SessionId): Promise<number | null>;
   updateSeedLength(id: SessionId, seedLength: number): Promise<void>;
   refreshTitle(id: SessionId): Promise<void>;
-  /**
-   * 插入事件行与它们的用量行（`usageRows` 由写路径一次折好，读侧维度已物化在行上）。
-   * 这一批事件与桥接行同事务，提交即「被引用」。
-   */
   insertEvents(events: EventInsert[], usageRows: readonly EventUsageRow[]): Promise<void>;
   insertBridges(rows: Array<{
     fSessionId: SessionId;
@@ -3924,55 +5936,42 @@ interface BackendTx {
     fSurfaceOp: string | null;
   }>): Promise<void>;
   updateHead(id: SessionId, headEventId: string, headSequence: number): Promise<void>;
-  /** 写批次提交时递增 revision；给了 `lastEventAt` 就一并把「最后活动时间」往前推（只增不减）。 */
   bumpRevision(id: SessionId, lastEventAt?: number): Promise<void>;
-  deleteBridgeTail(id: SessionId, fromSequence: number): Promise<void>;
+  deleteBridgeTail(id: SessionId, fromSequence: number): Promise<readonly string[]>;
   getPrevBridge(id: SessionId, sequence: number): Promise<{
     fEventId: string;
     fSequence: number;
   } | undefined>;
-  deleteSession(id: SessionId): Promise<void>;
-  /** 批量删除整条会话：桥接行、workspace 归属行、投影行与会话行。 */
-  deleteSessions(ids: SessionId[]): Promise<number>;
+  deleteSession(id: SessionId): Promise<readonly string[]>;
+  deleteSessions(ids: SessionId[]): Promise<{
+    deleted: number;
+    eventIds: readonly string[];
+  }>;
 }
-/**
- * 「会话行」列表项：管理面自己的列表用（完整语料，含归档）+ 标题 + 最后活动时间。
- *
- * 与官方列表（`session/list` → `ctx.sessionQuery.listSessions`）的区别：那条按部署策略**默认排除归档**，
- * 这里给的是完整集合，标题也直接带出来（官方那条的标题走投影缓存）。
- */
 interface SessionListRowRecord {
   sessionId: string;
   title: string | null;
   origin: string | null;
   cwd: string | null;
   createdAt: number;
-  /** 该会话最后一个事件的时间（没有事件时回落 `createdAt`）。 */
   updatedAt: number;
   archived: boolean;
   subagent: boolean;
-  /** 所属工作区标题；不属于任何工作区时为 null。 */
   workspace: string | null;
 }
-/** 会话行列表的查询条件：搜索、子代理过滤与分页都在后端做（前端分页等于每次拉全量）。 */
 interface SessionListRowsQuery {
-  /** 匹配标题或所属工作区标题（大小写不敏感）；空串即不过滤。 */
   query?: string;
-  /** 是否连子代理派生会话一起返回（默认不含）。 */
   includeSubagents?: boolean;
   limit?: number;
   offset?: number;
 }
 interface SessionListRowsPage {
   items: SessionListRowRecord[];
-  /** 过滤后的总数（分页前的），前端据此算页数。 */
   total: number;
 }
-/** 活动计数的一个桶：本地日 + 四项计数（轮次 / 步骤 / 用户输入 / 工具调用）。 */
 interface SessionCountBucket extends UsageActivityTotals {
   day: string;
 }
-/** 用量累加的一个桶：本地日 + 模型归属 + 五个 token 列。 */
 interface SessionUsageBucket extends UsageTokenTotals {
   day: string;
   provider: string | null;
@@ -3989,45 +5988,15 @@ interface Backend {
   getEventTypesBefore(id: SessionId, beforeSequence: number, limit: number): Promise<Array<Pick<EventRow, "fSequence" | "fType">>>;
   listSessions(): Promise<SessionRow[]>;
   transaction<T>(fn: (tx: BackendTx) => Promise<T>): Promise<T>;
-  /** 删除已无桥接行引用的事件行（孤儿），返回删除行数。 */
   collectOrphans(): Promise<number>;
-  /** 父会话已不存在（或没有父）的 subagent 会话：父被删后它们成了孤儿。 */
   listOrphanSubagentSessions(): Promise<SessionId[]>;
-  /**
-   * 用量统计的原始聚合：读三张派生统计表（`t_event_usage` + 两张会话汇总表），
-   * 给出总量 / subagent 拆分、按天×模型的桶与按会话的行（事件行去重、排除孤儿）。
-   * @param sinceMs - 只算该时刻（含）之后的用量；省略即全量。会话汇总表按本地日过滤，
-   * 与毫秒过滤等价的前提是调用方把起点对齐到本地零点（见 `resolveUsageSince`）。
-   */
   usageReport(sinceMs?: number): Promise<UsageAggregate>;
-  /** 管理面的会话行列表：完整语料（含归档）+ 标题 + 最后活动时间，按活动倒序分页。 */
   listSessionRows(query?: SessionListRowsQuery): Promise<SessionListRowsPage>;
-  /**
-   * token 用量**旁路累加**（派生表 `t_session_usage`，不参与写事务、失败可丢——表可销毁重建）：
-   * 每个 (会话, 本地日, 模型) 记一行累加。
-   * @param id - 会话 id。
-   * @param buckets - 本批要累加的 (day, provider, model, tokens)。
-   */
   incrementSessionUsage(id: SessionId, buckets: readonly SessionUsageBucket[]): Promise<void>;
-  /**
-   * 活动计数**旁路累加**（派生表 `t_session_counts`，同上）：每个 (会话, 本地日) 累加四项计数。
-   * @param id - 会话 id。
-   * @param buckets - 本批要累加的 (day, turns, steps, userInputs, toolCalls)。
-   */
   incrementSessionCounts(id: SessionId, buckets: readonly SessionCountBucket[]): Promise<void>;
-  /**
-   * 按会话从事件表重算两张会话汇总表（rewind / fork 之后调用）：先删该会话的行再重算。
-   * @param id - 会话 id。
-   */
   rebuildSessionStats(id: SessionId): Promise<void>;
-  /**
-   * 全量重算 `t_event_usage` 的引用标记（`f_referenced` / `f_subagent`）：rewind / fork / 会话删除之后调用。
-   * 引用可能跨会话消失（截断、删除），只按本会话判定不够，故这里是全量。
-   */
-  refreshEventUsageFlags(): Promise<void>;
-  /** 删掉一个会话的汇总行（会话删除时；外键 CASCADE 之外再显式清一次）。 */
+  refreshEventUsageFlags(eventIds: readonly string[]): Promise<void>;
   deleteSessionStats(id: SessionId): Promise<void>;
-  /** 回收空间与统计（含 VACUUM）；不得在事务内执行。 */
   vacuum(): Promise<void>;
   close(): Promise<void>;
 }
@@ -4072,46 +6041,9 @@ declare function repairAssistantSettlement(events: SessionEvent[]): void;
 declare function repairRequestHeaders(events: SessionEvent[]): void;
 declare function syncMeteringRanges(events: SessionEvent[]): void;
 declare function renameLegacyPtcEvents(events: SessionEvent[]): void;
-/**
- * 把**旧代（v3 及更早）的消息形状**归一到当前格式（v4）：迁移链（严格）拒绝那些形状时，读路径仍要
- * 能把它们读出来——只动字段与标记，不改坐标、不改内容。
- *
- * 三件事：
- * - `system/message` 的 source：`{ kind: 'plugin', plugin: '@deepseek-ai/dsh-system-prompt' }` → `{ kind: 'system-prompt' }`
- *   （v4 起 system 消息只认这个 kind）；
- * - `tool/result` 的消息：v3 是 user 角色、结果块包在 `content[0]`；v4 是 `role: 'tool'` + 顶层
- *   `toolCallId` + `content` 就是结果块；
- * - **本仓库自造、上游不认识的事件类型**（见 `OWN_EVENT_TYPES`：历史遗留的与我们当前在写的）标
- *   `ignorable: true`——v4 的校验对未知类型只接受可忽略信封。
- *
- * 只认这张白名单：**其它未知类型保持 fail loud**（那是「数据来自更新的 harness」的信号，不能吞掉）。
- */
 declare function normalizeToCurrentShape(events: SessionEvent[]): void;
-/**
- * 落库前给**本仓库自造的事件类型**补上 `ignorable: true` 信封。
- *
- * 上游的持久化校验（`validateStoredEvents`）只放行「已知类型」或「带可忽略信封的未知类型」，我们的类型
- * 按构造就在已知表之外——不补的话连**写入**都会被拒（`appendBatch` 里那道校验）。上游 `Session.append`
- * 没有承载这个信封的口子（第三个参数只服务 surface 事件），所以这一笔由持久化层补：canonical log 里的
- * 形状不变，落库的那一份带上信封。
- * @param events - 即将落库的批次（`materializeAppendBatch` 的 JSON 快照副本，可写）。
- */
 declare function sealOwnEvents(events: readonly SessionEvent[]): void;
-/**
- * 本仓库自造、上游不认识的事件类型：读的时候标 `ignorable: true`，v4 的持久化校验才肯跳过它们
- * （`validateStoredEvents` 只放行「已知类型」或「带可忽略信封的未知类型」）。
- *
- * 两类都在这张表里：
- * - **历史遗留**：写过、后来连同机制一起删除的（`session-branch/version`）；
- * - **当前在写**：本仓库的插件自己声明的事件类型（`session-mode/selected`）——上游的
- *   `KNOWN_SESSION_EVENT_TYPES` 由上游仓库的声明生成，外部插件的事件按构造就在它之外。
- *
- * 新增自造事件类型时**必须**登记到这里，否则读路径 fail loud（真回归：`session-mode/selected` 漏登记，
- * 会话打不开）。**不要**用「所有未知类型」代替（那会掩盖更新版本的未知事件——那种必须拒读）。
- */
 declare const OWN_EVENT_TYPES: ReadonlySet<string>;
-/** 这批事件是否需要按当前形状归一（旧代消息形状，或尚未标 `ignorable` 的自造事件类型）——写路径曾把回退
- * 视图的结果以当前版本号落库，所以**版本号不可信**，读之前要按内容判一次。 */
 declare function needsShapeAdoption(events: readonly SessionEvent[]): boolean;
 declare function repairReadView(events: SessionEvent[]): void;
 declare function orphanInboxSpliceSeqs(events: readonly SessionEvent[]): Set<number>;
@@ -4122,7 +6054,6 @@ declare function scanRows(rows: readonly EventRow[], base?: number): {
 };
 declare function toJsonlArtifact(meta: SessionHeader, inheritedEventCount: number, events: readonly SessionEvent[]): string;
 declare function titleOfEventData(data: string): string | undefined;
-/** 用量行的列（`t_event_usage`）：读侧维度（本地日与两个归属标记）在写入时一起物化。 */
 interface EventUsageRow {
   fEventId: string;
   fCreatedAt: number;
@@ -4137,15 +6068,6 @@ interface EventUsageRow {
   fReasoningTokens: number;
   fTotalTokens: number;
 }
-/**
- * 一条事件行的用量（只有带 `usage` 的 `assistant/message` 才有）：写路径据此记录
- * `t_event_usage`，统计因此不必逐行解析 JSON。两种 `f_data` 结构（带信封 / 老格式）都认。
- * 读侧维度一起物化：本地日由事件时间算，`f_referenced` 直接 1（这一批事件行与桥接行同事务，
- * 提交即被引用），`f_subagent` 取写入它的会话是否子代理。
- * @param event - 待写入的事件行。
- * @param subagent - 写入它的会话是否 `origin === 'subagent'`。
- * @returns 用量行，或该事件没有用量时的 undefined。
- */
 declare function usageRowOf(event: {
   fEventId: string;
   fCreatedAt: number;
@@ -4153,4 +6075,4 @@ declare function usageRowOf(event: {
   fData: string;
 }, subagent: boolean): EventUsageRow | undefined;
 //#endregion
-export { SessionDeletionError as $, SessionRow as A, tWorkspaceState as At, UsageTokenTotals as B, usageRowOf as C, tSessionCounts as Ct, SessionCountBucket as D, tSessions as Dt, EventRow as E, tSessionUsage as Et, UsageActivityTotals as F, addTotals as G, addActivityCount as H, UsageAggregate as I, registerSessionUsage as J, emptyTotals as K, UsageBucket as L, COUNTED_EVENT_TYPES as M, WriteGuard as Mt, SESSION_USAGE_PATH as N, StorageRepository as Nt, SessionListRowsPage as O, tStorageUnits as Ot, SessionUsageReport as P, ResolvedConfig as Q, UsageRangeKey as R, toJsonlArtifact as S, tSchemaMeta as St, BackendTx as T, tSessionProjcacheRows as Tt, addActivityTotals as U, UsageTotals as V, addTokenTotals as W, Config$1 as X, resolveUsageSince as Y, ProjectionCacheOptions as Z, sealOwnEvents as _, eventDimensions as _t, normalizeToCurrentShape as a, locateTurnEnd as at, syncMeteringRanges as b, tEvents as bt, renameLegacyPtcEvents as c, SessionRowsItem as ct, repairReadView as d, EVENT_ENCODING as dt, SessionDeletionErrorCode as et, repairRequestHeaders as f, EventKind as ft, scanRows as g, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as gt, rowToMeta as h, SCHEMA_VERSION as ht, needsShapeAdoption as i, SessionBranchRdbProvider as it, SessionUsageBucket as j, tWorkspaces as jt, SessionListRowsQuery as k, tWorkspaceSessions as kt, repairAssistantSettlement as l, SessionRowsValue as lt, rowToEvent as m, JournalMode as mt, OWN_EVENT_TYPES as n, SessionPersistenceRdbInternals as nt, orphanInboxSpliceSeqs as o, truncateLiveSession as ot, repairSurfaceOps as p, EventRole as pt, localDayKey as q, findSurfaceRepairs as r, SessionBranchRdb as rt, recomputeReplaceProvenance as s, SESSION_ROWS_PATH as st, EventUsageRow as t, SessionPersistenceRdb as tt, repairOrphanInboxSplices as u, DEFAULT_BUSY_TIMEOUT_MS as ut, sessionConflictRow as v, eventKind as vt, Backend as w, tSessionEvents as wt, titleOfEventData as x, tPersistenceState as xt, sessionInsertRow as y, tEventUsage as yt, UsageSessionRow as z };
+export { SessionDeletionErrorCode as $, SessionRow as A, WriteGuard as At, UsageTotals as B, usageRowOf as C, tSessionProjcacheRows as Ct, SessionCountBucket as D, tWorkspaceSessions as Dt, EventRow as E, tStorageUnits as Et, UsageAggregate as F, SESSION_ROWS_PATH as Ft, emptyTotals as G, addActivityTotals as H, UsageBucket as I, SESSION_USAGE_PATH as It, resolveUsageSince as J, localDayKey as K, UsageRangeKey as L, StorageRepository as Lt, COUNTED_EVENT_TYPES as M, SESSION_EXPORT_PATH as Mt, SessionUsageReport as N, SESSION_GC_PATH as Nt, SessionListRowsPage as O, tWorkspaceState as Ot, UsageActivityTotals as P, SESSION_IMPORT_PATH as Pt, SessionDeletionError as Q, UsageSessionRow as R, toJsonlArtifact as S, tSessionEvents as St, BackendTx as T, tSessions as Tt, addTokenTotals as U, addActivityCount as V, addTotals as W, ProjectionCacheOptions as X, Config$1 as Y, ResolvedConfig as Z, sealOwnEvents as _, tEventUsage as _t, normalizeToCurrentShape as a, truncateLiveSession as at, syncMeteringRanges as b, tSchemaMeta as bt, renameLegacyPtcEvents as c, DEFAULT_BUSY_TIMEOUT_MS as ct, repairReadView as d, EventRole as dt, SessionPersistenceRdb as et, repairRequestHeaders as f, JournalMode as ft, scanRows as g, eventKind as gt, rowToMeta as h, eventDimensions as ht, needsShapeAdoption as i, locateTurnEnd as it, SessionUsageBucket as j, SESSION_DELETE_PATH as jt, SessionListRowsQuery as k, tWorkspaces as kt, repairAssistantSettlement as l, EVENT_ENCODING as lt, rowToEvent as m, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as mt, OWN_EVENT_TYPES as n, SessionBranchRdb as nt, orphanInboxSpliceSeqs as o, SessionRowsItem as ot, repairSurfaceOps as p, SCHEMA_VERSION as pt, registerSessionUsage as q, findSurfaceRepairs as r, SessionBranchRdbProvider as rt, recomputeReplaceProvenance as s, SessionRowsValue as st, EventUsageRow as t, SessionPersistenceRdbInternals as tt, repairOrphanInboxSplices as u, EventKind as ut, sessionConflictRow as v, tEvents as vt, Backend as w, tSessionUsage as wt, titleOfEventData as x, tSessionCounts as xt, sessionInsertRow as y, tPersistenceState as yt, UsageTokenTotals as z };