@orq-ai/node 4.1.0-rc.3 → 4.1.0-rc.5

package/src/models/operations/createagentresponserequest.ts

@@ -7,6 +7,7 @@ import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
@@ -36,92 +37,13 @@ export type RoleUserMessage = ClosedEnum<typeof RoleUserMessage>;
  */
 export type CreateAgentResponseRequestRole = RoleUserMessage | RoleToolMessage;
 
-export const CreateAgentResponseRequestPublicMessagePartKind = {
-  ToolResult: "tool_result",
-} as const;
-export type CreateAgentResponseRequestPublicMessagePartKind = ClosedEnum<
-  typeof CreateAgentResponseRequestPublicMessagePartKind
->;
-
-/**
- * Tool execution result part. Use this ONLY when providing results for a pending tool call from the agent. The tool_call_id must match the ID from the agent's tool call request.
- */
-export type ToolResultPart = {
-  kind: CreateAgentResponseRequestPublicMessagePartKind;
-  toolCallId: string;
-  result?: any | undefined;
-  metadata?: { [k: string]: any } | undefined;
-};
-
-export const PublicMessagePartKind = {
-  File: "file",
-} as const;
-export type PublicMessagePartKind = ClosedEnum<typeof PublicMessagePartKind>;
-
-/**
- * File in URI format. Check in the model's documentation for the supported mime types for the URI format
- */
-export type FileInURIFormat = {
-  /**
-   * URL for the File content
-   */
-  uri: string;
-  /**
-   * Optional mimeType for the file
-   */
-  mimeType?: string | undefined;
-  /**
-   * Optional name for the file
-   */
-  name?: string | undefined;
-};
-
-/**
- * Binary in base64 format. Check in the model's documentation for the supported mime types for the binary format.
- */
-export type BinaryFormat = {
-  /**
-   * base64 encoded content of the file
-   */
-  bytes: string;
-  /**
-   * Optional mimeType for the file
-   */
-  mimeType?: string | undefined;
-  /**
-   * Optional name for the file
-   */
-  name?: string | undefined;
-};
-
-export type PublicMessagePartFile = BinaryFormat | FileInURIFormat;
-
-/**
- * File attachment part. Use this to send files (images, documents, etc.) to the agent for processing.
- */
-export type FilePart = {
-  kind: PublicMessagePartKind;
-  file: BinaryFormat | FileInURIFormat;
-  metadata?: { [k: string]: any } | undefined;
-};
-
-export const Kind = {
-  Text: "text",
-} as const;
-export type Kind = ClosedEnum<typeof Kind>;
-
-/**
- * Text content part. Use this to send text messages to the agent.
- */
-export type TextPart = {
-  kind: Kind;
-  text: string;
-};
-
 /**
  * Message part that can be provided by users. Use "text" for regular messages, "file" for attachments, or "tool_result" when responding to tool call requests.
  */
-export type PublicMessagePart = TextPart | FilePart | ToolResultPart;
+export type PublicMessagePart =
+  | components.TextPart
+  | components.FilePart
+  | components.ToolResultPart;
 
 /**
  * The A2A message to send to the agent (user input or tool results)
@@ -138,7 +60,9 @@ export type A2AMessage = {
   /**
    * A2A message parts (text, file, or tool_result only)
    */
