@orq-ai/node 4.2.0-rc.52 → 4.2.0-rc.54

package/src/models/components/conversationwithmessagesresponse.ts

@@ -155,7 +155,7 @@ export const ConversationWithMessagesResponse$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("conv_01kfe1mwtfv3ahttgsafq4036f"),
+  _id: z.string().default("conv_01kfg037989m13dewbgt6gzfvx"),
   kind: ConversationWithMessagesResponseKind$inboundSchema,
   displayName: z.string(),
   createdAt: z.number(),
@@ -189,7 +189,7 @@ export const ConversationWithMessagesResponse$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ConversationWithMessagesResponse
 > = z.object({
-  id: z.string().default("conv_01kfe1mwtfv3ahttgsafq4036f"),
+  id: z.string().default("conv_01kfg037989m13dewbgt6gzfvx"),
   kind: ConversationWithMessagesResponseKind$outboundSchema,
   displayName: z.string(),
   createdAt: z.number(),

package/src/models/components/createagentresponse.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v3";
 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 { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -53,6 +54,41 @@ export type Usage = {
   completionTokensDetails?: CompletionTokensDetails | null | undefined;
 };
 
+/**
+ * The reason why the agent stopped generating
+ */
+export const FinishReason = {
+  Stop: "stop",
+  Length: "length",
+  ToolCalls: "tool_calls",
+  ContentFilter: "content_filter",
+  FunctionCall: "function_call",
+  MaxIterations: "max_iterations",
+  MaxTime: "max_time",
+} as const;
+/**
+ * The reason why the agent stopped generating
+ */
+export type FinishReason = ClosedEnum<typeof FinishReason>;
+
+export const CreateAgentResponseType = {
+  Function: "function",
+} as const;
+export type CreateAgentResponseType = ClosedEnum<
+  typeof CreateAgentResponseType
+>;
+
+export type FunctionT = {
+  name?: string | undefined;
+  arguments?: string | undefined;
+};
+
+export type PendingToolCalls = {
+  id: string;
+  type: CreateAgentResponseType;
+  function: FunctionT;
+};
+
 /**
  * Response type from the create-response endpoint.
  */
@@ -81,6 +117,14 @@ export type CreateAgentResponse = {
    * Token usage from the agent execution
    */
   usage?: Usage | null | undefined;
+  /**
+   * The reason why the agent stopped generating
+   */
+  finishReason?: FinishReason | undefined;
+  /**
+   * Tool calls awaiting user response (when finish_reason is function_call)
+   */
+  pendingToolCalls?: Array<PendingToolCalls> | undefined;
 };
 
 /** @internal */
@@ -273,6 +317,105 @@ export function usageFromJSON(
   );
 }
 
+/** @internal */
+export const FinishReason$inboundSchema: z.ZodNativeEnum<typeof FinishReason> =
+  z.nativeEnum(FinishReason);
+/** @internal */
+export const FinishReason$outboundSchema: z.ZodNativeEnum<typeof FinishReason> =
+  FinishReason$inboundSchema;
+
+/** @internal */
+export const CreateAgentResponseType$inboundSchema: z.ZodNativeEnum<
+  typeof CreateAgentResponseType
+> = z.nativeEnum(CreateAgentResponseType);
+/** @internal */
+export const CreateAgentResponseType$outboundSchema: z.ZodNativeEnum<
+  typeof CreateAgentResponseType
+> = CreateAgentResponseType$inboundSchema;
+
+/** @internal */
+export const FunctionT$inboundSchema: z.ZodType<
+  FunctionT,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  arguments: z.string().optional(),
+});
+/** @internal */
+export type FunctionT$Outbound = {
+  name?: string | undefined;
+  arguments?: string | undefined;
+};
+
+/** @internal */
+export const FunctionT$outboundSchema: z.ZodType<
+  FunctionT$Outbound,
+  z.ZodTypeDef,
+  FunctionT
+> = z.object({
+  name: z.string().optional(),
+  arguments: z.string().optional(),
+});
+
+export function functionToJSON(functionT: FunctionT): string {
+  return JSON.stringify(FunctionT$outboundSchema.parse(functionT));
+}
+export function functionFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionT, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionT' from JSON`,
+  );
+}
+
+/** @internal */
+export const PendingToolCalls$inboundSchema: z.ZodType<
+  PendingToolCalls,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  type: CreateAgentResponseType$inboundSchema,
+  function: z.lazy(() => FunctionT$inboundSchema),
+});
+/** @internal */
+export type PendingToolCalls$Outbound = {
+  id: string;
+  type: string;
+  function: FunctionT$Outbound;
+};
+
+/** @internal */
+export const PendingToolCalls$outboundSchema: z.ZodType<
+  PendingToolCalls$Outbound,
+  z.ZodTypeDef,
+  PendingToolCalls
+> = z.object({
+  id: z.string(),
+  type: CreateAgentResponseType$outboundSchema,
+  function: z.lazy(() => FunctionT$outboundSchema),
+});
+
+export function pendingToolCallsToJSON(
+  pendingToolCalls: PendingToolCalls,
+): string {
+  return JSON.stringify(
+    PendingToolCalls$outboundSchema.parse(pendingToolCalls),
+  );
+}
+export function pendingToolCallsFromJSON(
+  jsonString: string,
+): SafeParseResult<PendingToolCalls, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PendingToolCalls$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PendingToolCalls' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateAgentResponse$inboundSchema: z.ZodType<
   CreateAgentResponse,
