@cossistant/react 0.0.26 → 0.0.29

package/realtime-events.d.ts

@@ -111,11 +111,12 @@ declare const realtimeSchema: {
       visitorId: ZodString;
       websiteId: ZodString;
       status: ZodDefault<ZodEnum<{
-        resolved: "resolved";
         open: "open";
+        resolved: "resolved";
         spam: "spam";
       }>>;
       deletedAt: ZodDefault<ZodNullable<ZodString>>;
+      visitorLastSeenAt: ZodOptional<ZodNullable<ZodString>>;
       lastTimelineItem: ZodOptional<ZodObject<{
         id: ZodOptional<ZodString>;
         conversationId: ZodString;
@@ -189,8 +190,8 @@ declare const realtimeSchema: {
     header: ZodObject<{
       id: ZodString;
       status: ZodEnum<{
-        resolved: "resolved";
         open: "open";
+        resolved: "resolved";
         spam: "spam";
       }>;
       priority: ZodEnum<{
@@ -224,6 +225,12 @@ declare const realtimeSchema: {
       resolvedAt: ZodNullable<ZodString>;
       resolvedByUserId: ZodNullable<ZodString>;
       resolvedByAiAgentId: ZodNullable<ZodString>;
+      escalatedAt: ZodNullable<ZodString>;
+      escalatedByAiAgentId: ZodNullable<ZodString>;
+      escalationReason: ZodNullable<ZodString>;
+      escalationHandledAt: ZodNullable<ZodString>;
+      escalationHandledByUserId: ZodNullable<ZodString>;
+      aiPausedUntil: ZodNullable<ZodString>;
       createdAt: ZodString;
       updatedAt: ZodString;
       deletedAt: ZodNullable<ZodString>;
@@ -429,6 +436,162 @@ declare const realtimeSchema: {
       }, $strip>>;
     }, $strip>;
   }, $strip>;
+  readonly conversationEventCreated: ZodObject<{
+    websiteId: ZodString;
+    organizationId: ZodString;
+    visitorId: ZodNullable<ZodString>;
+    userId: ZodNullable<ZodString>;
+    conversationId: ZodString;
+    aiAgentId: ZodNullable<ZodString>;
+    event: ZodObject<{
+      id: ZodString;
+      conversationId: ZodString;
+      organizationId: ZodString;
+      type: ZodEnum<{
+        assigned: "assigned";
+        unassigned: "unassigned";
+        participant_requested: "participant_requested";
+        participant_joined: "participant_joined";
+        participant_left: "participant_left";
+        status_changed: "status_changed";
+        priority_changed: "priority_changed";
+        tag_added: "tag_added";
+        tag_removed: "tag_removed";
+        resolved: "resolved";
+        reopened: "reopened";
+        visitor_blocked: "visitor_blocked";
+        visitor_unblocked: "visitor_unblocked";
+        visitor_identified: "visitor_identified";
+      }>;
+      actorUserId: ZodNullable<ZodString>;
+      actorAiAgentId: ZodNullable<ZodString>;
+      targetUserId: ZodNullable<ZodString>;
+      targetAiAgentId: ZodNullable<ZodString>;
+      message: ZodNullable<ZodString>;
+      metadata: ZodNullable<ZodRecord<ZodString, ZodUnknown>>;
+      createdAt: ZodString;
+      updatedAt: ZodString;
+      deletedAt: ZodNullable<ZodString>;
+    }, $strip>;
+  }, $strip>;
+  readonly conversationUpdated: ZodObject<{
+    websiteId: ZodString;
+    organizationId: ZodString;
+    visitorId: ZodNullable<ZodString>;
+    userId: ZodNullable<ZodString>;
+    conversationId: ZodString;
+    updates: ZodObject<{
+      title: ZodOptional<ZodNullable<ZodString>>;
+      sentiment: ZodOptional<ZodNullable<ZodEnum<{
+        positive: "positive";
+        negative: "negative";
+        neutral: "neutral";
+      }>>>;
+      sentimentConfidence: ZodOptional<ZodNullable<ZodNumber>>;
+      escalatedAt: ZodOptional<ZodNullable<ZodString>>;
+      escalationReason: ZodOptional<ZodNullable<ZodString>>;
+    }, $strip>;
+    aiAgentId: ZodNullable<ZodString>;
+  }, $strip>;
+  readonly crawlStarted: ZodObject<{
+    websiteId: ZodString;
+    organizationId: ZodString;
+    visitorId: ZodNullable<ZodString>;
+    userId: ZodNullable<ZodString>;
+    linkSourceId: ZodString;
+    url: ZodString;
+    discoveredPages: ZodArray<ZodObject<{
+      url: ZodString;
+      title: ZodNullable<ZodString>;
+      depth: ZodNumber;
+    }, $strip>>;
+    totalPagesCount: ZodNumber;
+  }, $strip>;
+  readonly crawlProgress: ZodObject<{
+    websiteId: ZodString;
+    organizationId: ZodString;
+    visitorId: ZodNullable<ZodString>;
+    userId: ZodNullable<ZodString>;
+    linkSourceId: ZodString;
+    url: ZodString;
+    page: ZodObject<{
+      url: ZodString;
+      title: ZodNullable<ZodString>;
+      status: ZodEnum<{
+        pending: "pending";
+        crawling: "crawling";
+        completed: "completed";
+        failed: "failed";
+      }>;
+      sizeBytes: ZodOptional<ZodNumber>;
+      error: ZodOptional<ZodNullable<ZodString>>;
+    }, $strip>;
+    completedCount: ZodNumber;
+    totalCount: ZodNumber;
+  }, $strip>;
+  readonly crawlCompleted: ZodObject<{
+    websiteId: ZodString;
+    organizationId: ZodString;
+    visitorId: ZodNullable<ZodString>;
+    userId: ZodNullable<ZodString>;
+    linkSourceId: ZodString;
+    url: ZodString;
+    crawledPagesCount: ZodNumber;
+    totalSizeBytes: ZodNumber;
+    failedPagesCount: ZodNumber;
+  }, $strip>;
+  readonly crawlFailed: ZodObject<{
+    websiteId: ZodString;
+    organizationId: ZodString;
+    visitorId: ZodNullable<ZodString>;
+    userId: ZodNullable<ZodString>;
+    linkSourceId: ZodString;
+    url: ZodString;
+    error: ZodString;
+  }, $strip>;
+  readonly linkSourceUpdated: ZodObject<{
+    websiteId: ZodString;
+    organizationId: ZodString;
+    visitorId: ZodNullable<ZodString>;
+    userId: ZodNullable<ZodString>;
+    linkSourceId: ZodString;
+    status: ZodEnum<{
+      pending: "pending";
+      crawling: "crawling";
+      completed: "completed";
+      failed: "failed";
+      mapping: "mapping";
+    }>;
+    discoveredPagesCount: ZodOptional<ZodNumber>;
+    crawledPagesCount: ZodOptional<ZodNumber>;
+    totalSizeBytes: ZodOptional<ZodNumber>;
+    errorMessage: ZodOptional<ZodNullable<ZodString>>;
+  }, $strip>;
+  readonly crawlPagesDiscovered: ZodObject<{
+    websiteId: ZodString;
+    organizationId: ZodString;
+    visitorId: ZodNullable<ZodString>;
+    userId: ZodNullable<ZodString>;
+    linkSourceId: ZodString;
+    pages: ZodArray<ZodObject<{
+      url: ZodString;
+      path: ZodString;
+      depth: ZodNumber;
+    }, $strip>>;
+  }, $strip>;
+  readonly crawlPageCompleted: ZodObject<{
+    websiteId: ZodString;
+    organizationId: ZodString;
+    visitorId: ZodNullable<ZodString>;
+    userId: ZodNullable<ZodString>;
+    linkSourceId: ZodString;
+    page: ZodObject<{
+      url: ZodString;
+      title: ZodNullable<ZodString>;
+      sizeBytes: ZodNumber;
+      knowledgeId: ZodString;
+    }, $strip>;
+  }, $strip>;
 };
 type RealtimeEventType = keyof typeof realtimeSchema;
 type RealtimeEventPayload<T extends RealtimeEventType> = output<(typeof realtimeSchema)[T]>;

package/realtime-events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"realtime-events.d.ts","names":[],"sources":["../../types/src/realtime-events.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;cAiBa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmED,iBAAA,gBAAiC;KAEjC,+BAA+B,qBAAqB,eACvD,gBAAgB;KAGb,wBAAwB;QAC7B;WACG,qBAAqB;;KAGnB,gBAAA,WACL,oBAAoB,cAAc,KACvC;KAEU,4BAA4B,qBACvC,qBAAqB"}
+{"version":3,"file":"realtime-events.d.ts","names":[],"sources":["../../types/src/realtime-events.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;cAqBa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwLD,iBAAA,gBAAiC;KAEjC,+BAA+B,qBAAqB,eACvD,gBAAgB;KAGb,wBAAwB;QAC7B;WACG,qBAAqB;;KAGnB,gBAAA,WACL,oBAAoB,cAAc,KACvC;KAEU,4BAA4B,qBACvC,qBAAqB"}

package/registries.d.ts

@@ -1,7 +1,7 @@
 import { $ZodType } from "./schemas.js";
 import { input, output } from "./core.js";
 
-//#region ../../node_modules/.bun/zod@4.1.12/node_modules/zod/v4/core/registries.d.cts
+//#region ../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/registries.d.cts
 declare const $output: unique symbol;
 type $output = typeof $output;
 declare const $input: unique symbol;

package/registries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registries.d.ts","names":["core","$ZodType","$output","$input","$replace","Meta","S","output","input","M","P","K","R","MetadataType","$ZodRegistry","Schema","WeakMap","Map","JSONSchemaMeta","GlobalMeta","registry","T","globalRegistry"],"sources":["../../../node_modules/.bun/zod@4.1.12/node_modules/zod/v4/core/registries.d.cts"],"sourcesContent":["import type * as core from \"./core.cjs\";\nimport type { $ZodType } from \"./schemas.cjs\";\nexport declare const $output: unique symbol;\nexport type $output = typeof $output;\nexport declare const $input: unique symbol;\nexport type $input = typeof $input;\nexport type $replace<Meta, S extends $ZodType> = Meta extends $output ? core.output<S> : Meta extends $input ? core.input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends (...args: infer P) => infer R ? (...args: {\n    [K in keyof P]: $replace<P[K], S>;\n}) => $replace<R, S> : Meta extends object ? {\n    [K in keyof Meta]: $replace<Meta[K], S>;\n} : Meta;\ntype MetadataType = object | undefined;\nexport declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {\n    _meta: Meta;\n    _schema: Schema;\n    _map: WeakMap<Schema, $replace<Meta, Schema>>;\n    _idmap: Map<string, Schema>;\n    add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;\n    clear(): this;\n    remove(schema: Schema): this;\n    get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;\n    has(schema: Schema): boolean;\n}\nexport interface JSONSchemaMeta {\n    id?: string | undefined;\n    title?: string | undefined;\n    description?: string | undefined;\n    deprecated?: boolean | undefined;\n    [k: string]: unknown;\n}\nexport interface GlobalMeta extends JSONSchemaMeta {\n}\nexport declare function registry<T extends MetadataType = MetadataType, S extends $ZodType = $ZodType>(): $ZodRegistry<T, S>;\nexport declare const globalRegistry: $ZodRegistry<GlobalMeta>;\nexport {};\n"],"x_google_ignoreList":[0],"mappings":";;;;cAEqBE;KACTA,OAAAA,UAAiBA;AADRA,cAEAC,MAFsB,EAAA,OAAA,MAAA;AAC/BD,KAEAC,MAAAA,GAFO,OAESA,MAFCD;AACRC,KAETC,QAF8B,CAAA,IAAA,EAAA,UAELH,QAFK,CAAA,GAEOI,IAFP,SAEoBH,OAFpB,GAE8BF,MAF9B,CAE0CM,CAF1C,CAAA,GAE+CD,IAF/C,SAE4DF,MAF5D,GAEqEH,KAFrE,CAEgFM,CAFhF,CAAA,GAEqFD,IAFrF,SAAA,CAAA,KAAA,EAAA,CAAA,EAAA,GAEgHD,QAFhH,CAEyHK,CAFzH,EAE4HH,CAF5H,CAAA,EAAA,GAEmID,IAFnI,UAAA,CAAA,GAAA,IAAA,EAAA,KAAA,EAAA,EAAA,GAAA,KAAA,EAAA,IAAA,CAAA,GAAA,IAAA,EAAA,QAC9BF,MAEIO,CAFE,GAEEN,QAFQD,CAECO,CAFDP,CAEGQ,CAFHR,CAAAA,EAEOG,CAFD,CAAA,EAClC,EAAA,GAEMF,QAFMA,CAEGQ,CAFK,EAEFN,CAFE,CAAA,GAEGD,IAFHA,SAAA,MAAA,GAAA,QAAiBJ,MAGrBI,IAHqBJ,GAGdG,QAHcH,CAGLI,IAHKJ,CAGAU,CAHAV,CAAAA,EAGIK,CAHJL,CAAAA,EAAYI,GAI7CA,IAJ6CA;KAK5CQ,YAAAA,GALyDX,MAAAA,GAAAA,SAAAA;AAAsBI,cAM/DQ,YAN+DR,CAAAA,aAMrCO,YANqCP,GAMtBO,YANsBP,EAAAA,eAMOL,QANPK,GAMkBL,QANlBK,CAAAA,CAAAA;EAAZN,KAAAA,EAO7DK,IAP6DL;EAAiBK,OAAAA,EAQ5EU,MAR4EV;EAAaF,IAAAA,EAS5Fa,OAT4Fb,CASpFY,MAToFZ,EAS5EC,QAT4ED,CASnEE,IATmEF,EAS7DY,MAT6DZ,CAAAA,CAAAA;EAAoBG,MAAAA,EAU9GW,GAV8GX,CAAAA,MAAAA,EAUlGS,MAVkGT,CAAAA;EAAXN,GAAAA,CAAAA,UAW7Fe,MAX6Ff,CAAAA,CAAAA,MAAAA,EAW7EM,CAX6EN,EAAAA,GAAAA,KAAAA,EAAAA,SAAAA,SAW9CK,IAX8CL,GAAAA,CAWtCI,QAXsCJ,CAW7BK,IAX6BL,EAWvBM,CAXuBN,CAAAA,CAAAA,CAAAA,GAAAA,CAWfI,QAXeJ,CAWNK,IAXML,EAWAM,CAXAN,CAAAA,CAAAA,CAAAA,EAAAA,IAAAA;EAAgBK,KAAAA,CAAAA,CAAAA,EAAAA,IAAAA;EAAoCI,MAAAA,CAAAA,MAAAA,EAahJM,MAbgJN,CAAAA,EAAAA,IAAAA;EAAGH,GAAAA,CAAAA,UAcpJS,MAdoJT,CAAAA,CAAAA,MAAAA,EAcpIA,CAdoIA,CAAAA,EAchIF,QAdgIE,CAcvHD,IAduHC,EAcjHA,CAdiHA,CAAAA,GAAAA,SAAAA;EAAZF,GAAAA,CAAAA,MAAAA,EAe1IW,MAf0IX,CAAAA,EAAAA,OAAAA;;AAC1IM,UAgBCQ,cAAAA,CAhBDR;EAAaA,EAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAEC,KAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAIL,WAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAfF,UAAAA,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;EACLQ,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,OAAAA;;AAATR,UAsBWe,UAAAA,SAAmBD,cAtB9Bd,CAAAA"}
+{"version":3,"file":"registries.d.ts","names":["core","$ZodType","$output","$input","$replace","Meta","S","output","input","M","P","K","R","MetadataType","$ZodRegistry","Schema","WeakMap","Map","JSONSchemaMeta","GlobalMeta","registry","T","globalRegistry"],"sources":["../../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/registries.d.cts"],"sourcesContent":["import type * as core from \"./core.cjs\";\nimport type { $ZodType } from \"./schemas.cjs\";\nexport declare const $output: unique symbol;\nexport type $output = typeof $output;\nexport declare const $input: unique symbol;\nexport type $input = typeof $input;\nexport type $replace<Meta, S extends $ZodType> = Meta extends $output ? core.output<S> : Meta extends $input ? core.input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends (...args: infer P) => infer R ? (...args: {\n    [K in keyof P]: $replace<P[K], S>;\n}) => $replace<R, S> : Meta extends object ? {\n    [K in keyof Meta]: $replace<Meta[K], S>;\n} : Meta;\ntype MetadataType = object | undefined;\nexport declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {\n    _meta: Meta;\n    _schema: Schema;\n    _map: WeakMap<Schema, $replace<Meta, Schema>>;\n    _idmap: Map<string, Schema>;\n    add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;\n    clear(): this;\n    remove(schema: Schema): this;\n    get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;\n    has(schema: Schema): boolean;\n}\nexport interface JSONSchemaMeta {\n    id?: string | undefined;\n    title?: string | undefined;\n    description?: string | undefined;\n    deprecated?: boolean | undefined;\n    [k: string]: unknown;\n}\nexport interface GlobalMeta extends JSONSchemaMeta {\n}\nexport declare function registry<T extends MetadataType = MetadataType, S extends $ZodType = $ZodType>(): $ZodRegistry<T, S>;\nexport declare const globalRegistry: $ZodRegistry<GlobalMeta>;\nexport {};\n"],"x_google_ignoreList":[0],"mappings":";;;;cAEqBE;KACTA,OAAAA,UAAiBA;AADRA,cAEAC,MAFsB,EAAA,OAAA,MAAA;AAC/BD,KAEAC,MAAAA,GAFO,OAESA,MAFCD;AACRC,KAETC,QAF8B,CAAA,IAAA,EAAA,UAELH,QAFK,CAAA,GAEOI,IAFP,SAEoBH,OAFpB,GAE8BF,MAF9B,CAE0CM,CAF1C,CAAA,GAE+CD,IAF/C,SAE4DF,MAF5D,GAEqEH,KAFrE,CAEgFM,CAFhF,CAAA,GAEqFD,IAFrF,SAAA,CAAA,KAAA,EAAA,CAAA,EAAA,GAEgHD,QAFhH,CAEyHK,CAFzH,EAE4HH,CAF5H,CAAA,EAAA,GAEmID,IAFnI,UAAA,CAAA,GAAA,IAAA,EAAA,KAAA,EAAA,EAAA,GAAA,KAAA,EAAA,IAAA,CAAA,GAAA,IAAA,EAAA,QAC9BF,MAEIO,CAFE,GAEEN,QAFQD,CAECO,CAFDP,CAEGQ,CAFHR,CAAAA,EAEOG,CAFD,CAAA,EAClC,EAAA,GAEMF,QAFMA,CAEGQ,CAFK,EAEFN,CAFE,CAAA,GAEGD,IAFHA,SAAA,MAAA,GAAA,QAAiBJ,MAGrBI,IAHqBJ,GAGdG,QAHcH,CAGLI,IAHKJ,CAGAU,CAHAV,CAAAA,EAGIK,CAHJL,CAAAA,EAAYI,GAI7CA,IAJ6CA;KAK5CQ,YAAAA,GALyDX,MAAAA,GAAAA,SAAAA;AAAsBI,cAM/DQ,YAN+DR,CAAAA,aAMrCO,YANqCP,GAMtBO,YANsBP,EAAAA,eAMOL,QANPK,GAMkBL,QANlBK,CAAAA,CAAAA;EAAZN,KAAAA,EAO7DK,IAP6DL;EAAiBK,OAAAA,EAQ5EU,MAR4EV;EAAaF,IAAAA,EAS5Fa,OAT4Fb,CASpFY,MAToFZ,EAS5EC,QAT4ED,CASnEE,IATmEF,EAS7DY,MAT6DZ,CAAAA,CAAAA;EAAoBG,MAAAA,EAU9GW,GAV8GX,CAAAA,MAAAA,EAUlGS,MAVkGT,CAAAA;EAAXN,GAAAA,CAAAA,UAW7Fe,MAX6Ff,CAAAA,CAAAA,MAAAA,EAW7EM,CAX6EN,EAAAA,GAAAA,KAAAA,EAAAA,SAAAA,SAW9CK,IAX8CL,GAAAA,CAWtCI,QAXsCJ,CAW7BK,IAX6BL,EAWvBM,CAXuBN,CAAAA,CAAAA,CAAAA,GAAAA,CAWfI,QAXeJ,CAWNK,IAXML,EAWAM,CAXAN,CAAAA,CAAAA,CAAAA,EAAAA,IAAAA;EAAgBK,KAAAA,CAAAA,CAAAA,EAAAA,IAAAA;EAAoCI,MAAAA,CAAAA,MAAAA,EAahJM,MAbgJN,CAAAA,EAAAA,IAAAA;EAAGH,GAAAA,CAAAA,UAcpJS,MAdoJT,CAAAA,CAAAA,MAAAA,EAcpIA,CAdoIA,CAAAA,EAchIF,QAdgIE,CAcvHD,IAduHC,EAcjHA,CAdiHA,CAAAA,GAAAA,SAAAA;EAAZF,GAAAA,CAAAA,MAAAA,EAe1IW,MAf0IX,CAAAA,EAAAA,OAAAA;;AAC1IM,UAgBCQ,cAAAA,CAhBDR;EAAaA,EAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAEC,KAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAIL,WAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAfF,UAAAA,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;EACLQ,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,OAAAA;;AAATR,UAsBWe,UAAAA,SAAmBD,cAtB9Bd,CAAAA"}

package/schemas.d.ts

@@ -1,11 +1,13 @@
+import { BaseSchema } from "./json-schema.js";
 import { StandardSchemaV1 } from "./standard-schema.js";
-import { AnyFunc, Class, EnumLike, IsAny, JWTAlgorithm, Literal, LoosePartial, MakeReadonly, MaybeAsync, NoUndefined, Prettify, PrimitiveSet, PropValues } from "./util.js";
+import { ProcessParams, ToJSONSchemaContext } from "./to-json-schema.js";
+import { AnyFunc, Class, EnumLike, IsAny, JWTAlgorithm, Literal, LoosePartial, MakeReadonly, MaybeAsync, MimeTypes, NoUndefined, Prettify, PrimitiveSet, PropValues, TupleItems } from "./util.js";
 import { version } from "./versions.js";
 import { $ZodCheck, $ZodCheckDef, $ZodCheckInternals, $ZodCheckStringFormatDef, $ZodCheckStringFormatInternals } from "./checks.js";
-import { $ZodErrorMap, $ZodIssue, $ZodIssueBase, $ZodIssueInvalidKey, $ZodIssueInvalidType, $ZodIssueInvalidUnion, $ZodIssueInvalidValue, $ZodIssueUnrecognizedKeys, $ZodRawIssue } from "./errors.js";
+import { $ZodErrorMap, $ZodIssue, $ZodIssueBase, $ZodIssueInvalidElement, $ZodIssueInvalidKey, $ZodIssueInvalidType, $ZodIssueInvalidUnion, $ZodIssueInvalidValue, $ZodIssueTooBig, $ZodIssueTooSmall, $ZodIssueUnrecognizedKeys, $ZodRawIssue } from "./errors.js";
 import { $constructor, input, output } from "./core.js";
 
-//#region ../../node_modules/.bun/zod@4.1.12/node_modules/zod/v4/core/schemas.d.cts
+//#region ../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/schemas.d.cts
 interface ParseContext<T$1 extends $ZodIssueBase = never> {
   /** Customize error messages. */
   readonly error?: $ZodErrorMap<T$1>;
@@ -71,6 +73,8 @@ interface _$ZodTypeInternals {
   bag: Record<string, unknown>;
   /** @internal The set of issues this schema might throw during type checking. */
   isst: $ZodIssueBase;
+  /** @internal Subject to change, not a public API. */
+  processJSONSchema?: ((ctx: ToJSONSchemaContext, json: BaseSchema, params: ProcessParams) => void) | undefined;
   /** An optional method used to override `toJSONSchema` logic. */
   toJSONSchema?: () => unknown;
   /** @internal The parent of this schema. Only set during certain clone operations. */
@@ -91,6 +95,7 @@ interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals
   _zod: Internals;
   "~standard": $ZodStandardSchema<this>;
 }
+interface _$ZodType<T$1 extends $ZodTypeInternals = $ZodTypeInternals> extends $ZodType<T$1["output"], T$1["input"], T$1> {}
 declare const $ZodType: $constructor<$ZodType>;
 interface $ZodStringDef extends $ZodTypeDef {
   type: "string";
@@ -111,6 +116,8 @@ interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, Input> {
     contentEncoding: string;
   }>;
 }
+interface $ZodString<Input = unknown> extends _$ZodType<$ZodStringInternals<Input>> {}
+declare const $ZodString: $constructor<$ZodString>;
 interface $ZodStringFormatDef<Format extends string = string> extends $ZodStringDef, $ZodCheckStringFormatDef<Format> {}
 interface $ZodStringFormatInternals<Format extends string = string> extends $ZodStringInternals<string>, $ZodCheckStringFormatInternals {
   def: $ZodStringFormatDef<Format>;
@@ -302,6 +309,10 @@ interface $ZodNumberInternals<Input = unknown> extends $ZodTypeInternals<number,
     pattern: RegExp;
   }>;
 }
+interface $ZodNumber<Input = unknown> extends $ZodType {
+  _zod: $ZodNumberInternals<Input>;
+}
+declare const $ZodNumber: $constructor<$ZodNumber>;
 interface $ZodBooleanDef extends $ZodTypeDef {
   type: "boolean";
   coerce?: boolean;
@@ -312,6 +323,53 @@ interface $ZodBooleanInternals<T$1 = unknown> extends $ZodTypeInternals<boolean,
   def: $ZodBooleanDef;
   isst: $ZodIssueInvalidType;
 }
+interface $ZodBoolean<T$1 = unknown> extends $ZodType {
+  _zod: $ZodBooleanInternals<T$1>;
+}
+declare const $ZodBoolean: $constructor<$ZodBoolean>;
+interface $ZodBigIntDef extends $ZodTypeDef {
+  type: "bigint";
+  coerce?: boolean;
+}
+interface $ZodBigIntInternals<T$1 = unknown> extends $ZodTypeInternals<bigint, T$1> {
+  pattern: RegExp;
+  /** @internal Internal API, use with caution */
+  def: $ZodBigIntDef;
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: bigint;
+    maximum: bigint;
+    format: string;
+  }>;
+}
+interface $ZodBigInt<T$1 = unknown> extends $ZodType {
+  _zod: $ZodBigIntInternals<T$1>;
+}
+declare const $ZodBigInt: $constructor<$ZodBigInt>;
+interface $ZodSymbolDef extends $ZodTypeDef {
+  type: "symbol";
+}
+interface $ZodSymbolInternals extends $ZodTypeInternals<symbol, symbol> {
+  def: $ZodSymbolDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodSymbol extends $ZodType {
+  _zod: $ZodSymbolInternals;
+}
+declare const $ZodSymbol: $constructor<$ZodSymbol>;
+interface $ZodUndefinedDef extends $ZodTypeDef {
+  type: "undefined";
+}
+interface $ZodUndefinedInternals extends $ZodTypeInternals<undefined, undefined> {
+  pattern: RegExp;
+  def: $ZodUndefinedDef;
+  values: PrimitiveSet;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodUndefined extends $ZodType {
+  _zod: $ZodUndefinedInternals;
+}
+declare const $ZodUndefined: $constructor<$ZodUndefined>;
 interface $ZodNullDef extends $ZodTypeDef {
   type: "null";
 }
@@ -321,6 +379,21 @@ interface $ZodNullInternals extends $ZodTypeInternals<null, null> {
   values: PrimitiveSet;
   isst: $ZodIssueInvalidType;
 }
+interface $ZodNull extends $ZodType {
+  _zod: $ZodNullInternals;
+}
+declare const $ZodNull: $constructor<$ZodNull>;
+interface $ZodAnyDef extends $ZodTypeDef {
+  type: "any";
+}
+interface $ZodAnyInternals extends $ZodTypeInternals<any, any> {
+  def: $ZodAnyDef;
+  isst: never;
+}
+interface $ZodAny extends $ZodType {
+  _zod: $ZodAnyInternals;
+}
+declare const $ZodAny: $constructor<$ZodAny>;
 interface $ZodUnknownDef extends $ZodTypeDef {
   type: "unknown";
 }
@@ -328,6 +401,49 @@ interface $ZodUnknownInternals extends $ZodTypeInternals<unknown, unknown> {
   def: $ZodUnknownDef;
   isst: never;
 }
+interface $ZodUnknown extends $ZodType {
+  _zod: $ZodUnknownInternals;
+}
+declare const $ZodUnknown: $constructor<$ZodUnknown>;
+interface $ZodNeverDef extends $ZodTypeDef {
+  type: "never";
+}
+interface $ZodNeverInternals extends $ZodTypeInternals<never, never> {
+  def: $ZodNeverDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodNever extends $ZodType {
+  _zod: $ZodNeverInternals;
+}
+declare const $ZodNever: $constructor<$ZodNever>;
+interface $ZodVoidDef extends $ZodTypeDef {
+  type: "void";
+}
+interface $ZodVoidInternals extends $ZodTypeInternals<void, void> {
+  def: $ZodVoidDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodVoid extends $ZodType {
+  _zod: $ZodVoidInternals;
+}
+declare const $ZodVoid: $constructor<$ZodVoid>;
+interface $ZodDateDef extends $ZodTypeDef {
+  type: "date";
+  coerce?: boolean;
+}
+interface $ZodDateInternals<T$1 = unknown> extends $ZodTypeInternals<Date, T$1> {
+  def: $ZodDateDef;
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: Date;
+    maximum: Date;
+    format: string;
+  }>;
+}
+interface $ZodDate<T$1 = unknown> extends $ZodType {
+  _zod: $ZodDateInternals<T$1>;
+}
+declare const $ZodDate: $constructor<$ZodDate>;
 interface $ZodArrayDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "array";
   element: T$1;
@@ -397,15 +513,14 @@ out Shape extends $ZodShape = $ZodShape, out Config extends $ZodObjectConfig = $
 }
 type $ZodLooseShape = Record<string, any>;
 interface $ZodObject< /** @ts-ignore Cast variance */
-out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {
-  "~standard": $ZodStandardSchema<this>;
-}
+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$1 extends SomeType> = T$1 extends any ? output<T$1> : never;
 type $InferUnionInput<T$1 extends SomeType> = T$1 extends any ? input<T$1> : never;
 interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
   type: "union";
   options: Options;
+  inclusive?: boolean;
 }
 type IsOptionalIn<T$1 extends SomeType> = T$1 extends OptionalInSchema ? true : false;
 type IsOptionalOut<T$1 extends SomeType> = T$1 extends OptionalOutSchema ? true : false;
@@ -440,11 +555,34 @@ interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $
   _zod: $ZodIntersectionInternals<A, B>;
 }
 declare const $ZodIntersection: $constructor<$ZodIntersection>;
+interface $ZodTupleDef<T$1 extends TupleItems = readonly $ZodType[], Rest$1 extends SomeType | null = $ZodType | null> extends $ZodTypeDef {
+  type: "tuple";
+  items: T$1;
+  rest: Rest$1;
+}
+type $InferTupleInputType<T$1 extends TupleItems, Rest$1 extends SomeType | null> = [...TupleInputTypeWithOptionals<T$1>, ...(Rest$1 extends SomeType ? input<Rest$1>[] : [])];
+type TupleInputTypeNoOptionals<T$1 extends TupleItems> = { [k in keyof T$1]: input<T$1[k]> };
+type TupleInputTypeWithOptionals<T$1 extends TupleItems> = T$1 extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optin"] extends "optional" ? [...TupleInputTypeWithOptionals<Prefix>, input<Tail>?] : TupleInputTypeNoOptionals<T$1> : [];
+type $InferTupleOutputType<T$1 extends TupleItems, Rest$1 extends SomeType | null> = [...TupleOutputTypeWithOptionals<T$1>, ...(Rest$1 extends SomeType ? output<Rest$1>[] : [])];
+type TupleOutputTypeNoOptionals<T$1 extends TupleItems> = { [k in keyof T$1]: output<T$1[k]> };
+type TupleOutputTypeWithOptionals<T$1 extends TupleItems> = T$1 extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, output<Tail>?] : TupleOutputTypeNoOptionals<T$1> : [];
+interface $ZodTupleInternals<T$1 extends TupleItems = readonly $ZodType[], Rest$1 extends SomeType | null = $ZodType | null> extends _$ZodTypeInternals {
+  def: $ZodTupleDef<T$1, Rest$1>;
+  isst: $ZodIssueInvalidType | $ZodIssueTooBig<unknown[]> | $ZodIssueTooSmall<unknown[]>;
+  output: $InferTupleOutputType<T$1, Rest$1>;
+  input: $InferTupleInputType<T$1, Rest$1>;
+}
+interface $ZodTuple<T$1 extends TupleItems = readonly $ZodType[], Rest$1 extends SomeType | null = $ZodType | null> extends $ZodType {
+  _zod: $ZodTupleInternals<T$1, Rest$1>;
+}
+declare const $ZodTuple: $constructor<$ZodTuple>;
 type $ZodRecordKey = $ZodType<string | number | symbol, string | number | symbol>;
 interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "record";
   keyType: Key;
   valueType: Value;
