@orq-ai/node 4.15.0-rc.3 → 4.15.0-rc.30

package/src/models/components/agentresponserequest.ts

@@ -29,29 +29,29 @@ import {
 /**
  * Message containing tool execution results
  */
-export const RoleToolMessage = {
+export const ToolMessage = {
   Tool: "tool",
 } as const;
 /**
  * Message containing tool execution results
  */
-export type RoleToolMessage = ClosedEnum<typeof RoleToolMessage>;
+export type ToolMessage = ClosedEnum<typeof ToolMessage>;
 
 /**
  * Message from the end user
  */
-export const RoleUserMessage = {
+export const UserMessage = {
   User: "user",
 } as const;
 /**
  * Message from the end user
  */
-export type RoleUserMessage = ClosedEnum<typeof RoleUserMessage>;
+export type UserMessage = ClosedEnum<typeof UserMessage>;
 
 /**
  * Message role (user or tool for continuing executions)
  */
-export type AgentResponseRequestRole = RoleUserMessage | RoleToolMessage;
+export type AgentResponseRequestRole = UserMessage | ToolMessage;
 
 /**
  * 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.
@@ -73,7 +73,7 @@ export type A2AMessage = {
   /**
    * Message role (user or tool for continuing executions)
    */
-  role: RoleUserMessage | RoleToolMessage;
+  role: UserMessage | ToolMessage;
   /**
    * A2A message parts (text, file, or tool_result only). Note: Tool role messages must only contain tool_result parts.
    */
@@ -182,7 +182,7 @@ export type Engine = ClosedEnum<typeof Engine>;
 /**
  * Configuration options for the agent invocation
  */
-export type Configuration = {
+export type AgentResponseRequestConfiguration = {
   /**
    * Whether to block until the agent task completes. When true, the response will include the full task with messages. When false (default), returns immediately with task ID and status.
    */
@@ -244,7 +244,7 @@ export type AgentResponseRequest = {
   /**
    * Configuration options for the agent invocation
    */
-  configuration?: Configuration | undefined;
+  configuration?: AgentResponseRequestConfiguration | undefined;
   /**
    * If true, returns immediately without waiting for completion. If false (default), waits until the agent becomes inactive or errors.
    */
@@ -260,14 +260,12 @@ export type AgentResponseRequest = {
 };
 
 /** @internal */
-export const RoleToolMessage$outboundSchema: z.ZodNativeEnum<
-  typeof RoleToolMessage
-> = z.nativeEnum(RoleToolMessage);
+export const ToolMessage$outboundSchema: z.ZodNativeEnum<typeof ToolMessage> = z
+  .nativeEnum(ToolMessage);
 
 /** @internal */
-export const RoleUserMessage$outboundSchema: z.ZodNativeEnum<
-  typeof RoleUserMessage
-> = z.nativeEnum(RoleUserMessage);
+export const UserMessage$outboundSchema: z.ZodNativeEnum<typeof UserMessage> = z
+  .nativeEnum(UserMessage);
 
 /** @internal */
 export type AgentResponseRequestRole$Outbound = string | string;
@@ -277,7 +275,7 @@ export const AgentResponseRequestRole$outboundSchema: z.ZodType<
   AgentResponseRequestRole$Outbound,
   z.ZodTypeDef,
   AgentResponseRequestRole
-> = z.union([RoleUserMessage$outboundSchema, RoleToolMessage$outboundSchema]);
+> = z.union([UserMessage$outboundSchema, ToolMessage$outboundSchema]);
 
 export function agentResponseRequestRoleToJSON(
   agentResponseRequestRole: AgentResponseRequestRole,
@@ -333,10 +331,7 @@ export const A2AMessage$outboundSchema: z.ZodType<
   A2AMessage
 > = z.object({
   messageId: z.string().optional(),
-  role: z.union([
-    RoleUserMessage$outboundSchema,
-    RoleToolMessage$outboundSchema,
-  ]),
+  role: z.union([UserMessage$outboundSchema, ToolMessage$outboundSchema]),
   parts: z.array(
     z.union([
       TextPart$outboundSchema,
@@ -478,21 +473,27 @@ export const Engine$outboundSchema: z.ZodNativeEnum<typeof Engine> = z
   .nativeEnum(Engine);
 
 /** @internal */
-export type Configuration$Outbound = {
+export type AgentResponseRequestConfiguration$Outbound = {
   blocking: boolean;
 };
 
 /** @internal */
-export const Configuration$outboundSchema: z.ZodType<
-  Configuration$Outbound,
+export const AgentResponseRequestConfiguration$outboundSchema: z.ZodType<
+  AgentResponseRequestConfiguration$Outbound,
   z.ZodTypeDef,
-  Configuration
+  AgentResponseRequestConfiguration
 > = z.object({
   blocking: z.boolean().default(false),
 });
 
-export function configurationToJSON(configuration: Configuration): string {
-  return JSON.stringify(Configuration$outboundSchema.parse(configuration));
+export function agentResponseRequestConfigurationToJSON(
+  agentResponseRequestConfiguration: AgentResponseRequestConfiguration,
+): string {
+  return JSON.stringify(
+    AgentResponseRequestConfiguration$outboundSchema.parse(
+      agentResponseRequestConfiguration,
+    ),
+  );
 }
 
 /** @internal */
@@ -528,7 +529,7 @@ export type AgentResponseRequest$Outbound = {
   memory?: AgentResponseRequestMemory$Outbound | undefined;
   metadata?: { [k: string]: any } | undefined;
   engine?: string | undefined;
-  configuration?: Configuration$Outbound | undefined;
+  configuration?: AgentResponseRequestConfiguration$Outbound | undefined;
   background: boolean;
   stream: boolean;
   conversation?: Conversation$Outbound | undefined;
@@ -550,7 +551,8 @@ export const AgentResponseRequest$outboundSchema: z.ZodType<
   memory: z.lazy(() => AgentResponseRequestMemory$outboundSchema).optional(),
   metadata: z.record(z.any()).optional(),
   engine: Engine$outboundSchema.optional(),
-  configuration: z.lazy(() => Configuration$outboundSchema).optional(),
+  configuration: z.lazy(() => AgentResponseRequestConfiguration$outboundSchema)
+    .optional(),
   background: z.boolean().default(false),
   stream: z.boolean().default(false),
   conversation: z.lazy(() => Conversation$outboundSchema).optional(),

package/src/models/components/agentstartedstreamingevent.ts

@@ -140,6 +140,10 @@ export type Evaluators = {
    * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
    */
   executeOn: AgentStartedStreamingEventDataExecuteOn;
+  /**
+   * Evaluator-specific configuration, passed through to the evaluator at run time. For orq_pii_detection this carries regions, entities, entity_thresholds, language and threshold, and is validated against PIIDetectionGuardrailOptions: regions and entities are two mutually exclusive coverage modes, and every entity_thresholds key must also appear in entities. on_failure is rejected: an evaluator acting as a guardrail always fails closed.
+   */
+  options?: { [k: string]: any } | undefined;
 };
 
 /**
@@ -169,6 +173,10 @@ export type Guardrails = {
    * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
    */
   executeOn: AgentStartedStreamingEventExecuteOn;
+  /**
+   * Evaluator-specific configuration, passed through to the evaluator at run time. For orq_pii_detection this carries regions, entities, entity_thresholds, language and threshold, and is validated against PIIDetectionGuardrailOptions: regions and entities are two mutually exclusive coverage modes, and every entity_thresholds key must also appear in entities. on_failure is rejected: an evaluator acting as a guardrail always fails closed.
+   */
+  options?: { [k: string]: any } | undefined;
 };
 
 export type Settings = {
@@ -198,7 +206,7 @@ export type Settings = {
    */
   evaluators?: Array<Evaluators> | undefined;
   /**
-   * Configuration for a guardrail applied to the agent
+   * Configuration for a guardrail applied to the agent. sample_rate has no effect here: a guardrail is a gate rather than a measurement, so it runs on every request.
    */
   guardrails?: Array<Guardrails> | undefined;
 };
@@ -376,6 +384,7 @@ export const Evaluators$inboundSchema: z.ZodType<
   id: z.string(),
   sample_rate: z.number().default(50),
   execute_on: AgentStartedStreamingEventDataExecuteOn$inboundSchema,
+  options: z.record(z.any()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "sample_rate": "sampleRate",
@@ -407,6 +416,7 @@ export const Guardrails$inboundSchema: z.ZodType<
   id: z.string(),
   sample_rate: z.number().default(50),
   execute_on: AgentStartedStreamingEventExecuteOn$inboundSchema,
+  options: z.record(z.any()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "sample_rate": "sampleRate",

package/src/models/components/agentthoughtstreamingevent.ts

@@ -83,7 +83,7 @@ export type AgentThoughtStreamingEventFunction = {
   arguments?: string | undefined;
 };
 
-export type AgentThoughtStreamingEventToolCalls = {
+export type ToolCalls = {
   index?: number | undefined;
   id?: string | undefined;
   type?: AgentThoughtStreamingEventDataType | undefined;
@@ -104,7 +104,7 @@ export type AgentThoughtStreamingEventDataRole = ClosedEnum<
 /**
  * If the audio output modality is requested, this object contains data about the audio response from the model.
  */
-export type AgentThoughtStreamingEventAudio = {
+export type Audio = {
   id: string;
   expiresAt: number;
   data: string;
@@ -117,7 +117,7 @@ export type AgentThoughtStreamingEventAudio = {
 export type AgentThoughtStreamingEventMessage = {
   content?: string | null | undefined;
   refusal?: string | null | undefined;
-  toolCalls?: Array<AgentThoughtStreamingEventToolCalls> | undefined;
+  toolCalls?: Array<ToolCalls> | undefined;
   role?: AgentThoughtStreamingEventDataRole | undefined;
   /**
    * Internal thought process of the model
@@ -134,7 +134,7 @@ export type AgentThoughtStreamingEventMessage = {
   /**
    * If the audio output modality is requested, this object contains data about the audio response from the model.
    */
-  audio?: AgentThoughtStreamingEventAudio | null | undefined;
+  audio?: Audio | null | undefined;
 };
 
 export type TopLogprobs = {
@@ -152,7 +152,7 @@ export type TopLogprobs = {
   bytes: Array<number> | null;
 };
 
-export type AgentThoughtStreamingEventContent = {
+export type Content = {
   /**
    * The token.
    */
@@ -212,7 +212,7 @@ export type Logprobs = {
   /**
    * A list of message content tokens with log probability information.
    */
-  content: Array<AgentThoughtStreamingEventContent> | null;
+  content: Array<Content> | null;
   /**
    * A list of message refusal tokens with log probability information.
    */
@@ -411,8 +411,8 @@ export function agentThoughtStreamingEventFunctionFromJSON(
 }
 
 /** @internal */
-export const AgentThoughtStreamingEventToolCalls$inboundSchema: z.ZodType<
-  AgentThoughtStreamingEventToolCalls,
+export const ToolCalls$inboundSchema: z.ZodType<
+  ToolCalls,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -428,14 +428,13 @@ export const AgentThoughtStreamingEventToolCalls$inboundSchema: z.ZodType<
   });
 });
 
-export function agentThoughtStreamingEventToolCallsFromJSON(
+export function toolCallsFromJSON(
   jsonString: string,
-): SafeParseResult<AgentThoughtStreamingEventToolCalls, SDKValidationError> {
+): SafeParseResult<ToolCalls, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) =>
-      AgentThoughtStreamingEventToolCalls$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AgentThoughtStreamingEventToolCalls' from JSON`,
+    (x) => ToolCalls$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolCalls' from JSON`,
   );
 }
 
@@ -445,28 +444,25 @@ export const AgentThoughtStreamingEventDataRole$inboundSchema: z.ZodNativeEnum<
 > = z.nativeEnum(AgentThoughtStreamingEventDataRole);
 
 /** @internal */
-export const AgentThoughtStreamingEventAudio$inboundSchema: z.ZodType<
-  AgentThoughtStreamingEventAudio,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  id: z.string(),
-  expires_at: z.number().int(),
-  data: z.string(),
-  transcript: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "expires_at": "expiresAt",
+export const Audio$inboundSchema: z.ZodType<Audio, z.ZodTypeDef, unknown> = z
+  .object({
+    id: z.string(),
+    expires_at: z.number().int(),
+    data: z.string(),
+    transcript: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      "expires_at": "expiresAt",
+    });
   });
-});
 
-export function agentThoughtStreamingEventAudioFromJSON(
+export function audioFromJSON(
   jsonString: string,
-): SafeParseResult<AgentThoughtStreamingEventAudio, SDKValidationError> {
+): SafeParseResult<Audio, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AgentThoughtStreamingEventAudio$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AgentThoughtStreamingEventAudio' from JSON`,
+    (x) => Audio$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Audio' from JSON`,
   );
 }
 
@@ -478,15 +474,12 @@ export const AgentThoughtStreamingEventMessage$inboundSchema: z.ZodType<
 > = z.object({
   content: z.nullable(z.string()).optional(),
   refusal: z.nullable(z.string()).optional(),
-  tool_calls: z.array(
-    z.lazy(() => AgentThoughtStreamingEventToolCalls$inboundSchema),
-  ).optional(),
+  tool_calls: z.array(z.lazy(() => ToolCalls$inboundSchema)).optional(),
   role: AgentThoughtStreamingEventDataRole$inboundSchema.optional(),
   reasoning: z.nullable(z.string()).optional(),
   reasoning_signature: z.nullable(z.string()).optional(),
   redacted_reasoning: z.string().optional(),
-  audio: z.nullable(z.lazy(() => AgentThoughtStreamingEventAudio$inboundSchema))
-    .optional(),
+  audio: z.nullable(z.lazy(() => Audio$inboundSchema)).optional(),
 }).transform((v) => {
   return remap$(v, {
     "tool_calls": "toolCalls",
@@ -527,28 +520,25 @@ export function topLogprobsFromJSON(
 }
 
 /** @internal */
-export const AgentThoughtStreamingEventContent$inboundSchema: z.ZodType<
-  AgentThoughtStreamingEventContent,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  token: z.string(),
-  logprob: z.number(),
-  bytes: z.nullable(z.array(z.number())),
-  top_logprobs: z.array(z.lazy(() => TopLogprobs$inboundSchema)),
-}).transform((v) => {
-  return remap$(v, {
-    "top_logprobs": "topLogprobs",
+export const Content$inboundSchema: z.ZodType<Content, z.ZodTypeDef, unknown> =
+  z.object({
+    token: z.string(),
+    logprob: z.number(),
+    bytes: z.nullable(z.array(z.number())),
+    top_logprobs: z.array(z.lazy(() => TopLogprobs$inboundSchema)),
+  }).transform((v) => {
+    return remap$(v, {
+      "top_logprobs": "topLogprobs",
+    });
   });
-});
 
-export function agentThoughtStreamingEventContentFromJSON(
+export function contentFromJSON(
   jsonString: string,
-): SafeParseResult<AgentThoughtStreamingEventContent, SDKValidationError> {
+): SafeParseResult<Content, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AgentThoughtStreamingEventContent$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AgentThoughtStreamingEventContent' from JSON`,
+    (x) => Content$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Content' from JSON`,
   );
 }
 
@@ -605,9 +595,7 @@ export const Logprobs$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  content: z.nullable(
-    z.array(z.lazy(() => AgentThoughtStreamingEventContent$inboundSchema)),
-  ),
+  content: z.nullable(z.array(z.lazy(() => Content$inboundSchema))),
   refusal: z.nullable(z.array(z.lazy(() => Refusal$inboundSchema))),
 });
 

package/src/models/components/annotationqueue.ts

@@ -0,0 +1,101 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  AnnotationQueueMetadata,
+  AnnotationQueueMetadata$inboundSchema,
+} from "./annotationqueuemetadata.js";
+
+export type AnnotationQueue = {
+  /**
+   * Unique annotation queue identifier assigned by ORQ.
+   */
+  id: string;
+  /**
+   * The display name of the annotation queue.
+   */
+  displayName: string;
+  /**
+   * The description of the annotation queue.
+   */
+  description: string;
+  /**
+   * The unique identifier of the workspace it belongs to.
+   */
+  workspaceId: string;
+  /**
+   * The project ID. When set, human reviews are resolved from the project automatically.
+   */
+  projectId?: string | undefined;
+  /**
+   * Legacy: manually selected human review IDs. Used only when project_id is not set.
+   */
+  humanReviewIds: Array<string>;
+  /**
+   * Aggregate counters for the annotation queue.
+   */
+  metadata: AnnotationQueueMetadata;
+  /**
+   * The account that created the annotation queue. Unset when created via API key authentication.
+   */
+  createdById?: string | undefined;
+  /**
+   * The account that last updated the annotation queue. Unset when updated via API key authentication.
+   */
+  updatedById?: string | undefined;
+  /**
+   * The date and time the annotation queue was created.
+   */
+  created?: Date | undefined;
+  /**
+   * The date and time the annotation queue was last updated.
+   */
+  updated?: Date | undefined;
+};
+
+/** @internal */
+export const AnnotationQueue$inboundSchema: z.ZodType<
+  AnnotationQueue,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  display_name: z.string(),
+  description: z.string(),
+  workspace_id: z.string(),
+  project_id: z.string().optional(),
+  human_review_ids: z.array(z.string()),
+  metadata: AnnotationQueueMetadata$inboundSchema,
+  created_by_id: z.string().optional(),
+  updated_by_id: z.string().optional(),
+  created: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  updated: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "display_name": "displayName",
+    "workspace_id": "workspaceId",
+    "project_id": "projectId",
+    "human_review_ids": "humanReviewIds",
+    "created_by_id": "createdById",
+    "updated_by_id": "updatedById",
+  });
+});
+
+export function annotationQueueFromJSON(
+  jsonString: string,
+): SafeParseResult<AnnotationQueue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnnotationQueue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnnotationQueue' from JSON`,
+  );
+}

package/src/models/components/annotationqueueitem.ts

@@ -0,0 +1,80 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type AnnotationQueueItem = {
+  /**
+   * Unique annotation queue item identifier assigned by ORQ.
+   */
+  id: string;
+  /**
+   * The unique identifier of the annotation queue.
+   */
+  annotationQueueId: string;
+  /**
+   * The unique identifier of the workspace it belongs to.
+   */
+  workspaceId: string;
+  /**
+   * The unique identifiers of the human reviews that have been used to annotate the item.
+   */
+  usedHumanReviewIds?: Array<string> | undefined;
+  /**
+   * The item type. Either `span` or `datapoint`.
+   */
+  type: string;
+  /**
+   * The span this item points to. Present when `type` is `span`.
+   */
+  spanId?: string | undefined;
+  /**
+   * The trace identifier this span belongs to.
+   */
+  traceId?: string | undefined;
+  /**
+   * The datapoint this item points to. Present when `type` is `datapoint`.
+   */
+  datapointId?: string | undefined;
+};
+
+/** @internal */
+export const AnnotationQueueItem$inboundSchema: z.ZodType<
+  AnnotationQueueItem,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  annotation_queue_id: z.string(),
+  workspace_id: z.string(),
+  used_human_review_ids: z.array(z.string()).optional(),
+  type: z.string(),
+  span_id: z.string().optional(),
+  trace_id: z.string().optional(),
+  datapoint_id: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "annotation_queue_id": "annotationQueueId",
+    "workspace_id": "workspaceId",
+    "used_human_review_ids": "usedHumanReviewIds",
+    "span_id": "spanId",
+    "trace_id": "traceId",
+    "datapoint_id": "datapointId",
+  });
+});
+
+export function annotationQueueItemFromJSON(
+  jsonString: string,
+): SafeParseResult<AnnotationQueueItem, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnnotationQueueItem$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnnotationQueueItem' from JSON`,
+  );
+}

package/src/models/components/annotationqueueitemref.ts

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+/**
+ * Span reference accepted by AddAnnotationQueueItems.
+ */
+export type AnnotationQueueItemRef = {
+  spanId: string;
+  traceId: string;
+};
+
+/** @internal */
+export type AnnotationQueueItemRef$Outbound = {
+  span_id: string;
+  trace_id: string;
+};
+
+/** @internal */
+export const AnnotationQueueItemRef$outboundSchema: z.ZodType<
+  AnnotationQueueItemRef$Outbound,
+  z.ZodTypeDef,
+  AnnotationQueueItemRef
+> = z.object({
+  spanId: z.string(),
+  traceId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    spanId: "span_id",
+    traceId: "trace_id",
+  });
+});
+
+export function annotationQueueItemRefToJSON(
+  annotationQueueItemRef: AnnotationQueueItemRef,
+): string {
+  return JSON.stringify(
+    AnnotationQueueItemRef$outboundSchema.parse(annotationQueueItemRef),
+  );
+}

package/src/models/components/annotationqueuemetadata.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Aggregate counters maintained by the service as items are added and removed.
+ */
+export type AnnotationQueueMetadata = {
+  /**
+   * Number of items currently in the annotation queue.
+   */
+  itemsCount: number;
+};
+
+/** @internal */
+export const AnnotationQueueMetadata$inboundSchema: z.ZodType<
+  AnnotationQueueMetadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  items_count: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "items_count": "itemsCount",
+  });
+});
+
+export function annotationQueueMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<AnnotationQueueMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnnotationQueueMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnnotationQueueMetadata' from JSON`,
+  );
+}