@@ -285,11 +428,16 @@ export const CreateAgentResponse$inboundSchema: z.ZodType<
   created_at: z.string(),
   model: z.string(),
   usage: z.nullable(z.lazy(() => Usage$inboundSchema)).optional(),
+  finish_reason: FinishReason$inboundSchema.optional(),
+  pending_tool_calls: z.array(z.lazy(() => PendingToolCalls$inboundSchema))
+    .optional(),
 }).transform((v) => {
   return remap$(v, {
     "_id": "id",
     "task_id": "taskId",
     "created_at": "createdAt",
+    "finish_reason": "finishReason",
+    "pending_tool_calls": "pendingToolCalls",
   });
 });
 /** @internal */
@@ -300,6 +448,8 @@ export type CreateAgentResponse$Outbound = {
   created_at: string;
   model: string;
   usage?: Usage$Outbound | null | undefined;
+  finish_reason?: string | undefined;
+  pending_tool_calls?: Array<PendingToolCalls$Outbound> | undefined;
 };
 
 /** @internal */
@@ -314,11 +464,16 @@ export const CreateAgentResponse$outboundSchema: z.ZodType<
   createdAt: z.string(),
   model: z.string(),
   usage: z.nullable(z.lazy(() => Usage$outboundSchema)).optional(),
+  finishReason: FinishReason$outboundSchema.optional(),
+  pendingToolCalls: z.array(z.lazy(() => PendingToolCalls$outboundSchema))
+    .optional(),
 }).transform((v) => {
   return remap$(v, {
     id: "_id",
     taskId: "task_id",
     createdAt: "created_at",
+    finishReason: "finish_reason",
+    pendingToolCalls: "pending_tool_calls",
   });
 });
 

package/src/models/components/partdoneevent.ts

@@ -79,7 +79,7 @@ export const PartReasoningPart$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("reasoning_01kfe1mwg7gpfcshwwfnnbpexj"),
+  _id: z.string().default("reasoning_01kfg036xgkrepbh43thtavq3f"),
   metadata: z.record(z.any()).optional(),
   kind: PartKind$inboundSchema,
   reasoning: z.string(),