+  /** @default "strict" - errors on keys not matching keyType. "loose" passes through non-matching keys unchanged. */
+  mode?: "strict" | "loose";
 }
 type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<output<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>, input<Value>>> : Record<input<Key>, input<Value>>;
@@ -461,6 +599,35 @@ interface $ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends So
   _zod: $ZodRecordInternals<Key, Value>;
 }
 declare const $ZodRecord: $constructor<$ZodRecord>;
+interface $ZodMapDef<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "map";
+  keyType: Key;
+  valueType: Value;
+}
+interface $ZodMapInternals<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeInternals<Map<output<Key>, output<Value>>, Map<input<Key>, input<Value>>> {
+  def: $ZodMapDef<Key, Value>;
+  isst: $ZodIssueInvalidType | $ZodIssueInvalidKey | $ZodIssueInvalidElement<unknown>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+interface $ZodMap<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodMapInternals<Key, Value>;
+}
+declare const $ZodMap: $constructor<$ZodMap>;
+interface $ZodSetDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "set";
+  valueType: T$1;
+}
+interface $ZodSetInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<Set<output<T$1>>, Set<input<T$1>>> {
+  def: $ZodSetDef<T$1>;
+  isst: $ZodIssueInvalidType;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+interface $ZodSet<T$1 extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodSetInternals<T$1>;
+}
+declare const $ZodSet: $constructor<$ZodSet>;
 type $InferEnumOutput<T$1 extends EnumLike> = T$1[keyof T$1] & {};
 type $InferEnumInput<T$1 extends EnumLike> = T$1[keyof T$1] & {};
 interface $ZodEnumDef<T$1 extends EnumLike = EnumLike> extends $ZodTypeDef {
@@ -494,6 +661,30 @@ interface $ZodLiteral<T$1 extends Literal = Literal> extends $ZodType {
   _zod: $ZodLiteralInternals<T$1>;
 }
 declare const $ZodLiteral: $constructor<$ZodLiteral>;
+type _File = typeof globalThis extends {
+  File: infer F extends new (...args: any[]) => any;
+} ? InstanceType<F> : {};
+/** Do not reference this directly. */
+interface File extends _File {
+  readonly type: string;
+  readonly size: number;
+}
+interface $ZodFileDef extends $ZodTypeDef {
+  type: "file";
+}
+interface $ZodFileInternals extends $ZodTypeInternals<File, File> {
+  def: $ZodFileDef;
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: number;
+    maximum: number;
+    mime: MimeTypes[];
+  }>;
+}
+interface $ZodFile extends $ZodType {
+  _zod: $ZodFileInternals;
+}
+declare const $ZodFile: $constructor<$ZodFile>;
 interface $ZodTransformDef extends $ZodTypeDef {
   type: "transform";
   transform: (input: unknown, payload: ParsePayload<unknown>) => MaybeAsync<unknown>;
@@ -587,6 +778,20 @@ interface $ZodNonOptional<T$1 extends SomeType = $ZodType> extends $ZodType {
   _zod: $ZodNonOptionalInternals<T$1>;
 }
 declare const $ZodNonOptional: $constructor<$ZodNonOptional>;
+interface $ZodSuccessDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "success";
+  innerType: T$1;
+}
+interface $ZodSuccessInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, input<T$1>> {
+  def: $ZodSuccessDef<T$1>;
+  isst: never;
+  optin: T$1["_zod"]["optin"];
+  optout: "optional" | undefined;
+}
+interface $ZodSuccess<T$1 extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodSuccessInternals<T$1>;
+}
+declare const $ZodSuccess: $constructor<$ZodSuccess>;
 interface $ZodCatchCtx extends ParsePayload {
   /** @deprecated Use `ctx.issues` */
   error: {
@@ -611,6 +816,17 @@ interface $ZodCatch<T$1 extends SomeType = $ZodType> extends $ZodType {
   _zod: $ZodCatchInternals<T$1>;
 }
 declare const $ZodCatch: $constructor<$ZodCatch>;
+interface $ZodNaNDef extends $ZodTypeDef {
+  type: "nan";
+}
+interface $ZodNaNInternals extends $ZodTypeInternals<number, number> {
+  def: $ZodNaNDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodNaN extends $ZodType {
+  _zod: $ZodNaNInternals;
+}
+declare const $ZodNaN: $constructor<$ZodNaN>;
 interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeDef {
   type: "pipe";
   in: A;
@@ -648,6 +864,87 @@ interface $ZodReadonly<T$1 extends SomeType = $ZodType> extends $ZodType {
   _zod: $ZodReadonlyInternals<T$1>;
 }
 declare const $ZodReadonly: $constructor<$ZodReadonly>;
+interface $ZodTemplateLiteralDef extends $ZodTypeDef {
+  type: "template_literal";
+  parts: $ZodTemplateLiteralPart[];
+  format?: string | undefined;
+}
+interface $ZodTemplateLiteralInternals<Template extends string = string> extends $ZodTypeInternals<Template, Template> {
+  pattern: RegExp;
+  def: $ZodTemplateLiteralDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodTemplateLiteral<Template extends string = string> extends $ZodType {
+  _zod: $ZodTemplateLiteralInternals<Template>;
+}
+type LiteralPart = Exclude<Literal, symbol>;
+interface SchemaPartInternals extends $ZodTypeInternals<LiteralPart, LiteralPart> {
+  pattern: RegExp;
+}
+interface SchemaPart extends $ZodType {
+  _zod: SchemaPartInternals;
+}
+type $ZodTemplateLiteralPart = LiteralPart | SchemaPart;
+declare const $ZodTemplateLiteral: $constructor<$ZodTemplateLiteral>;
+type $ZodFunctionArgs = $ZodType<unknown[], unknown[]>;
+type $ZodFunctionIn = $ZodFunctionArgs;
+type $ZodFunctionOut = $ZodType;
+type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<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>) => MaybeAsync<output<Returns>>;
+interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodTypeDef {
+  type: "function";
+  input: In;
+  output: Out;
+}
+interface $ZodFunctionInternals<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> extends $ZodTypeInternals<$InferOuterFunctionType<Args, Returns>, $InferInnerFunctionType<Args, Returns>> {
+  def: $ZodFunctionDef<Args, Returns>;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodType<any, any, $ZodFunctionInternals<Args, Returns>> {
+  /** @deprecated */
+  _def: $ZodFunctionDef<Args, Returns>;
+  _input: $InferInnerFunctionType<Args, Returns>;
+  _output: $InferOuterFunctionType<Args, Returns>;
+  implement<F$1 extends $InferInnerFunctionType<Args, Returns>>(func: F$1): (...args: Parameters<this["_output"]>) => ReturnType<F$1> extends ReturnType<this["_output"]> ? ReturnType<F$1> : ReturnType<this["_output"]>;
+  implementAsync<F$1 extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F$1): F$1 extends $InferOuterFunctionTypeAsync<Args, Returns> ? F$1 : $InferOuterFunctionTypeAsync<Args, Returns>;
+  input<const Items extends TupleItems, const Rest$1 extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest$1): $ZodFunction<$ZodTuple<Items, Rest$1>, Returns>;
+  input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
+  input(...args: any[]): $ZodFunction<any, Returns>;
+  output<NewReturns extends $ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
+}
+declare const $ZodFunction: $constructor<$ZodFunction>;
+interface $ZodPromiseDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "promise";
+  innerType: T$1;
+}
+interface $ZodPromiseInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<output<T$1>>, MaybeAsync<input<T$1>>> {
+  def: $ZodPromiseDef<T$1>;
+  isst: never;
+}
+interface $ZodPromise<T$1 extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodPromiseInternals<T$1>;
+}
+declare const $ZodPromise: $constructor<$ZodPromise>;
+interface $ZodLazyDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "lazy";
+  getter: () => T$1;
+}
+interface $ZodLazyInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<output<T$1>, input<T$1>> {
+  def: $ZodLazyDef<T$1>;
+  isst: never;
+  /** Auto-cached way to retrieve the inner schema */
+  innerType: T$1;
+  pattern: T$1["_zod"]["pattern"];
+  propValues: T$1["_zod"]["propValues"];
+  optin: T$1["_zod"]["optin"];
+  optout: T$1["_zod"]["optout"];
+}
+interface $ZodLazy<T$1 extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodLazyInternals<T$1>;
+}
+declare const $ZodLazy: $constructor<$ZodLazy>;
 interface $ZodCustomDef<O = unknown> extends $ZodTypeDef, $ZodCheckDef {
   type: "custom";
   check: "custom";
@@ -668,6 +965,7 @@ interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
   _zod: $ZodCustomInternals<O, I>;
 }
 declare const $ZodCustom: $constructor<$ZodCustom>;
