@orq-ai/node 4.9.24 → 4.9.29

package/packages/orq-rc/src/models/operations/listagents.ts

@@ -11,14 +11,13 @@ import * as components from "../components/index.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
- * Filter agents by type: "internal" for Orquesta-managed agents, "a2a" for external A2A-compliant agents
+ * Filter agents by type
  */
 export const QueryParamType = {
   Internal: "internal",
-  A2a: "a2a",
 } as const;
 /**
- * Filter agents by type: "internal" for Orquesta-managed agents, "a2a" for external A2A-compliant agents
+ * Filter agents by type
  */
 export type QueryParamType = ClosedEnum<typeof QueryParamType>;
 
@@ -36,7 +35,7 @@ export type ListAgentsRequest = {
    */
   endingBefore?: string | undefined;
   /**
-   * Filter agents by type: "internal" for Orquesta-managed agents, "a2a" for external A2A-compliant agents
+   * Filter agents by type
    */
   type?: QueryParamType | undefined;
 };
@@ -1065,36 +1064,6 @@ export type ListAgentsModel = {
     | undefined;
 };
 
-export type ListAgentsHeaders = {
-  /**
-   * Header value. **Update behavior**: Provide empty string ("") to preserve existing encrypted value without re-entering credentials. Provide new value to rotate. Omit header entirely to remove.
-   */
-  value: string;
-  encrypted: boolean;
-};
-
-/**
- * A2A configuration with agent endpoint and authentication. Only present for A2A agents.
- */
-export type ListAgentsA2AAgentConfiguration = {
-  /**
-   * The A2A agent endpoint URL (e.g., https://example.com/agent/a2a)
-   */
-  agentUrl: string;
-  /**
-   * Optional explicit URL to fetch agent card. Defaults to {agent_url}/card if not provided
-   */
-  cardUrl?: string | undefined;
-  /**
-   * HTTP headers for A2A agent requests with encryption support (max 20 headers). **Update behavior**: Empty string values preserve existing encrypted headers, allowing partial updates without credential re-entry.
-   */
-  headers?: { [k: string]: ListAgentsHeaders } | undefined;
-  /**
-   * Cached agent card from discovery. Refreshed periodically.
-   */
-  cachedCard?: any | undefined;
-};
-
 export type ListAgentsData = {
   id: string;
   /**
@@ -1157,10 +1126,6 @@ export type ListAgentsData = {
   instructions: string;
   settings?: ListAgentsSettings | undefined;
   model: ListAgentsModel;
-  /**
-   * A2A configuration with agent endpoint and authentication. Only present for A2A agents.
-   */
-  a2a?: ListAgentsA2AAgentConfiguration | undefined;
 };
 
 /**
@@ -2652,54 +2617,6 @@ export function listAgentsModelFromJSON(
   );
 }
 
-/** @internal */
-export const ListAgentsHeaders$inboundSchema: z.ZodType<
-  ListAgentsHeaders,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  value: z.string(),
-  encrypted: z.boolean().default(false),
-});
-
-export function listAgentsHeadersFromJSON(
-  jsonString: string,
-): SafeParseResult<ListAgentsHeaders, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ListAgentsHeaders$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAgentsHeaders' from JSON`,
-  );
-}
-
-/** @internal */
-export const ListAgentsA2AAgentConfiguration$inboundSchema: z.ZodType<
-  ListAgentsA2AAgentConfiguration,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  agent_url: z.string(),
-  card_url: z.string().optional(),
-  headers: z.record(z.lazy(() => ListAgentsHeaders$inboundSchema)).optional(),
-  cached_card: z.any().optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "agent_url": "agentUrl",
-    "card_url": "cardUrl",
-    "cached_card": "cachedCard",
-  });
-});
-
-export function listAgentsA2AAgentConfigurationFromJSON(
-  jsonString: string,
-): SafeParseResult<ListAgentsA2AAgentConfiguration, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ListAgentsA2AAgentConfiguration$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAgentsA2AAgentConfiguration' from JSON`,
-  );
-}
-
 /** @internal */
 export const ListAgentsData$inboundSchema: z.ZodType<
   ListAgentsData,
@@ -2733,7 +2650,6 @@ export const ListAgentsData$inboundSchema: z.ZodType<
   instructions: z.string(),
   settings: z.lazy(() => ListAgentsSettings$inboundSchema).optional(),
   model: z.lazy(() => ListAgentsModel$inboundSchema),