-  parts: Array<TextPart | FilePart | ToolResultPart>;
+  parts: Array<
+    components.TextPart | components.FilePart | components.ToolResultPart
+  >;
 };
 
 /**
@@ -248,10 +172,23 @@ export type CreateAgentResponseRequestAgentsResponsesRole = ClosedEnum<
   typeof CreateAgentResponseRequestAgentsResponsesRole
 >;
 
+export type Parts =
+  | (components.ToolCallPart & { kind: "tool_call" })
+  | (components.TextPart & { kind: "text" })
+  | (components.DataPart & { kind: "data" })
+  | (components.FilePart & { kind: "file" })
+  | (components.ToolResultPart & { kind: "tool_result" });
+
 export type Output = {
   messageId: string;
   role: CreateAgentResponseRequestAgentsResponsesRole;
-  parts: Array<any>;
+  parts: Array<
+    | (components.ToolCallPart & { kind: "tool_call" })
+    | (components.TextPart & { kind: "text" })
+    | (components.DataPart & { kind: "data" })
+    | (components.FilePart & { kind: "file" })
+    | (components.ToolResultPart & { kind: "tool_result" })
+  >;
   metadata?: { [k: string]: any } | undefined;
 };
 
@@ -376,309 +313,21 @@ export function createAgentResponseRequestRoleFromJSON(
   );
 }
 
-/** @internal */
-export const CreateAgentResponseRequestPublicMessagePartKind$inboundSchema:
-  z.ZodNativeEnum<typeof CreateAgentResponseRequestPublicMessagePartKind> = z
-    .nativeEnum(CreateAgentResponseRequestPublicMessagePartKind);
-/** @internal */
-export const CreateAgentResponseRequestPublicMessagePartKind$outboundSchema:
-  z.ZodNativeEnum<typeof CreateAgentResponseRequestPublicMessagePartKind> =
-    CreateAgentResponseRequestPublicMessagePartKind$inboundSchema;
-
-/** @internal */
-export const ToolResultPart$inboundSchema: z.ZodType<
-  ToolResultPart,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  kind: CreateAgentResponseRequestPublicMessagePartKind$inboundSchema,
-  tool_call_id: z.string(),
-  result: z.any().optional(),
-  metadata: z.record(z.any()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "tool_call_id": "toolCallId",
-  });
-});
-/** @internal */
-export type ToolResultPart$Outbound = {
-  kind: string;
-  tool_call_id: string;
-  result?: any | undefined;
-  metadata?: { [k: string]: any } | undefined;
-};
-
-/** @internal */
-export const ToolResultPart$outboundSchema: z.ZodType<
-  ToolResultPart$Outbound,
-  z.ZodTypeDef,
-  ToolResultPart
-> = z.object({
-  kind: CreateAgentResponseRequestPublicMessagePartKind$outboundSchema,
-  toolCallId: z.string(),
-  result: z.any().optional(),
-  metadata: z.record(z.any()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    toolCallId: "tool_call_id",
-  });
-});
-
-export function toolResultPartToJSON(toolResultPart: ToolResultPart): string {
-  return JSON.stringify(ToolResultPart$outboundSchema.parse(toolResultPart));
-}
-export function toolResultPartFromJSON(
-  jsonString: string,
-): SafeParseResult<ToolResultPart, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ToolResultPart$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ToolResultPart' from JSON`,
-  );
-}
-
-/** @internal */
-export const PublicMessagePartKind$inboundSchema: z.ZodNativeEnum<
-  typeof PublicMessagePartKind
-> = z.nativeEnum(PublicMessagePartKind);
-/** @internal */
-export const PublicMessagePartKind$outboundSchema: z.ZodNativeEnum<
-  typeof PublicMessagePartKind
-> = PublicMessagePartKind$inboundSchema;
-
-/** @internal */
-export const FileInURIFormat$inboundSchema: z.ZodType<
-  FileInURIFormat,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  uri: z.string(),
-  mimeType: z.string().optional(),
-  name: z.string().optional(),
-});
-/** @internal */
-export type FileInURIFormat$Outbound = {
-  uri: string;
-  mimeType?: string | undefined;
-  name?: string | undefined;
-};
-
-/** @internal */
-export const FileInURIFormat$outboundSchema: z.ZodType<
-  FileInURIFormat$Outbound,
-  z.ZodTypeDef,
-  FileInURIFormat
-> = z.object({
-  uri: z.string(),
-  mimeType: z.string().optional(),
-  name: z.string().optional(),
-});
-
-export function fileInURIFormatToJSON(
-  fileInURIFormat: FileInURIFormat,
-): string {
-  return JSON.stringify(FileInURIFormat$outboundSchema.parse(fileInURIFormat));
-}
-export function fileInURIFormatFromJSON(
-  jsonString: string,
-): SafeParseResult<FileInURIFormat, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => FileInURIFormat$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FileInURIFormat' from JSON`,
-  );
-}
-
-/** @internal */
-export const BinaryFormat$inboundSchema: z.ZodType<
-  BinaryFormat,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  bytes: z.string(),
-  mimeType: z.string().optional(),
-  name: z.string().optional(),
-});
-/** @internal */
-export type BinaryFormat$Outbound = {
-  bytes: string;
-  mimeType?: string | undefined;
-  name?: string | undefined;
-};
-
-/** @internal */
-export const BinaryFormat$outboundSchema: z.ZodType<
-  BinaryFormat$Outbound,
-  z.ZodTypeDef,
-  BinaryFormat
-> = z.object({
-  bytes: z.string(),
-  mimeType: z.string().optional(),
-  name: z.string().optional(),
-});
-
-export function binaryFormatToJSON(binaryFormat: BinaryFormat): string {
-  return JSON.stringify(BinaryFormat$outboundSchema.parse(binaryFormat));
-}
-export function binaryFormatFromJSON(
-  jsonString: string,
-): SafeParseResult<BinaryFormat, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => BinaryFormat$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'BinaryFormat' from JSON`,
-  );
-}
-
-/** @internal */
-export const PublicMessagePartFile$inboundSchema: z.ZodType<
-  PublicMessagePartFile,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() => BinaryFormat$inboundSchema),
-  z.lazy(() => FileInURIFormat$inboundSchema),
-]);
-/** @internal */
-export type PublicMessagePartFile$Outbound =
-  | BinaryFormat$Outbound
-  | FileInURIFormat$Outbound;
-
-/** @internal */
-export const PublicMessagePartFile$outboundSchema: z.ZodType<
-  PublicMessagePartFile$Outbound,
-  z.ZodTypeDef,
-  PublicMessagePartFile
-> = z.union([
-  z.lazy(() => BinaryFormat$outboundSchema),
-  z.lazy(() => FileInURIFormat$outboundSchema),
-]);
-
-export function publicMessagePartFileToJSON(
-  publicMessagePartFile: PublicMessagePartFile,
-): string {
-  return JSON.stringify(
-    PublicMessagePartFile$outboundSchema.parse(publicMessagePartFile),
-  );
-}
-export function publicMessagePartFileFromJSON(
-  jsonString: string,
-): SafeParseResult<PublicMessagePartFile, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => PublicMessagePartFile$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PublicMessagePartFile' from JSON`,
-  );
-}
-
-/** @internal */
-export const FilePart$inboundSchema: z.ZodType<
-  FilePart,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  kind: PublicMessagePartKind$inboundSchema,
-  file: z.union([
-    z.lazy(() => BinaryFormat$inboundSchema),
-    z.lazy(() => FileInURIFormat$inboundSchema),
-  ]),
-  metadata: z.record(z.any()).optional(),
-});
-/** @internal */
-export type FilePart$Outbound = {
-  kind: string;
-  file: BinaryFormat$Outbound | FileInURIFormat$Outbound;
-  metadata?: { [k: string]: any } | undefined;
-};
-
-/** @internal */
-export const FilePart$outboundSchema: z.ZodType<
-  FilePart$Outbound,
-  z.ZodTypeDef,
-  FilePart
-> = z.object({
-  kind: PublicMessagePartKind$outboundSchema,
-  file: z.union([
-    z.lazy(() => BinaryFormat$outboundSchema),
-    z.lazy(() => FileInURIFormat$outboundSchema),
-  ]),
-  metadata: z.record(z.any()).optional(),
-});
-
-export function filePartToJSON(filePart: FilePart): string {
-  return JSON.stringify(FilePart$outboundSchema.parse(filePart));
-}
-export function filePartFromJSON(
-  jsonString: string,
-): SafeParseResult<FilePart, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => FilePart$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FilePart' from JSON`,
-  );
-}
-
-/** @internal */
-export const Kind$inboundSchema: z.ZodNativeEnum<typeof Kind> = z.nativeEnum(
-  Kind,
-);
-/** @internal */
-export const Kind$outboundSchema: z.ZodNativeEnum<typeof Kind> =
-  Kind$inboundSchema;
-
-/** @internal */
-export const TextPart$inboundSchema: z.ZodType<
-  TextPart,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  kind: Kind$inboundSchema,
-  text: z.string(),
-});
-/** @internal */
-export type TextPart$Outbound = {
-  kind: string;
-  text: string;
-};
-
-/** @internal */
-export const TextPart$outboundSchema: z.ZodType<
-  TextPart$Outbound,
-  z.ZodTypeDef,
-  TextPart
-> = z.object({
-  kind: Kind$outboundSchema,
-  text: z.string(),
-});
-
-export function textPartToJSON(textPart: TextPart): string {
-  return JSON.stringify(TextPart$outboundSchema.parse(textPart));
-}
-export function textPartFromJSON(
-  jsonString: string,
-): SafeParseResult<TextPart, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => TextPart$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'TextPart' from JSON`,
-  );
-}
-
 /** @internal */
 export const PublicMessagePart$inboundSchema: z.ZodType<
   PublicMessagePart,
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => TextPart$inboundSchema),
-  z.lazy(() => FilePart$inboundSchema),
-  z.lazy(() => ToolResultPart$inboundSchema),
+  components.TextPart$inboundSchema,
+  components.FilePart$inboundSchema,
+  components.ToolResultPart$inboundSchema,
 ]);
 /** @internal */
 export type PublicMessagePart$Outbound =
-  | TextPart$Outbound
-  | FilePart$Outbound
-  | ToolResultPart$Outbound;
+  | components.TextPart$Outbound
+  | components.FilePart$Outbound
+  | components.ToolResultPart$Outbound;
 
 /** @internal */
 export const PublicMessagePart$outboundSchema: z.ZodType<
@@ -686,9 +335,9 @@ export const PublicMessagePart$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   PublicMessagePart
 > = z.union([
-  z.lazy(() => TextPart$outboundSchema),
-  z.lazy(() => FilePart$outboundSchema),
-  z.lazy(() => ToolResultPart$outboundSchema),
+  components.TextPart$outboundSchema,
+  components.FilePart$outboundSchema,
+  components.ToolResultPart$outboundSchema,
 ]);
 
 export function publicMessagePartToJSON(
@@ -718,9 +367,9 @@ export const A2AMessage$inboundSchema: z.ZodType<
   role: z.union([RoleUserMessage$inboundSchema, RoleToolMessage$inboundSchema]),
   parts: z.array(
     z.union([
-      z.lazy(() => TextPart$inboundSchema),
-      z.lazy(() => FilePart$inboundSchema),
-      z.lazy(() => ToolResultPart$inboundSchema),
+      components.TextPart$inboundSchema,
+      components.FilePart$inboundSchema,
+      components.ToolResultPart$inboundSchema,
     ]),
   ),
 });
@@ -728,7 +377,11 @@ export const A2AMessage$inboundSchema: z.ZodType<
 export type A2AMessage$Outbound = {
   messageId?: string | undefined;
   role: string | string;
-  parts: Array<TextPart$Outbound | FilePart$Outbound | ToolResultPart$Outbound>;
+  parts: Array<
+    | components.TextPart$Outbound
+    | components.FilePart$Outbound
+    | components.ToolResultPart$Outbound
+  >;
 };
 
 /** @internal */
@@ -744,9 +397,9 @@ export const A2AMessage$outboundSchema: z.ZodType<
   ]),
   parts: z.array(
     z.union([
-      z.lazy(() => TextPart$outboundSchema),
-      z.lazy(() => FilePart$outboundSchema),
-      z.lazy(() => ToolResultPart$outboundSchema),
+      components.TextPart$outboundSchema,
+      components.FilePart$outboundSchema,
+      components.ToolResultPart$outboundSchema,
     ]),
   ),
 });
@@ -1045,19 +698,130 @@ export const CreateAgentResponseRequestAgentsResponsesRole$outboundSchema:
   z.ZodNativeEnum<typeof CreateAgentResponseRequestAgentsResponsesRole> =
     CreateAgentResponseRequestAgentsResponsesRole$inboundSchema;
 
+/** @internal */
+export const Parts$inboundSchema: z.ZodType<Parts, z.ZodTypeDef, unknown> = z
+  .union([
+    components.ToolCallPart$inboundSchema.and(
+      z.object({ kind: z.literal("tool_call") }).transform((v) => ({
+        kind: v.kind,
+      })),
+    ),
+    components.TextPart$inboundSchema.and(
+      z.object({ kind: z.literal("text") }).transform((v) => ({
+        kind: v.kind,
+      })),
+    ),
+    components.DataPart$inboundSchema.and(
+      z.object({ kind: z.literal("data") }).transform((v) => ({
+        kind: v.kind,
+      })),
+    ),
+    components.FilePart$inboundSchema.and(
+      z.object({ kind: z.literal("file") }).transform((v) => ({
+        kind: v.kind,
+      })),
+    ),
+    components.ToolResultPart$inboundSchema.and(
+      z.object({ kind: z.literal("tool_result") }).transform((v) => ({
+        kind: v.kind,
+      })),
+    ),
+  ]);
+/** @internal */
+export type Parts$Outbound =
+  | (components.ToolCallPart$Outbound & { kind: "tool_call" })
+  | (components.TextPart$Outbound & { kind: "text" })
+  | (components.DataPart$Outbound & { kind: "data" })
+  | (components.FilePart$Outbound & { kind: "file" })
+  | (components.ToolResultPart$Outbound & { kind: "tool_result" });
+
+/** @internal */
+export const Parts$outboundSchema: z.ZodType<
+  Parts$Outbound,
+  z.ZodTypeDef,
+  Parts
+> = z.union([
+  components.ToolCallPart$outboundSchema.and(
+    z.object({ kind: z.literal("tool_call") }).transform((v) => ({
+      kind: v.kind,
+    })),
+  ),
+  components.TextPart$outboundSchema.and(
+    z.object({ kind: z.literal("text") }).transform((v) => ({ kind: v.kind })),
+  ),
+  components.DataPart$outboundSchema.and(
+    z.object({ kind: z.literal("data") }).transform((v) => ({ kind: v.kind })),
+  ),
+  components.FilePart$outboundSchema.and(
+    z.object({ kind: z.literal("file") }).transform((v) => ({ kind: v.kind })),
+  ),
+  components.ToolResultPart$outboundSchema.and(
+    z.object({ kind: z.literal("tool_result") }).transform((v) => ({
+      kind: v.kind,
+    })),
+  ),
+]);
+
+export function partsToJSON(parts: Parts): string {
+  return JSON.stringify(Parts$outboundSchema.parse(parts));
+}
+export function partsFromJSON(
+  jsonString: string,
+): SafeParseResult<Parts, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Parts$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Parts' from JSON`,
+  );
+}
+
 /** @internal */
 export const Output$inboundSchema: z.ZodType<Output, z.ZodTypeDef, unknown> = z
   .object({
     messageId: z.string(),
     role: CreateAgentResponseRequestAgentsResponsesRole$inboundSchema,
-    parts: z.array(z.any()),
+    parts: z.array(
+      z.union([
+        components.ToolCallPart$inboundSchema.and(
+          z.object({ kind: z.literal("tool_call") }).transform((v) => ({
+            kind: v.kind,
+          })),
+        ),
+        components.TextPart$inboundSchema.and(
+          z.object({ kind: z.literal("text") }).transform((v) => ({
+            kind: v.kind,
+          })),
+        ),
+        components.DataPart$inboundSchema.and(
+          z.object({ kind: z.literal("data") }).transform((v) => ({
+            kind: v.kind,
+          })),
+        ),
+        components.FilePart$inboundSchema.and(
+          z.object({ kind: z.literal("file") }).transform((v) => ({
+            kind: v.kind,
+          })),
+        ),
+        components.ToolResultPart$inboundSchema.and(
+          z.object({ kind: z.literal("tool_result") }).transform((v) => ({
+            kind: v.kind,
+          })),
+        ),
+      ]),
+    ),
     metadata: z.record(z.any()).optional(),
   });
 /** @internal */
 export type Output$Outbound = {
   messageId: string;
   role: string;
-  parts: Array<any>;
+  parts: Array<
+    | (components.ToolCallPart$Outbound & { kind: "tool_call" })
+    | (components.TextPart$Outbound & { kind: "text" })
+    | (components.DataPart$Outbound & { kind: "data" })
+    | (components.FilePart$Outbound & { kind: "file" })
+    | (components.ToolResultPart$Outbound & { kind: "tool_result" })
+  >;
   metadata?: { [k: string]: any } | undefined;
 };
 