+type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodFunction | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile;
 //#endregion
-export { $ZodArray, $ZodArrayInternals, $ZodBase64, $ZodBase64URL, $ZodBooleanInternals, $ZodCIDRv4, $ZodCIDRv6, $ZodCUID, $ZodCUID2, $ZodCatch, $ZodCatchCtx, $ZodCatchInternals, $ZodCustom, $ZodDefault, $ZodDefaultInternals, $ZodE164, $ZodEmail, $ZodEmailInternals, $ZodEmoji, $ZodEnum, $ZodEnumInternals, $ZodGUID, $ZodIPv4, $ZodIPv6, $ZodISODate, $ZodISODateTime, $ZodISODuration, $ZodISOTime, $ZodIntersection, $ZodIntersectionInternals, $ZodJWT, $ZodKSUID, $ZodLiteral, $ZodLiteralInternals, $ZodLooseShape, $ZodNanoID, $ZodNonOptional, $ZodNonOptionalInternals, $ZodNullInternals, $ZodNullable, $ZodNullableInternals, $ZodNumberInternals, $ZodObject, $ZodObjectConfig, $ZodObjectInternals, $ZodOptional, $ZodOptionalInternals, $ZodPipe, $ZodPipeInternals, $ZodPrefault, $ZodPrefaultInternals, $ZodReadonly, $ZodReadonlyInternals, $ZodRecord, $ZodRecordInternals, $ZodRecordKey, $ZodShape, $ZodStringFormat, $ZodStringFormatInternals, $ZodStringInternals, $ZodTransform, $ZodTransformInternals, $ZodType, $ZodTypeInternals, $ZodULID, $ZodULIDInternals, $ZodURL, $ZodURLInternals, $ZodUUID, $ZodUnion, $ZodUnionInternals, $ZodUnknownInternals, $ZodXID, $catchall, $loose, $strict, $strip, CheckFn, ParseContext, ParsePayload, SomeType };
+export { $ZodArray, $ZodArrayInternals, $ZodBase64, $ZodBase64URL, $ZodBooleanInternals, $ZodCIDRv4, $ZodCIDRv6, $ZodCUID, $ZodCUID2, $ZodCatch, $ZodCatchCtx, $ZodCatchInternals, $ZodCustom, $ZodDefault, $ZodDefaultInternals, $ZodE164, $ZodEmail, $ZodEmailInternals, $ZodEmoji, $ZodEnum, $ZodEnumInternals, $ZodGUID, $ZodIPv4, $ZodIPv6, $ZodISODate, $ZodISODateTime, $ZodISODuration, $ZodISOTime, $ZodIntersection, $ZodIntersectionInternals, $ZodJWT, $ZodKSUID, $ZodLiteral, $ZodLiteralInternals, $ZodLooseShape, $ZodNanoID, $ZodNonOptional, $ZodNonOptionalInternals, $ZodNullInternals, $ZodNullable, $ZodNullableInternals, $ZodNumberInternals, $ZodObject, $ZodObjectConfig, $ZodObjectInternals, $ZodOptional, $ZodOptionalInternals, $ZodPipe, $ZodPipeInternals, $ZodPrefault, $ZodPrefaultInternals, $ZodReadonly, $ZodReadonlyInternals, $ZodRecord, $ZodRecordInternals, $ZodRecordKey, $ZodShape, $ZodStringFormat, $ZodStringFormatInternals, $ZodStringInternals, $ZodTransform, $ZodTransformInternals, $ZodType, $ZodTypeInternals, $ZodTypes, $ZodULID, $ZodULIDInternals, $ZodURL, $ZodURLInternals, $ZodUUID, $ZodUnion, $ZodUnionInternals, $ZodUnknownInternals, $ZodXID, $catchall, $loose, $strict, $strip, CheckFn, ParseContext, ParsePayload, SomeType };
 //# sourceMappingURL=schemas.d.ts.map