@@ -104,7 +104,7 @@ export const PartReasoningPart$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   PartReasoningPart
 > = z.object({
-  id: z.string().default("reasoning_01kfe1mwg7gpfcshwwfnnbpexj"),
+  id: z.string().default("reasoning_01kfg036xgkrepbh43thtavq3f"),
   metadata: z.record(z.any()).optional(),
   kind: PartKind$outboundSchema,
   reasoning: z.string(),

package/src/models/components/reasoningpart.ts

@@ -40,7 +40,7 @@ export const ReasoningPart$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("reasoning_01kfe1mwg0n394524n5jxgv5hb"),
+  _id: z.string().default("reasoning_01kfg036x3m6xskhdmjrkz2jjg"),
   metadata: z.record(z.any()).optional(),
   kind: z.literal("reasoning"),
   reasoning: z.string(),
@@ -65,7 +65,7 @@ export const ReasoningPart$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ReasoningPart
 > = z.object({
-  id: z.string().default("reasoning_01kfe1mwg0n394524n5jxgv5hb"),
+  id: z.string().default("reasoning_01kfg036x3m6xskhdmjrkz2jjg"),
   metadata: z.record(z.any()).optional(),
   kind: z.literal("reasoning"),
   reasoning: z.string(),

package/src/models/components/responsedoneevent.ts

@@ -12,7 +12,7 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 /**
  * The reason why the agent stopped generating
  */
-export const FinishReason = {
+export const ResponseDoneEventFinishReason = {
   Stop: "stop",
   Length: "length",
   ToolCalls: "tool_calls",
@@ -24,7 +24,9 @@ export const FinishReason = {
 /**
  * The reason why the agent stopped generating
  */
-export type FinishReason = ClosedEnum<typeof FinishReason>;
+export type ResponseDoneEventFinishReason = ClosedEnum<
+  typeof ResponseDoneEventFinishReason
+>;
 
 export type ResponseDoneEventPromptTokensDetails = {
   cachedTokens?: number | null | undefined;
@@ -75,7 +77,7 @@ export type ResponseDoneEventDataType = ClosedEnum<
   typeof ResponseDoneEventDataType
 >;
 
-export type FunctionT = {
+export type ResponseDoneEventFunction = {
   /**
    * The name of the function to call
    */
@@ -86,20 +88,20 @@ export type FunctionT = {
   arguments?: string | undefined;
 };
 
-export type PendingToolCalls = {
+export type ResponseDoneEventPendingToolCalls = {
   /**
    * Unique identifier for the tool call
    */
   id: string;
   type: ResponseDoneEventDataType;
-  function: FunctionT;
+  function: ResponseDoneEventFunction;
 };
 
 export type ResponseDoneEventData = {
   /**
    * The reason why the agent stopped generating
    */
-  finishReason: FinishReason;
+  finishReason: ResponseDoneEventFinishReason;
   /**
    * Token usage statistics for the complete response
    */
@@ -107,7 +109,7 @@ export type ResponseDoneEventData = {
   /**
    * Tool calls awaiting user response (when finishReason is function_call)
    */
-  pendingToolCalls?: Array<PendingToolCalls> | undefined;
+  pendingToolCalls?: Array<ResponseDoneEventPendingToolCalls> | undefined;
 };
 
 /**
@@ -123,11 +125,13 @@ export type ResponseDoneEvent = {
 };
 
 /** @internal */
-export const FinishReason$inboundSchema: z.ZodNativeEnum<typeof FinishReason> =
-  z.nativeEnum(FinishReason);
+export const ResponseDoneEventFinishReason$inboundSchema: z.ZodNativeEnum<
+  typeof ResponseDoneEventFinishReason
+> = z.nativeEnum(ResponseDoneEventFinishReason);
 /** @internal */
-export const FinishReason$outboundSchema: z.ZodNativeEnum<typeof FinishReason> =
-  FinishReason$inboundSchema;
+export const ResponseDoneEventFinishReason$outboundSchema: z.ZodNativeEnum<
+  typeof ResponseDoneEventFinishReason
+> = ResponseDoneEventFinishReason$inboundSchema;
 
 /** @internal */
 export const ResponseDoneEventPromptTokensDetails$inboundSchema: z.ZodType<
@@ -351,8 +355,8 @@ export const ResponseDoneEventDataType$outboundSchema: z.ZodNativeEnum<
 > = ResponseDoneEventDataType$inboundSchema;
 
 /** @internal */
-export const FunctionT$inboundSchema: z.ZodType<
-  FunctionT,
+export const ResponseDoneEventFunction$inboundSchema: z.ZodType<
+  ResponseDoneEventFunction,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -360,76 +364,82 @@ export const FunctionT$inboundSchema: z.ZodType<
   arguments: z.string().optional(),
 });
 /** @internal */
-export type FunctionT$Outbound = {
+export type ResponseDoneEventFunction$Outbound = {
   name?: string | undefined;
   arguments?: string | undefined;
 };
 
 /** @internal */
-export const FunctionT$outboundSchema: z.ZodType<
-  FunctionT$Outbound,
+export const ResponseDoneEventFunction$outboundSchema: z.ZodType<
+  ResponseDoneEventFunction$Outbound,
   z.ZodTypeDef,
-  FunctionT
+  ResponseDoneEventFunction
 > = z.object({
   name: z.string().optional(),
   arguments: z.string().optional(),
 });
 
-export function functionToJSON(functionT: FunctionT): string {
-  return JSON.stringify(FunctionT$outboundSchema.parse(functionT));
+export function responseDoneEventFunctionToJSON(
+  responseDoneEventFunction: ResponseDoneEventFunction,
+): string {
+  return JSON.stringify(
+    ResponseDoneEventFunction$outboundSchema.parse(responseDoneEventFunction),
+  );
 }
-export function functionFromJSON(
+export function responseDoneEventFunctionFromJSON(
   jsonString: string,
-): SafeParseResult<FunctionT, SDKValidationError> {
+): SafeParseResult<ResponseDoneEventFunction, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => FunctionT$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FunctionT' from JSON`,
+    (x) => ResponseDoneEventFunction$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseDoneEventFunction' from JSON`,
   );
 }
 
 /** @internal */
-export const PendingToolCalls$inboundSchema: z.ZodType<
-  PendingToolCalls,
+export const ResponseDoneEventPendingToolCalls$inboundSchema: z.ZodType<
+  ResponseDoneEventPendingToolCalls,
   z.ZodTypeDef,
   unknown
 > = z.object({
   id: z.string(),
   type: ResponseDoneEventDataType$inboundSchema,
-  function: z.lazy(() => FunctionT$inboundSchema),
+  function: z.lazy(() => ResponseDoneEventFunction$inboundSchema),
 });
 /** @internal */
-export type PendingToolCalls$Outbound = {
+export type ResponseDoneEventPendingToolCalls$Outbound = {
   id: string;
   type: string;
-  function: FunctionT$Outbound;
+  function: ResponseDoneEventFunction$Outbound;
 };
 
 /** @internal */
-export const PendingToolCalls$outboundSchema: z.ZodType<
-  PendingToolCalls$Outbound,
+export const ResponseDoneEventPendingToolCalls$outboundSchema: z.ZodType<
+  ResponseDoneEventPendingToolCalls$Outbound,
   z.ZodTypeDef,
-  PendingToolCalls
+  ResponseDoneEventPendingToolCalls
 > = z.object({
   id: z.string(),
   type: ResponseDoneEventDataType$outboundSchema,
-  function: z.lazy(() => FunctionT$outboundSchema),
+  function: z.lazy(() => ResponseDoneEventFunction$outboundSchema),
 });
 
-export function pendingToolCallsToJSON(
-  pendingToolCalls: PendingToolCalls,
+export function responseDoneEventPendingToolCallsToJSON(
+  responseDoneEventPendingToolCalls: ResponseDoneEventPendingToolCalls,
 ): string {
   return JSON.stringify(
-    PendingToolCalls$outboundSchema.parse(pendingToolCalls),
+    ResponseDoneEventPendingToolCalls$outboundSchema.parse(
+      responseDoneEventPendingToolCalls,
+    ),
   );
 }
-export function pendingToolCallsFromJSON(
+export function responseDoneEventPendingToolCallsFromJSON(
   jsonString: string,
-): SafeParseResult<PendingToolCalls, SDKValidationError> {
+): SafeParseResult<ResponseDoneEventPendingToolCalls, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => PendingToolCalls$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PendingToolCalls' from JSON`,
+    (x) => ResponseDoneEventPendingToolCalls$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseDoneEventPendingToolCalls' from JSON`,
   );
 }
 
@@ -439,16 +449,19 @@ export const ResponseDoneEventData$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  finishReason: FinishReason$inboundSchema,
+  finishReason: ResponseDoneEventFinishReason$inboundSchema,
   usage: z.lazy(() => ResponseDoneEventUsage$inboundSchema).optional(),
-  pendingToolCalls: z.array(z.lazy(() => PendingToolCalls$inboundSchema))
-    .optional(),
+  pendingToolCalls: z.array(
+    z.lazy(() => ResponseDoneEventPendingToolCalls$inboundSchema),
+  ).optional(),
 });
 /** @internal */
 export type ResponseDoneEventData$Outbound = {
   finishReason: string;
   usage?: ResponseDoneEventUsage$Outbound | undefined;
-  pendingToolCalls?: Array<PendingToolCalls$Outbound> | undefined;
+  pendingToolCalls?:
+    | Array<ResponseDoneEventPendingToolCalls$Outbound>
+    | undefined;
 };
 
 /** @internal */
@@ -457,10 +470,11 @@ export const ResponseDoneEventData$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ResponseDoneEventData
 > = z.object({
-  finishReason: FinishReason$outboundSchema,
+  finishReason: ResponseDoneEventFinishReason$outboundSchema,
   usage: z.lazy(() => ResponseDoneEventUsage$outboundSchema).optional(),
-  pendingToolCalls: z.array(z.lazy(() => PendingToolCalls$outboundSchema))
-    .optional(),
+  pendingToolCalls: z.array(
+    z.lazy(() => ResponseDoneEventPendingToolCalls$outboundSchema),
+  ).optional(),
 });
 
 export function responseDoneEventDataToJSON(

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(
-    "2026-01-20T15:51:06.085Z",
+    "2026-01-21T10:02:27.374Z",
   ).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("2026-01-20T15:51:06.085Z"))
+  updated: z.date().default(() => new Date("2026-01-21T10:02:27.374Z"))
     .transform(v => v.toISOString()),
 }).transform((v) => {
   return remap$(v, {

package/src/models/operations/createconversation.ts

@@ -270,7 +270,7 @@ export const CreateConversationResponseBody$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("conv_01kfe1mwtc5jzmh1rveatwt3ms"),
+  _id: z.string().default("conv_01kfg037957qts609ny87x1bp8"),
   kind: CreateConversationKind$inboundSchema,
   displayName: z.string(),
   createdAt: z.number(),
@@ -302,7 +302,7 @@ export const CreateConversationResponseBody$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CreateConversationResponseBody
 > = z.object({
-  id: z.string().default("conv_01kfe1mwtc5jzmh1rveatwt3ms"),
+  id: z.string().default("conv_01kfg037957qts609ny87x1bp8"),
   kind: CreateConversationKind$outboundSchema,
   displayName: z.string(),
   createdAt: z.number(),

package/src/models/operations/createconversationresponse.ts

@@ -337,7 +337,7 @@ export const PartReasoningPart$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("reasoning_01kfe1mwv9dacgvqaexbqzvavz"),
+  _id: z.string().default("reasoning_01kfg0379v46kd78p305h27zg4"),
   metadata: z.record(z.any()).optional(),
   kind: PartKind$inboundSchema,
   reasoning: z.string(),
@@ -362,7 +362,7 @@ export const PartReasoningPart$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   PartReasoningPart
 > = z.object({
-  id: z.string().default("reasoning_01kfe1mwv9dacgvqaexbqzvavz"),
+  id: z.string().default("reasoning_01kfg0379v46kd78p305h27zg4"),
   metadata: z.record(z.any()).optional(),
   kind: PartKind$outboundSchema,
   reasoning: z.string(),
@@ -510,7 +510,7 @@ export const ReasoningPart$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("reasoning_01kfe1mwv267fx1tbg6m4fz6nk"),
+  _id: z.string().default("reasoning_01kfg0379meegwa9t23tne9pmj"),
   metadata: z.record(z.any()).optional(),
   kind: DeltaKind$inboundSchema,
   reasoning: z.string(),
@@ -535,7 +535,7 @@ export const ReasoningPart$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ReasoningPart
 > = z.object({
-  id: z.string().default("reasoning_01kfe1mwv267fx1tbg6m4fz6nk"),
+  id: z.string().default("reasoning_01kfg0379meegwa9t23tne9pmj"),
   metadata: z.record(z.any()).optional(),
   kind: DeltaKind$outboundSchema,
   reasoning: z.string(),

package/src/models/operations/createdataset.ts

@@ -187,7 +187,7 @@ export const CreateDatasetResponseBody$inboundSchema: z.ZodType<
   created: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   updated: z.string().datetime({ offset: true }).default(
-    "2026-01-20T15:51:06.085Z",
+    "2026-01-21T10:02:27.374Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {
@@ -226,7 +226,7 @@ export const CreateDatasetResponseBody$outboundSchema: z.ZodType<
   createdById: z.string().optional(),
   updatedById: z.string().optional(),
   created: z.date().transform(v => v.toISOString()).optional(),
-  updated: z.date().default(() => new Date("2026-01-20T15:51:06.085Z"))
+  updated: z.date().default(() => new Date("2026-01-21T10:02:27.374Z"))
     .transform(v => v.toISOString()),
 }).transform((v) => {
   return remap$(v, {

package/src/models/operations/createdatasetitem.ts

@@ -3616,7 +3616,7 @@ export const Evaluations3$inboundSchema: z.ZodType<
   ),
   reviewed_by_id: z.string(),
   reviewed_at: z.string().datetime({ offset: true }).default(
-    "2026-01-20T15:51:20.277Z",
+    "2026-01-21T10:02:41.523Z",
   ).transform(v => new Date(v)),
   type: z.literal("string_array"),
   values: z.array(z.string()),
@@ -3653,7 +3653,7 @@ export const Evaluations3$outboundSchema: z.ZodType<
     "orq",
   ),
   reviewedById: z.string(),
-  reviewedAt: z.date().default(() => new Date("2026-01-20T15:51:20.277Z"))
+  reviewedAt: z.date().default(() => new Date("2026-01-21T10:02:41.523Z"))
     .transform(v => v.toISOString()),
   type: z.literal("string_array"),
   values: z.array(z.string()),
@@ -3709,7 +3709,7 @@ export const Evaluations2$inboundSchema: z.ZodType<
   source: CreateDatasetItemEvaluationsSource$inboundSchema.default("orq"),
   reviewed_by_id: z.string(),
   reviewed_at: z.string().datetime({ offset: true }).default(
-    "2026-01-20T15:51:20.277Z",
+    "2026-01-21T10:02:41.522Z",
   ).transform(v => new Date(v)),
   type: z.literal("number"),
   value: z.number(),
@@ -3744,7 +3744,7 @@ export const Evaluations2$outboundSchema: z.ZodType<
   humanReviewId: z.string(),
   source: CreateDatasetItemEvaluationsSource$outboundSchema.default("orq"),
   reviewedById: z.string(),
-  reviewedAt: z.date().default(() => new Date("2026-01-20T15:51:20.277Z"))
+  reviewedAt: z.date().default(() => new Date("2026-01-21T10:02:41.522Z"))
     .transform(v => v.toISOString()),
   type: z.literal("number"),
   value: z.number(),
@@ -3800,7 +3800,7 @@ export const Evaluations1$inboundSchema: z.ZodType<
   source: EvaluationsSource$inboundSchema.default("orq"),
   reviewed_by_id: z.string(),
   reviewed_at: z.string().datetime({ offset: true }).default(
-    "2026-01-20T15:51:20.276Z",
+    "2026-01-21T10:02:41.521Z",
   ).transform(v => new Date(v)),
   type: z.literal("string"),
   value: z.string(),
@@ -3835,7 +3835,7 @@ export const Evaluations1$outboundSchema: z.ZodType<
   humanReviewId: z.string(),
   source: EvaluationsSource$outboundSchema.default("orq"),
   reviewedById: z.string(),
-  reviewedAt: z.date().default(() => new Date("2026-01-20T15:51:20.276Z"))
+  reviewedAt: z.date().default(() => new Date("2026-01-21T10:02:41.521Z"))
     .transform(v => v.toISOString()),
   type: z.literal("string"),
   value: z.string(),
@@ -3940,7 +3940,7 @@ export const CreateDatasetItemResponseBody$inboundSchema: z.ZodType<
   created: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   updated: z.string().datetime({ offset: true }).default(
-    "2026-01-20T15:51:06.085Z",
+    "2026-01-21T10:02:27.374Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {
@@ -4018,7 +4018,7 @@ export const CreateDatasetItemResponseBody$outboundSchema: z.ZodType<
   createdById: z.string().optional(),
   updatedById: z.string().optional(),
   created: z.date().transform(v => v.toISOString()).optional(),
-  updated: z.date().default(() => new Date("2026-01-20T15:51:06.085Z"))
+  updated: z.date().default(() => new Date("2026-01-21T10:02:27.374Z"))
     .transform(v => v.toISOString()),
 }).transform((v) => {
   return remap$(v, {