@@ -1069,7 +833,35 @@ export const Output$outboundSchema: z.ZodType<
 > = z.object({
   messageId: z.string(),
   role: CreateAgentResponseRequestAgentsResponsesRole$outboundSchema,
-  parts: z.array(z.any()),
+  parts: z.array(
+    z.union([
+      components.ToolCallPart$outboundSchema.and(
+        z.object({ kind: z.literal("tool_call") }).transform((v) => ({
+          kind: v.kind,
+        })),
+      ),
+      components.TextPart$outboundSchema.and(
+        z.object({ kind: z.literal("text") }).transform((v) => ({
+          kind: v.kind,
+        })),
+      ),
+      components.DataPart$outboundSchema.and(
+        z.object({ kind: z.literal("data") }).transform((v) => ({
+          kind: v.kind,
+        })),
+      ),
+      components.FilePart$outboundSchema.and(
+        z.object({ kind: z.literal("file") }).transform((v) => ({
+          kind: v.kind,
+        })),
+      ),
+      components.ToolResultPart$outboundSchema.and(
+        z.object({ kind: z.literal("tool_result") }).transform((v) => ({
+          kind: v.kind,
+        })),
+      ),
+    ]),
+  ),
   metadata: z.record(z.any()).optional(),
 });
 

package/src/models/operations/createbudget.ts