-  a2a: z.lazy(() => ListAgentsA2AAgentConfiguration$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "_id": "id",

package/packages/orq-rc/src/models/operations/listchunks.ts

@@ -9,10 +9,28 @@ import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
+export const QueryParam2 = {
+  Pending: "pending",
+  Processing: "processing",
+  Completed: "completed",
+  Failed: "failed",
+  Queued: "queued",
+} as const;
+export type QueryParam2 = ClosedEnum<typeof QueryParam2>;
+
+export const QueryParam1 = {
+  Pending: "pending",
+  Processing: "processing",
+  Completed: "completed",
+  Failed: "failed",
+  Queued: "queued",
+} as const;
+export type QueryParam1 = ClosedEnum<typeof QueryParam1>;
+
 /**
- * Filter datasources by status.
+ * Filter chunks by status.
  */
-export type QueryParamStatus = Array<string> | string;
+export type QueryParamStatus = Array<QueryParam1> | QueryParam2;
 
 export type ListChunksRequest = {
   /**
@@ -40,9 +58,9 @@ export type ListChunksRequest = {
    */
   q?: string | undefined;
   /**
-   * Filter datasources by status.
+   * Filter chunks by status.
    */
-  status?: Array<string> | string | undefined;
+  status?: Array<QueryParam1> | QueryParam2 | undefined;
 };
 
 export const ListChunksObject = {
@@ -115,6 +133,14 @@ export type ListChunksResponseBody = {
   hasMore: boolean;
 };
 
+/** @internal */
+export const QueryParam2$outboundSchema: z.ZodNativeEnum<typeof QueryParam2> = z
+  .nativeEnum(QueryParam2);
+
+/** @internal */
+export const QueryParam1$outboundSchema: z.ZodNativeEnum<typeof QueryParam1> = z
+  .nativeEnum(QueryParam1);
+
 /** @internal */
 export type QueryParamStatus$Outbound = Array<string> | string;
 
@@ -123,7 +149,7 @@ export const QueryParamStatus$outboundSchema: z.ZodType<
   QueryParamStatus$Outbound,
   z.ZodTypeDef,
   QueryParamStatus
-> = z.union([z.array(z.string()), z.string()]);
+> = z.union([z.array(QueryParam1$outboundSchema), QueryParam2$outboundSchema]);
 
 export function queryParamStatusToJSON(
   queryParamStatus: QueryParamStatus,
@@ -156,7 +182,10 @@ export const ListChunksRequest$outboundSchema: z.ZodType<
   startingAfter: z.string().optional(),
   endingBefore: z.string().optional(),
   q: z.string().optional(),
-  status: z.union([z.array(z.string()), z.string()]).optional(),
+  status: z.union([
+    z.array(QueryParam1$outboundSchema),
+    QueryParam2$outboundSchema,
+  ]).optional(),
 }).transform((v) => {
   return remap$(v, {
     knowledgeId: "knowledge_id",

package/packages/orq-rc/src/models/operations/listdatasetdatapoints.ts

@@ -1270,7 +1270,7 @@ export const ListDatasetDatapointsEvaluations3$inboundSchema: z.ZodType<
   ),
   reviewed_by_id: z.string(),
   reviewed_at: z.string().datetime({ offset: true }).default(
-    "2026-05-25T16:12:26.664Z",
+    "2026-06-02T03:49:25.037Z",
   ).transform(v => new Date(v)),
   type: z.literal("string_array"),
   values: z.array(z.string()),
@@ -1320,7 +1320,7 @@ export const ListDatasetDatapointsEvaluations2$inboundSchema: z.ZodType<
   source: ListDatasetDatapointsEvaluationsSource$inboundSchema.default("orq"),
   reviewed_by_id: z.string(),
   reviewed_at: z.string().datetime({ offset: true }).default(
-    "2026-05-25T16:12:26.663Z",
+    "2026-06-02T03:49:25.037Z",
   ).transform(v => new Date(v)),
   type: z.literal("number"),
   value: z.number(),
@@ -1369,7 +1369,7 @@ export const ListDatasetDatapointsEvaluations1$inboundSchema: z.ZodType<
     .default("orq"),
   reviewed_by_id: z.string(),
   reviewed_at: z.string().datetime({ offset: true }).default(
-    "2026-05-25T16:12:26.663Z",
+    "2026-06-02T03:49:25.036Z",
   ).transform(v => new Date(v)),
   type: z.literal("string"),
   value: z.string(),
@@ -1448,7 +1448,7 @@ export const ListDatasetDatapointsData$inboundSchema: z.ZodType<
   created: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   updated: z.string().datetime({ offset: true }).default(
-    "2026-05-25T16:12:11.970Z",
+    "2026-06-02T03:49:02.542Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {

package/packages/orq-rc/src/models/operations/listdatasets.ts

@@ -156,7 +156,7 @@ export const ListDatasetsData$inboundSchema: z.ZodType<
   created: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   updated: z.string().datetime({ offset: true }).default(
-    "2026-05-25T16:12:11.970Z",
+    "2026-06-02T03:49:02.542Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {

package/packages/orq-rc/src/models/operations/listdatasources.ts

@@ -176,7 +176,7 @@ export const ListDatasourcesData$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("01KSFYHD383GAR720SG0AR0MCR"),
+  _id: z.string().default("01KT376MBFQKW3FASKXZVT6ZXX"),
   display_name: z.string(),
   description: z.string().optional(),
   status: ListDatasourcesStatus$inboundSchema,

package/packages/orq-rc/src/models/operations/modelazurefoundrydeployments.ts

@@ -0,0 +1,90 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ModelAzureFoundryDeploymentsRequestBody = {
+  apiKey: string;
+  apiVersion?: string | undefined;
+  baseUrl: string;
+  provider: string;
+};
+
+/**
+ * Azure Foundry deployments listed
+ */
+export type ModelAzureFoundryDeploymentsResponseBody = {
+  deployments: Array<components.AzureFoundryDeployment> | null;
+  region: string;
+};
+
+/** @internal */
+export type ModelAzureFoundryDeploymentsRequestBody$Outbound = {
+  api_key: string;
+  api_version?: string | undefined;
+  base_url: string;
+  provider: string;
+};
+
+/** @internal */
+export const ModelAzureFoundryDeploymentsRequestBody$outboundSchema: z.ZodType<
+  ModelAzureFoundryDeploymentsRequestBody$Outbound,
+  z.ZodTypeDef,
+  ModelAzureFoundryDeploymentsRequestBody
+> = z.object({
+  apiKey: z.string(),
+  apiVersion: z.string().optional(),
+  baseUrl: z.string(),
+  provider: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    apiKey: "api_key",
+    apiVersion: "api_version",
+    baseUrl: "base_url",
+  });
+});
+
+export function modelAzureFoundryDeploymentsRequestBodyToJSON(
+  modelAzureFoundryDeploymentsRequestBody:
+    ModelAzureFoundryDeploymentsRequestBody,
+): string {
+  return JSON.stringify(
+    ModelAzureFoundryDeploymentsRequestBody$outboundSchema.parse(
+      modelAzureFoundryDeploymentsRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export const ModelAzureFoundryDeploymentsResponseBody$inboundSchema: z.ZodType<
+  ModelAzureFoundryDeploymentsResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  deployments: z.nullable(
+    z.array(components.AzureFoundryDeployment$inboundSchema),
+  ),
+  region: z.string(),
+});
+
+export function modelAzureFoundryDeploymentsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ModelAzureFoundryDeploymentsResponseBody,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ModelAzureFoundryDeploymentsResponseBody$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ModelAzureFoundryDeploymentsResponseBody' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/operations/modelcreate.ts

@@ -0,0 +1,184 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ModelCreateRequestBody = {
+  configuration: { [k: string]: any };
+  displayName: string;
+  hasFunctions: boolean;
+  id: string;
+  inputCost: number;
+  metadata: components.ModelMetadata;
+  modelDeveloper: string;
+  modelFamily: string;
+  modelId: string;
+  modelType: string;
+  outputCost: number;
+  parameters: Array<components.CreateModelParameter> | null;
+  provider: string;
+};
+
+/**
+ * Model created successfully
+ */
+export type ModelCreateResponseBody = {
+  configuration: components.ModelConfigurationResponse;
+  created: Date;
+  description: string | null;
+  displayName: string;
+  docsUrl: string | null;
+  enabled: boolean;
+  enabledForEndpoints: boolean;
+  enabledForPlayground: boolean;
+  hasCpuPricing: boolean;
+  hasFunctions: boolean;
+  id: string;
+  inputCost: number | null;
+  inputCurrency: string;
+  isActive: boolean;
+  metadata: components.ModelMetadata;
+  modelDeveloper?: string | undefined;
+  modelFamily?: string | undefined;
+  modelId: string;
+  modelType: string;
+  outputCost: number | null;
+  outputCurrency: string;
+  owner: string;
+  parameters: Array<components.ModelParameterDocument> | null;
+  pricingUrl: string | null;
+  provider: string;
+  refId: string;
+  updated: Date;
+};
+
+/** @internal */
+export type ModelCreateRequestBody$Outbound = {
+  configuration: { [k: string]: any };
+  display_name: string;
+  has_functions: boolean;
+  id: string;
+  input_cost: number;
+  metadata: components.ModelMetadata$Outbound;
+  model_developer: string;
+  model_family: string;
+  model_id: string;
+  model_type: string;
+  output_cost: number;
+  parameters: Array<components.CreateModelParameter$Outbound> | null;
+  provider: string;
+};
+
+/** @internal */
+export const ModelCreateRequestBody$outboundSchema: z.ZodType<
+  ModelCreateRequestBody$Outbound,
+  z.ZodTypeDef,
+  ModelCreateRequestBody
+> = z.object({
+  configuration: z.record(z.any()),
+  displayName: z.string(),
+  hasFunctions: z.boolean(),
+  id: z.string(),
+  inputCost: z.number(),
+  metadata: components.ModelMetadata$outboundSchema,
+  modelDeveloper: z.string(),
+  modelFamily: z.string(),
+  modelId: z.string(),
+  modelType: z.string(),
+  outputCost: z.number(),
+  parameters: z.nullable(
+    z.array(components.CreateModelParameter$outboundSchema),
+  ),
+  provider: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    displayName: "display_name",
+    hasFunctions: "has_functions",
+    inputCost: "input_cost",
+    modelDeveloper: "model_developer",
+    modelFamily: "model_family",
+    modelId: "model_id",
+    modelType: "model_type",
+    outputCost: "output_cost",
+  });
+});
+
+export function modelCreateRequestBodyToJSON(
+  modelCreateRequestBody: ModelCreateRequestBody,
+): string {
+  return JSON.stringify(
+    ModelCreateRequestBody$outboundSchema.parse(modelCreateRequestBody),
+  );
+}
+
+/** @internal */
+export const ModelCreateResponseBody$inboundSchema: z.ZodType<
+  ModelCreateResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  configuration: components.ModelConfigurationResponse$inboundSchema,
+  created: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  description: z.nullable(z.string()),
+  display_name: z.string(),
+  docs_url: z.nullable(z.string()),
+  enabled: z.boolean(),
+  enabled_for_endpoints: z.boolean(),
+  enabled_for_playground: z.boolean(),
+  has_cpu_pricing: z.boolean(),
+  has_functions: z.boolean(),
+  id: z.string(),
+  input_cost: z.nullable(z.number()),
+  input_currency: z.string(),
+  is_active: z.boolean(),
+  metadata: components.ModelMetadata$inboundSchema,
+  model_developer: z.string().optional(),
+  model_family: z.string().optional(),
+  model_id: z.string(),
+  model_type: z.string(),
+  output_cost: z.nullable(z.number()),
+  output_currency: z.string(),
+  owner: z.string(),
+  parameters: z.nullable(
+    z.array(components.ModelParameterDocument$inboundSchema),
+  ),
+  pricing_url: z.nullable(z.string()),
+  provider: z.string(),
+  refId: z.string(),
+  updated: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+}).transform((v) => {
+  return remap$(v, {
+    "display_name": "displayName",
+    "docs_url": "docsUrl",
+    "enabled_for_endpoints": "enabledForEndpoints",
+    "enabled_for_playground": "enabledForPlayground",
+    "has_cpu_pricing": "hasCpuPricing",
+    "has_functions": "hasFunctions",
+    "input_cost": "inputCost",
+    "input_currency": "inputCurrency",
+    "is_active": "isActive",
+    "model_developer": "modelDeveloper",
+    "model_family": "modelFamily",
+    "model_id": "modelId",
+    "model_type": "modelType",
+    "output_cost": "outputCost",
+    "output_currency": "outputCurrency",
+    "pricing_url": "pricingUrl",
+  });
+});
+
+export function modelCreateResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<ModelCreateResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ModelCreateResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ModelCreateResponseBody' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/operations/modelcreateautorouter.ts

@@ -0,0 +1,151 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ModelCreateAutorouterRequestBody = {
+  economicalModel: string;
+  key: string;
+  profile?: string | undefined;
+  strongModel: string;
+};
+
+/**
+ * Autorouter model created successfully
+ */
+export type ModelCreateAutorouterResponseBody = {
+  configuration: components.ModelConfigurationResponse;
+  created: Date;
+  description: string | null;
+  displayName: string;
+  docsUrl: string | null;
+  enabled: boolean;
+  enabledForEndpoints: boolean;
+  enabledForPlayground: boolean;
+  hasCpuPricing: boolean;
+  hasFunctions: boolean;
+  id: string;
+  inputCost: number | null;
+  inputCurrency: string;
+  isActive: boolean;
+  metadata: components.ModelMetadata;
+  modelDeveloper?: string | undefined;
+  modelFamily?: string | undefined;
+  modelId: string;
+  modelType: string;
+  outputCost: number | null;
+  outputCurrency: string;
+  owner: string;
+  parameters: Array<components.ModelParameterDocument> | null;
+  pricingUrl: string | null;
+  provider: string;
+  refId: string;
+  updated: Date;
+};
+
+/** @internal */
+export type ModelCreateAutorouterRequestBody$Outbound = {
+  economical_model: string;
+  key: string;
+  profile?: string | undefined;
+  strong_model: string;
+};
+
+/** @internal */
+export const ModelCreateAutorouterRequestBody$outboundSchema: z.ZodType<
+  ModelCreateAutorouterRequestBody$Outbound,
+  z.ZodTypeDef,
+  ModelCreateAutorouterRequestBody
+> = z.object({
+  economicalModel: z.string(),
+  key: z.string(),
+  profile: z.string().optional(),
+  strongModel: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    economicalModel: "economical_model",
+    strongModel: "strong_model",
+  });
+});
+
+export function modelCreateAutorouterRequestBodyToJSON(
+  modelCreateAutorouterRequestBody: ModelCreateAutorouterRequestBody,
+): string {
+  return JSON.stringify(
+    ModelCreateAutorouterRequestBody$outboundSchema.parse(
+      modelCreateAutorouterRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export const ModelCreateAutorouterResponseBody$inboundSchema: z.ZodType<
+  ModelCreateAutorouterResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  configuration: components.ModelConfigurationResponse$inboundSchema,
+  created: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  description: z.nullable(z.string()),
+  display_name: z.string(),
+  docs_url: z.nullable(z.string()),
+  enabled: z.boolean(),
+  enabled_for_endpoints: z.boolean(),
+  enabled_for_playground: z.boolean(),
+  has_cpu_pricing: z.boolean(),
+  has_functions: z.boolean(),
+  id: z.string(),
+  input_cost: z.nullable(z.number()),
+  input_currency: z.string(),
+  is_active: z.boolean(),
+  metadata: components.ModelMetadata$inboundSchema,
+  model_developer: z.string().optional(),
+  model_family: z.string().optional(),
+  model_id: z.string(),
+  model_type: z.string(),
+  output_cost: z.nullable(z.number()),
+  output_currency: z.string(),
+  owner: z.string(),
+  parameters: z.nullable(
+    z.array(components.ModelParameterDocument$inboundSchema),
+  ),
+  pricing_url: z.nullable(z.string()),
+  provider: z.string(),
+  refId: z.string(),
+  updated: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+}).transform((v) => {
+  return remap$(v, {
+    "display_name": "displayName",
+    "docs_url": "docsUrl",
+    "enabled_for_endpoints": "enabledForEndpoints",
+    "enabled_for_playground": "enabledForPlayground",
+    "has_cpu_pricing": "hasCpuPricing",
+    "has_functions": "hasFunctions",
+    "input_cost": "inputCost",
+    "input_currency": "inputCurrency",
+    "is_active": "isActive",
+    "model_developer": "modelDeveloper",
+    "model_family": "modelFamily",
+    "model_id": "modelId",
+    "model_type": "modelType",
+    "output_cost": "outputCost",
+    "output_currency": "outputCurrency",
+    "pricing_url": "pricingUrl",
+  });
+});
+
+export function modelCreateAutorouterResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<ModelCreateAutorouterResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ModelCreateAutorouterResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ModelCreateAutorouterResponseBody' from JSON`,
+  );
+}