@cossistant/react 0.0.6 → 0.0.8

package/schemas.d.ts

@@ -1,96 +1,673 @@
-import { z } from "zod";
+import { StandardSchemaV1 } from "./standard-schema.js";
+import { AnyFunc, Class, EnumLike, IsAny, JWTAlgorithm, Literal, LoosePartial, MakeReadonly, MaybeAsync, NoUndefined, Prettify, PrimitiveSet, PropValues } 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 { $constructor, input, output } from "./core.js";
 
-//#region ../types/src/schemas.d.ts
-
-declare const conversationSchema: z.ZodObject<{
-  id: z.ZodString;
-  title: z.ZodOptional<z.ZodString>;
-  createdAt: z.ZodString;
-  updatedAt: z.ZodString;
-  visitorId: z.ZodString;
-  websiteId: z.ZodString;
-  status: z.ZodDefault<z.ZodEnum<{
-    resolved: "resolved";
-    open: "open";
-    spam: "spam";
-  }>>;
-  deletedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-  lastTimelineItem: z.ZodOptional<z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    conversationId: z.ZodString;
-    organizationId: z.ZodString;
-    visibility: z.ZodEnum<{
-      public: "public";
-      private: "private";
-    }>;
-    type: z.ZodEnum<{
-      message: "message";
-      event: "event";
-      identification: "identification";
-    }>;
-    text: z.ZodNullable<z.ZodString>;
-    tool: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    parts: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-      type: z.ZodLiteral<"text">;
-      text: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-      type: z.ZodLiteral<"event">;
-      eventType: z.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: z.ZodNullable<z.ZodString>;
-      actorAiAgentId: z.ZodNullable<z.ZodString>;
-      targetUserId: z.ZodNullable<z.ZodString>;
-      targetAiAgentId: z.ZodNullable<z.ZodString>;
-      message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>, z.ZodObject<{
-      type: z.ZodLiteral<"image">;
-      url: z.ZodString;
-      mediaType: z.ZodString;
-      fileName: z.ZodOptional<z.ZodString>;
-      size: z.ZodOptional<z.ZodNumber>;
-      width: z.ZodOptional<z.ZodNumber>;
-      height: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
-      type: z.ZodLiteral<"file">;
-      url: z.ZodString;
-      mediaType: z.ZodString;
-      fileName: z.ZodOptional<z.ZodString>;
-      size: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>]>>;
-    userId: z.ZodNullable<z.ZodString>;
-    aiAgentId: z.ZodNullable<z.ZodString>;
-    visitorId: z.ZodNullable<z.ZodString>;
-    createdAt: z.ZodString;
-    deletedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-  }, z.core.$strip>>;
-}, z.core.$strip>;
-type Conversation = z.infer<typeof conversationSchema>;
-declare const conversationSeenSchema: z.ZodObject<{
-  id: z.ZodString;
-  conversationId: z.ZodString;
-  userId: z.ZodNullable<z.ZodString>;
-  visitorId: z.ZodNullable<z.ZodString>;
-  aiAgentId: z.ZodNullable<z.ZodString>;
-  lastSeenAt: z.ZodString;
-  createdAt: z.ZodString;
-  updatedAt: z.ZodString;
-  deletedAt: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
-type ConversationSeen = z.infer<typeof conversationSeenSchema>;
+//#region ../../node_modules/.bun/zod@4.1.12/node_modules/zod/v4/core/schemas.d.cts
+interface ParseContext<T$1 extends $ZodIssueBase = never> {
+  /** Customize error messages. */
+  readonly error?: $ZodErrorMap<T$1>;
+  /** Include the `input` field in issue objects. Default `false`. */
+  readonly reportInput?: boolean;
+  /** Skip eval-based fast path. Default `false`. */
+  readonly jitless?: boolean;
+}
+/** @internal */
+interface ParseContextInternal<T$1 extends $ZodIssueBase = never> extends ParseContext<T$1> {
+  readonly async?: boolean | undefined;
+  readonly direction?: "forward" | "backward";
+  readonly skipChecks?: boolean;
+}
+interface ParsePayload<T$1 = unknown> {
+  value: T$1;
+  issues: $ZodRawIssue[];
+  /** A may to mark a whole payload as aborted. Used in codecs/pipes. */
+  aborted?: boolean;
+}
+type CheckFn<T$1> = (input: ParsePayload<T$1>) => MaybeAsync<void>;
+interface $ZodTypeDef {
+  type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "function" | "custom";
+  error?: $ZodErrorMap<never> | undefined;
+  checks?: $ZodCheck<never>[];
+}
+interface _$ZodTypeInternals {
+  /** The `@zod/core` version of this schema */
+  version: typeof version;
+  /** Schema definition. */
+  def: $ZodTypeDef;
+  /** @internal Randomly generated ID for this schema. */
+  /** @internal List of deferred initializers. */
+  deferred: AnyFunc[] | undefined;
+  /** @internal Parses input and runs all checks (refinements). */
+  run(payload: ParsePayload<any>, ctx: ParseContextInternal): MaybeAsync<ParsePayload>;
+  /** @internal Parses input, doesn't run checks. */
+  parse(payload: ParsePayload<any>, ctx: ParseContextInternal): MaybeAsync<ParsePayload>;
+  /** @internal  Stores identifiers for the set of traits implemented by this schema. */
+  traits: Set<string>;
+  /** @internal Indicates that a schema output type should be considered optional inside objects.
+   * @default Required
+   */
+  /** @internal */
+  optin?: "optional" | undefined;
+  /** @internal */
+  optout?: "optional" | undefined;
+  /** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
+   *
+   * Defined on: enum, const, literal, null, undefined
+   * Passthrough: optional, nullable, branded, default, catch, pipe
+   * Todo: unions?
+   */
+  values?: PrimitiveSet | undefined;
+  /** Default value bubbled up from  */
+  /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
+  propValues?: PropValues | undefined;
+  /** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
+  pattern: RegExp | undefined;
+  /** @internal The constructor function of this schema. */
+  constr: new (def: any) => $ZodType;
+  /** @internal A catchall object for bag metadata related to this schema. Commonly modified by checks using `onattach`. */
+  bag: Record<string, unknown>;
+  /** @internal The set of issues this schema might throw during type checking. */
+  isst: $ZodIssueBase;
+  /** An optional method used to override `toJSONSchema` logic. */
+  toJSONSchema?: () => unknown;
+  /** @internal The parent of this schema. Only set during certain clone operations. */
+  parent?: $ZodType | undefined;
+}
+/** @internal */
+interface $ZodTypeInternals<out O = unknown, out I = unknown> extends _$ZodTypeInternals {
+  /** @internal The inferred output type */
+  output: O;
+  /** @internal The inferred input type */
+  input: I;
+}
+type $ZodStandardSchema<T$1> = StandardSchemaV1.Props<input<T$1>, output<T$1>>;
+type SomeType = {
+  _zod: _$ZodTypeInternals;
+};
+interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> {
+  _zod: Internals;
+  "~standard": $ZodStandardSchema<this>;
+}
+declare const $ZodType: $constructor<$ZodType>;
+interface $ZodStringDef extends $ZodTypeDef {
+  type: "string";
+  coerce?: boolean;
+  checks?: $ZodCheck<string>[];
+}
+interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, Input> {
+  def: $ZodStringDef;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: number;
+    maximum: number;
+    patterns: Set<RegExp>;
+    format: string;
+    contentEncoding: string;
+  }>;
+}
+interface $ZodStringFormatDef<Format extends string = string> extends $ZodStringDef, $ZodCheckStringFormatDef<Format> {}
+interface $ZodStringFormatInternals<Format extends string = string> extends $ZodStringInternals<string>, $ZodCheckStringFormatInternals {
+  def: $ZodStringFormatDef<Format>;
+}
+interface $ZodStringFormat<Format extends string = string> extends $ZodType {
+  _zod: $ZodStringFormatInternals<Format>;
+}
+declare const $ZodStringFormat: $constructor<$ZodStringFormat>;
+interface $ZodGUIDInternals extends $ZodStringFormatInternals<"guid"> {}
+interface $ZodGUID extends $ZodType {
+  _zod: $ZodGUIDInternals;
+}
+declare const $ZodGUID: $constructor<$ZodGUID>;
+interface $ZodUUIDDef extends $ZodStringFormatDef<"uuid"> {
+  version?: "v1" | "v2" | "v3" | "v4" | "v5" | "v6" | "v7" | "v8";
+}
+interface $ZodUUIDInternals extends $ZodStringFormatInternals<"uuid"> {
+  def: $ZodUUIDDef;
+}
+interface $ZodUUID extends $ZodType {
+  _zod: $ZodUUIDInternals;
+}
+declare const $ZodUUID: $constructor<$ZodUUID>;
+interface $ZodEmailInternals extends $ZodStringFormatInternals<"email"> {}
+interface $ZodEmail extends $ZodType {
+  _zod: $ZodEmailInternals;
+}
+declare const $ZodEmail: $constructor<$ZodEmail>;
+interface $ZodURLDef extends $ZodStringFormatDef<"url"> {
+  hostname?: RegExp | undefined;
+  protocol?: RegExp | undefined;
+  normalize?: boolean | undefined;
+}
+interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
+  def: $ZodURLDef;
+}
+interface $ZodURL extends $ZodType {
+  _zod: $ZodURLInternals;
+}
+declare const $ZodURL: $constructor<$ZodURL>;
+interface $ZodEmojiInternals extends $ZodStringFormatInternals<"emoji"> {}
+interface $ZodEmoji extends $ZodType {
+  _zod: $ZodEmojiInternals;
+}
+declare const $ZodEmoji: $constructor<$ZodEmoji>;
+interface $ZodNanoIDInternals extends $ZodStringFormatInternals<"nanoid"> {}
+interface $ZodNanoID extends $ZodType {
+  _zod: $ZodNanoIDInternals;
+}
+declare const $ZodNanoID: $constructor<$ZodNanoID>;
+interface $ZodCUIDInternals extends $ZodStringFormatInternals<"cuid"> {}
+interface $ZodCUID extends $ZodType {
+  _zod: $ZodCUIDInternals;
+}
+declare const $ZodCUID: $constructor<$ZodCUID>;
+interface $ZodCUID2Internals extends $ZodStringFormatInternals<"cuid2"> {}
+interface $ZodCUID2 extends $ZodType {
+  _zod: $ZodCUID2Internals;
+}
+declare const $ZodCUID2: $constructor<$ZodCUID2>;
+interface $ZodULIDInternals extends $ZodStringFormatInternals<"ulid"> {}
+interface $ZodULID extends $ZodType {
+  _zod: $ZodULIDInternals;
+}
+declare const $ZodULID: $constructor<$ZodULID>;
+interface $ZodXIDInternals extends $ZodStringFormatInternals<"xid"> {}
+interface $ZodXID extends $ZodType {
+  _zod: $ZodXIDInternals;
+}
+declare const $ZodXID: $constructor<$ZodXID>;
+interface $ZodKSUIDInternals extends $ZodStringFormatInternals<"ksuid"> {}
+interface $ZodKSUID extends $ZodType {
+  _zod: $ZodKSUIDInternals;
+}
+declare const $ZodKSUID: $constructor<$ZodKSUID>;
+interface $ZodISODateTimeDef extends $ZodStringFormatDef<"datetime"> {
+  precision: number | null;
+  offset: boolean;
+  local: boolean;
+}
+interface $ZodISODateTimeInternals extends $ZodStringFormatInternals {
+  def: $ZodISODateTimeDef;
+}
+interface $ZodISODateTime extends $ZodType {
+  _zod: $ZodISODateTimeInternals;
+}
+declare const $ZodISODateTime: $constructor<$ZodISODateTime>;
+interface $ZodISODateInternals extends $ZodStringFormatInternals<"date"> {}
+interface $ZodISODate extends $ZodType {
+  _zod: $ZodISODateInternals;
+}
+declare const $ZodISODate: $constructor<$ZodISODate>;
+interface $ZodISOTimeDef extends $ZodStringFormatDef<"time"> {
+  precision?: number | null;
+}
+interface $ZodISOTimeInternals extends $ZodStringFormatInternals<"time"> {
+  def: $ZodISOTimeDef;
+}
+interface $ZodISOTime extends $ZodType {
+  _zod: $ZodISOTimeInternals;
+}
+declare const $ZodISOTime: $constructor<$ZodISOTime>;
+interface $ZodISODurationInternals extends $ZodStringFormatInternals<"duration"> {}
+interface $ZodISODuration extends $ZodType {
+  _zod: $ZodISODurationInternals;
+}
+declare const $ZodISODuration: $constructor<$ZodISODuration>;
+interface $ZodIPv4Def extends $ZodStringFormatDef<"ipv4"> {
+  version?: "v4";
+}
+interface $ZodIPv4Internals extends $ZodStringFormatInternals<"ipv4"> {
+  def: $ZodIPv4Def;
+}
+interface $ZodIPv4 extends $ZodType {
+  _zod: $ZodIPv4Internals;
+}
+declare const $ZodIPv4: $constructor<$ZodIPv4>;
+interface $ZodIPv6Def extends $ZodStringFormatDef<"ipv6"> {
+  version?: "v6";
+}
+interface $ZodIPv6Internals extends $ZodStringFormatInternals<"ipv6"> {
+  def: $ZodIPv6Def;
+}
+interface $ZodIPv6 extends $ZodType {
+  _zod: $ZodIPv6Internals;
+}
+declare const $ZodIPv6: $constructor<$ZodIPv6>;
+interface $ZodCIDRv4Def extends $ZodStringFormatDef<"cidrv4"> {
+  version?: "v4";
+}
+interface $ZodCIDRv4Internals extends $ZodStringFormatInternals<"cidrv4"> {
+  def: $ZodCIDRv4Def;
+}
+interface $ZodCIDRv4 extends $ZodType {
+  _zod: $ZodCIDRv4Internals;
+}
+declare const $ZodCIDRv4: $constructor<$ZodCIDRv4>;
+interface $ZodCIDRv6Def extends $ZodStringFormatDef<"cidrv6"> {
+  version?: "v6";
+}
+interface $ZodCIDRv6Internals extends $ZodStringFormatInternals<"cidrv6"> {
+  def: $ZodCIDRv6Def;
+}
+interface $ZodCIDRv6 extends $ZodType {
+  _zod: $ZodCIDRv6Internals;
+}
+declare const $ZodCIDRv6: $constructor<$ZodCIDRv6>;
+interface $ZodBase64Internals extends $ZodStringFormatInternals<"base64"> {}
+interface $ZodBase64 extends $ZodType {
+  _zod: $ZodBase64Internals;
+}
+declare const $ZodBase64: $constructor<$ZodBase64>;
+interface $ZodBase64URLInternals extends $ZodStringFormatInternals<"base64url"> {}
+interface $ZodBase64URL extends $ZodType {
+  _zod: $ZodBase64URLInternals;
+}
+declare const $ZodBase64URL: $constructor<$ZodBase64URL>;
+interface $ZodE164Internals extends $ZodStringFormatInternals<"e164"> {}
+interface $ZodE164 extends $ZodType {
+  _zod: $ZodE164Internals;
+}
+declare const $ZodE164: $constructor<$ZodE164>;
+interface $ZodJWTDef extends $ZodStringFormatDef<"jwt"> {
+  alg?: JWTAlgorithm | undefined;
+}
+interface $ZodJWTInternals extends $ZodStringFormatInternals<"jwt"> {
+  def: $ZodJWTDef;
+}
+interface $ZodJWT extends $ZodType {
+  _zod: $ZodJWTInternals;
+}
+declare const $ZodJWT: $constructor<$ZodJWT>;
+interface $ZodNumberDef extends $ZodTypeDef {
+  type: "number";
+  coerce?: boolean;
+}
+interface $ZodNumberInternals<Input = unknown> extends $ZodTypeInternals<number, Input> {
+  def: $ZodNumberDef;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: number;
+    maximum: number;
+    exclusiveMinimum: number;
+    exclusiveMaximum: number;
+    format: string;
+    pattern: RegExp;
+  }>;
+}
+interface $ZodBooleanDef extends $ZodTypeDef {
+  type: "boolean";
+  coerce?: boolean;
+  checks?: $ZodCheck<boolean>[];
+}
+interface $ZodBooleanInternals<T$1 = unknown> extends $ZodTypeInternals<boolean, T$1> {
+  pattern: RegExp;
+  def: $ZodBooleanDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodNullDef extends $ZodTypeDef {
+  type: "null";
+}
+interface $ZodNullInternals extends $ZodTypeInternals<null, null> {
+  pattern: RegExp;
+  def: $ZodNullDef;
+  values: PrimitiveSet;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodUnknownDef extends $ZodTypeDef {
+  type: "unknown";
+}
+interface $ZodUnknownInternals extends $ZodTypeInternals<unknown, unknown> {
+  def: $ZodUnknownDef;
+  isst: never;
+}
+interface $ZodArrayDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "array";
+  element: T$1;
+}
+interface $ZodArrayInternals<T$1 extends SomeType = $ZodType> extends _$ZodTypeInternals {
+  def: $ZodArrayDef<T$1>;
+  isst: $ZodIssueInvalidType;
+  output: output<T$1>[];
+  input: input<T$1>[];
+}
+interface $ZodArray<T$1 extends SomeType = $ZodType> extends $ZodType<any, any, $ZodArrayInternals<T$1>> {}
+declare const $ZodArray: $constructor<$ZodArray>;
+type OptionalOutSchema = {
+  _zod: {
+    optout: "optional";
+  };
+};
+type OptionalInSchema = {
+  _zod: {
+    optin: "optional";
+  };
+};
+type $InferObjectOutput<T$1 extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T$1 ? IsAny<T$1[keyof T$1]> extends true ? Record<string, unknown> : Record<string, output<T$1[keyof T$1]>> : keyof (T$1 & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T$1 as T$1[k] extends OptionalOutSchema ? never : k]: T$1[k]["_zod"]["output"] } & { -readonly [k in keyof T$1 as T$1[k] extends OptionalOutSchema ? k : never]?: T$1[k]["_zod"]["output"] } & Extra>;
+type $InferObjectInput<T$1 extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T$1 ? IsAny<T$1[keyof T$1]> extends true ? Record<string, unknown> : Record<string, input<T$1[keyof T$1]>> : keyof (T$1 & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T$1 as T$1[k] extends OptionalInSchema ? never : k]: T$1[k]["_zod"]["input"] } & { -readonly [k in keyof T$1 as T$1[k] extends OptionalInSchema ? k : never]?: T$1[k]["_zod"]["input"] } & Extra>;
+type $ZodObjectConfig = {
+  out: Record<string, unknown>;
+  in: Record<string, unknown>;
+};
+type $loose = {
+  out: Record<string, unknown>;
+  in: Record<string, unknown>;
+};
+type $strict = {
+  out: {};
+  in: {};
+};
+type $strip = {
+  out: {};
+  in: {};
+};
+type $catchall<T$1 extends SomeType> = {
+  out: {
+    [k: string]: output<T$1>;
+  };
+  in: {
+    [k: string]: input<T$1>;
+  };
+};
+type $ZodShape = Readonly<{
+  [k: string]: $ZodType;
+}>;
+interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef {
+  type: "object";
+  shape: Shape;
+  catchall?: $ZodType | undefined;
+}
+interface $ZodObjectInternals< /** @ts-ignore Cast variance */
+out Shape extends $ZodShape = $ZodShape, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
+  def: $ZodObjectDef<Shape>;
+  config: Config;
+  isst: $ZodIssueInvalidType | $ZodIssueUnrecognizedKeys;
+  propValues: PropValues;
+  output: $InferObjectOutput<Shape, Config["out"]>;
+  input: $InferObjectInput<Shape, Config["in"]>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+type $ZodLooseShape = Record<string, any>;
+interface $ZodObject< /** @ts-ignore Cast variance */
+out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {
+  "~standard": $ZodStandardSchema<this>;
+}
+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;
+}
+type IsOptionalIn<T$1 extends SomeType> = T$1 extends OptionalInSchema ? true : false;
+type IsOptionalOut<T$1 extends SomeType> = T$1 extends OptionalOutSchema ? true : false;
+interface $ZodUnionInternals<T$1 extends readonly SomeType[] = readonly $ZodType[]> extends _$ZodTypeInternals {
+  def: $ZodUnionDef<T$1>;
+  isst: $ZodIssueInvalidUnion;
+  pattern: T$1[number]["_zod"]["pattern"];
+  values: T$1[number]["_zod"]["values"];
+  output: $InferUnionOutput<T$1[number]>;
+  input: $InferUnionInput<T$1[number]>;
+  optin: IsOptionalIn<T$1[number]> extends false ? "optional" | undefined : "optional";
+  optout: IsOptionalOut<T$1[number]> extends false ? "optional" | undefined : "optional";
+}
+interface $ZodUnion<T$1 extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodUnionInternals<T$1>> {
+  _zod: $ZodUnionInternals<T$1>;
+}
+declare const $ZodUnion: $constructor<$ZodUnion>;
+interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "intersection";
+  left: Left;
+  right: Right;
+}
+interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _$ZodTypeInternals {
+  def: $ZodIntersectionDef<A, B>;
+  isst: never;
+  optin: A["_zod"]["optin"] | B["_zod"]["optin"];
+  optout: A["_zod"]["optout"] | B["_zod"]["optout"];
+  output: output<A> & output<B>;
+  input: input<A> & input<B>;
+}
+interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodIntersectionInternals<A, B>;
+}
+declare const $ZodIntersection: $constructor<$ZodIntersection>;
+type $ZodRecordKey = $ZodType<string | number | symbol, string | number | symbol>;
+interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "record";
+  keyType: Key;
+  valueType: Value;
+}
+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>>;
+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>>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+type $partial = {
+  "~~partial": true;
+};
+interface $ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodRecordInternals<Key, Value>;
+}
+declare const $ZodRecord: $constructor<$ZodRecord>;
+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 {
+  type: "enum";
+  entries: T$1;
+}
+interface $ZodEnumInternals< /** @ts-ignore Cast variance */
+out T$1 extends EnumLike = EnumLike> extends $ZodTypeInternals<$InferEnumOutput<T$1>, $InferEnumInput<T$1>> {
+  def: $ZodEnumDef<T$1>;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  values: PrimitiveSet;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  isst: $ZodIssueInvalidValue;
+}
+interface $ZodEnum<T$1 extends EnumLike = EnumLike> extends $ZodType {
+  _zod: $ZodEnumInternals<T$1>;
+}
+declare const $ZodEnum: $constructor<$ZodEnum>;
+interface $ZodLiteralDef<T$1 extends Literal> extends $ZodTypeDef {
+  type: "literal";
+  values: T$1[];
+}
+interface $ZodLiteralInternals<T$1 extends Literal = Literal> extends $ZodTypeInternals<T$1, T$1> {
+  def: $ZodLiteralDef<T$1>;
+  values: Set<T$1>;
+  pattern: RegExp;
+  isst: $ZodIssueInvalidValue;
+}
+interface $ZodLiteral<T$1 extends Literal = Literal> extends $ZodType {
+  _zod: $ZodLiteralInternals<T$1>;
+}
+declare const $ZodLiteral: $constructor<$ZodLiteral>;
+interface $ZodTransformDef extends $ZodTypeDef {
+  type: "transform";
+  transform: (input: unknown, payload: ParsePayload<unknown>) => MaybeAsync<unknown>;
+}
+interface $ZodTransformInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I> {
+  def: $ZodTransformDef;
+  isst: never;
+}
+interface $ZodTransform<O = unknown, I = unknown> extends $ZodType {
+  _zod: $ZodTransformInternals<O, I>;
+}
+declare const $ZodTransform: $constructor<$ZodTransform>;
+interface $ZodOptionalDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "optional";
+  innerType: T$1;
+}
+interface $ZodOptionalInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<output<T$1> | undefined, input<T$1> | undefined> {
+  def: $ZodOptionalDef<T$1>;
+  optin: "optional";
+  optout: "optional";
+  isst: never;
+  values: T$1["_zod"]["values"];
+  pattern: T$1["_zod"]["pattern"];
+}
+interface $ZodOptional<T$1 extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodOptionalInternals<T$1>;
+}
+declare const $ZodOptional: $constructor<$ZodOptional>;
+interface $ZodNullableDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "nullable";
+  innerType: T$1;
+}
+interface $ZodNullableInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<output<T$1> | null, input<T$1> | null> {
+  def: $ZodNullableDef<T$1>;
+  optin: T$1["_zod"]["optin"];
+  optout: T$1["_zod"]["optout"];
+  isst: never;
+  values: T$1["_zod"]["values"];
+  pattern: T$1["_zod"]["pattern"];
+}
+interface $ZodNullable<T$1 extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodNullableInternals<T$1>;
+}
+declare const $ZodNullable: $constructor<$ZodNullable>;
+interface $ZodDefaultDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "default";
+  innerType: T$1;
+  /** The default value. May be a getter. */
+  defaultValue: NoUndefined<output<T$1>>;
+}
+interface $ZodDefaultInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T$1>>, input<T$1> | undefined> {
+  def: $ZodDefaultDef<T$1>;
+  optin: "optional";
+  optout?: "optional" | undefined;
+  isst: never;
+  values: T$1["_zod"]["values"];
+}
+interface $ZodDefault<T$1 extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodDefaultInternals<T$1>;
+}
+declare const $ZodDefault: $constructor<$ZodDefault>;
+interface $ZodPrefaultDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "prefault";
+  innerType: T$1;
+  /** The default value. May be a getter. */
+  defaultValue: input<T$1>;
+}
+interface $ZodPrefaultInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T$1>>, input<T$1> | undefined> {
+  def: $ZodPrefaultDef<T$1>;
+  optin: "optional";
+  optout?: "optional" | undefined;
+  isst: never;
+  values: T$1["_zod"]["values"];
+}
+interface $ZodPrefault<T$1 extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodPrefaultInternals<T$1>;
+}
+declare const $ZodPrefault: $constructor<$ZodPrefault>;
+interface $ZodNonOptionalDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "nonoptional";
+  innerType: T$1;
+}
+interface $ZodNonOptionalInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T$1>>, NoUndefined<input<T$1>>> {
+  def: $ZodNonOptionalDef<T$1>;
+  isst: $ZodIssueInvalidType;
+  values: T$1["_zod"]["values"];
+  optin: "optional" | undefined;
+  optout: "optional" | undefined;
+}
+interface $ZodNonOptional<T$1 extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodNonOptionalInternals<T$1>;
+}
+declare const $ZodNonOptional: $constructor<$ZodNonOptional>;
+interface $ZodCatchCtx extends ParsePayload {
+  /** @deprecated Use `ctx.issues` */
+  error: {
+    issues: $ZodIssue[];
+  };
+  /** @deprecated Use `ctx.value` */
+  input: unknown;
+}
+interface $ZodCatchDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "catch";
+  innerType: T$1;
+  catchValue: (ctx: $ZodCatchCtx) => unknown;
+}
+interface $ZodCatchInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<output<T$1>, input<T$1>> {
+  def: $ZodCatchDef<T$1>;
+  optin: T$1["_zod"]["optin"];
+  optout: T$1["_zod"]["optout"];
+  isst: never;
+  values: T$1["_zod"]["values"];
+}
+interface $ZodCatch<T$1 extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodCatchInternals<T$1>;
+}
+declare const $ZodCatch: $constructor<$ZodCatch>;
+interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "pipe";
+  in: A;
+  out: B;
+  /** Only defined inside $ZodCodec instances. */
+  transform?: (value: output<A>, payload: ParsePayload<output<A>>) => MaybeAsync<input<B>>;
+  /** Only defined inside $ZodCodec instances. */
+  reverseTransform?: (value: input<B>, payload: ParsePayload<input<B>>) => MaybeAsync<output<A>>;
+}
+interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output<B>, input<A>> {
+  def: $ZodPipeDef<A, B>;
+  isst: never;
+  values: A["_zod"]["values"];
+  optin: A["_zod"]["optin"];
+  optout: B["_zod"]["optout"];
+  propValues: A["_zod"]["propValues"];
+}
+interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodPipeInternals<A, B>;
+}
+declare const $ZodPipe: $constructor<$ZodPipe>;
+interface $ZodReadonlyDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "readonly";
+  innerType: T$1;
+}
+interface $ZodReadonlyInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<MakeReadonly<output<T$1>>, MakeReadonly<input<T$1>>> {
+  def: $ZodReadonlyDef<T$1>;
+  optin: T$1["_zod"]["optin"];
+  optout: T$1["_zod"]["optout"];
+  isst: never;
+  propValues: T$1["_zod"]["propValues"];
+  values: T$1["_zod"]["values"];
+}
+interface $ZodReadonly<T$1 extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodReadonlyInternals<T$1>;
+}
+declare const $ZodReadonly: $constructor<$ZodReadonly>;
+interface $ZodCustomDef<O = unknown> extends $ZodTypeDef, $ZodCheckDef {
+  type: "custom";
+  check: "custom";
+  path?: PropertyKey[] | undefined;
+  error?: $ZodErrorMap | undefined;
+  params?: Record<string, any> | undefined;
+  fn: (arg: O) => unknown;
+}
+interface $ZodCustomInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I>, $ZodCheckInternals<O> {
+  def: $ZodCustomDef;
+  issc: $ZodIssue;
+  isst: never;
+  bag: LoosePartial<{
+    Class: typeof Class;
+  }>;
+}
+interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
+  _zod: $ZodCustomInternals<O, I>;
+}
+declare const $ZodCustom: $constructor<$ZodCustom>;
 //#endregion
-export { Conversation, ConversationSeen };
+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 };
 //# sourceMappingURL=schemas.d.ts.map