@@ -516,7 +516,7 @@ export const CreateBudgetResponseBody$inboundSchema: z.ZodType<
   created: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   updated: z.string().datetime({ offset: true }).default(
-    "2025-11-25T09:21:48.673Z",
+    "2025-11-25T16:34:40.403Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {
@@ -553,7 +553,7 @@ export const CreateBudgetResponseBody$outboundSchema: z.ZodType<
   isActive: z.boolean(),
   consumption: z.lazy(() => Consumption$outboundSchema).optional(),
   created: z.date().transform(v => v.toISOString()).optional(),
-  updated: z.date().default(() => new Date("2025-11-25T09:21:48.673Z"))
+  updated: z.date().default(() => new Date("2025-11-25T16:34:40.403Z"))
     .transform(v => v.toISOString()),
 }).transform((v) => {
   return remap$(v, {

package/src/models/operations/createcontact.ts

@@ -167,7 +167,7 @@ export const CreateContactResponseBody$inboundSchema: z.ZodType<
   created: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   updated: z.string().datetime({ offset: true }).default(
-    "2025-11-25T09:21:47.602Z",
+    "2025-11-25T16:34:40.058Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {
@@ -207,7 +207,7 @@ export const CreateContactResponseBody$outboundSchema: z.ZodType<
   tags: z.array(z.string()).optional(),
   metadata: z.record(z.any()).optional(),
   created: z.date().transform(v => v.toISOString()).optional(),
-  updated: z.date().default(() => new Date("2025-11-25T09:21:47.602Z"))
+  updated: z.date().default(() => new Date("2025-11-25T16:34:40.058Z"))
     .transform(v => v.toISOString()),
 }).transform((v) => {
   return remap$(v, {