@orq-ai/node 4.10.0-rc.9 → 4.10.1

package/{src/models/components/invokedeploymentrequest.ts → packages/orq-rc/src/models/operations/deploymentinvoke.ts}

@@ -4,68 +4,33 @@
 
 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 {
-  AudioContentPartSchema,
-  AudioContentPartSchema$Outbound,
-  AudioContentPartSchema$outboundSchema,
-} from "./audiocontentpartschema.js";
-import {
-  FileContentPartSchema,
-  FileContentPartSchema$Outbound,
-  FileContentPartSchema$outboundSchema,
-} from "./filecontentpartschema.js";
-import {
-  ImageContentPartSchema,
-  ImageContentPartSchema$Outbound,
-  ImageContentPartSchema$outboundSchema,
-} from "./imagecontentpartschema.js";
-import {
-  PublicIdentity,
-  PublicIdentity$Outbound,
-  PublicIdentity$outboundSchema,
-} from "./publicidentity.js";
-import {
-  ReasoningPartSchema,
-  ReasoningPartSchema$Outbound,
-  ReasoningPartSchema$outboundSchema,
-} from "./reasoningpartschema.js";
-import {
-  RedactedReasoningPartSchema,
-  RedactedReasoningPartSchema$Outbound,
-  RedactedReasoningPartSchema$outboundSchema,
-} from "./redactedreasoningpartschema.js";
-import {
-  RefusalPartSchema,
-  RefusalPartSchema$Outbound,
-  RefusalPartSchema$outboundSchema,
-} from "./refusalpartschema.js";
-import {
-  TextContentPartSchema,
-  TextContentPartSchema$Outbound,
-  TextContentPartSchema$outboundSchema,
-} from "./textcontentpartschema.js";
-
-export type InvokeDeploymentRequestContent2 = TextContentPartSchema;
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DeploymentInvokeContentDeployments2 =
+  components.TextContentPartSchema;
 
 /**
  * The contents of the tool message.
  */
-export type InvokeDeploymentRequestPrefixMessages5Content =
+export type DeploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent =
   | string
-  | Array<TextContentPartSchema>;
+  | Array<components.TextContentPartSchema>;
 
 /**
  * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
  */
-export const InvokeDeploymentRequestPrefixMessagesType = {
+export const DeploymentInvokePrefixMessagesType = {
   Ephemeral: "ephemeral",
 } as const;
 /**
  * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
  */
-export type InvokeDeploymentRequestPrefixMessagesType = ClosedEnum<
-  typeof InvokeDeploymentRequestPrefixMessagesType
+export type DeploymentInvokePrefixMessagesType = ClosedEnum<
+  typeof DeploymentInvokePrefixMessagesType
 >;
 
 /**
@@ -98,7 +63,7 @@ export type PrefixMessagesCacheControl = {
   /**
    * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
    */
-  type: InvokeDeploymentRequestPrefixMessagesType;
+  type: DeploymentInvokePrefixMessagesType;
   /**
    * The time-to-live for the cache control breakpoint. This may be one of the following values:
    *
@@ -120,7 +85,7 @@ export type ToolMessage = {
   /**
    * The contents of the tool message.
    */
-  content: string | Array<TextContentPartSchema>;
+  content: string | Array<components.TextContentPartSchema>;
   /**
    * Tool call that this message is responding to.
    */
@@ -128,22 +93,22 @@ export type ToolMessage = {
   cacheControl?: PrefixMessagesCacheControl | undefined;
 };
 
-export type Content2 =
-  | (TextContentPartSchema & { type: "text" })
-  | RefusalPartSchema
-  | ReasoningPartSchema
-  | RedactedReasoningPartSchema;
+export type DeploymentInvokeContent2 =
+  | (components.TextContentPartSchema & { type: "text" })
+  | components.RefusalPartSchema
+  | components.ReasoningPartSchema
+  | components.RedactedReasoningPartSchema;
 
 /**
  * The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified.
  */
-export type InvokeDeploymentRequestPrefixMessages4Content =
+export type DeploymentInvokePrefixMessagesDeploymentsRequestContent =
   | string
   | Array<
-    | (TextContentPartSchema & { type: "text" })
-    | RefusalPartSchema
-    | ReasoningPartSchema
-    | RedactedReasoningPartSchema
+    | (components.TextContentPartSchema & { type: "text" })
+    | components.RefusalPartSchema
+    | components.ReasoningPartSchema
+    | components.RedactedReasoningPartSchema
   >;
 
 /**
@@ -178,7 +143,7 @@ export type PrefixMessagesFunction = {
   arguments?: string | undefined;
 };
 
-export type ToolCalls = {
+export type PrefixMessagesToolCalls = {
   /**
    * The ID of the tool call.
    */
@@ -201,10 +166,10 @@ export type AssistantMessage = {
   content?:
     | string
     | Array<
-      | (TextContentPartSchema & { type: "text" })
-      | RefusalPartSchema
-      | ReasoningPartSchema
-      | RedactedReasoningPartSchema
+      | (components.TextContentPartSchema & { type: "text" })
+      | components.RefusalPartSchema
+      | components.ReasoningPartSchema
+      | components.RedactedReasoningPartSchema
     >
     | null
     | undefined;
@@ -227,20 +192,20 @@ export type AssistantMessage = {
   /**
    * The tool calls generated by the model, such as function calls.
    */
-  toolCalls?: Array<ToolCalls> | undefined;
+  toolCalls?: Array<PrefixMessagesToolCalls> | undefined;
 };
 
 /**
  * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
  */
-export const InvokeDeploymentRequest2PrefixMessagesType = {
+export const DeploymentInvoke2DeploymentsType = {
   Ephemeral: "ephemeral",
 } as const;
 /**
  * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
  */
-export type InvokeDeploymentRequest2PrefixMessagesType = ClosedEnum<
-  typeof InvokeDeploymentRequest2PrefixMessagesType
+export type DeploymentInvoke2DeploymentsType = ClosedEnum<
+  typeof DeploymentInvoke2DeploymentsType
 >;
 
 /**
@@ -253,7 +218,7 @@ export type InvokeDeploymentRequest2PrefixMessagesType = ClosedEnum<
  *
  * Defaults to `5m`. Only supported by `Anthropic` Claude models.
  */
-export const TwoTtl = {
+export const Ttl = {
   Fivem: "5m",
   Oneh: "1h",
 } as const;
@@ -267,13 +232,13 @@ export const TwoTtl = {
  *
  * Defaults to `5m`. Only supported by `Anthropic` Claude models.
  */
-export type TwoTtl = ClosedEnum<typeof TwoTtl>;
+export type Ttl = ClosedEnum<typeof Ttl>;
 
-export type TwoCacheControl = {
+export type CacheControl = {
   /**
    * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
    */
-  type: InvokeDeploymentRequest2PrefixMessagesType;
+  type: DeploymentInvoke2DeploymentsType;
   /**
    * The time-to-live for the cache control breakpoint. This may be one of the following values:
    *
@@ -284,7 +249,7 @@ export type TwoCacheControl = {
    *
    * Defaults to `5m`. Only supported by `Anthropic` Claude models.
    */
-  ttl?: TwoTtl | undefined;
+  ttl?: Ttl | undefined;
 };
 
 export type Four = {
@@ -292,28 +257,28 @@ export type Four = {
    * The type of the content part. Always `file`.
    */
   type: "file";
-  cacheControl?: TwoCacheControl | undefined;
+  cacheControl?: CacheControl | undefined;
   /**
    * File data for the content part. Must contain either file_data or uri, but not both.
    */
-  file: FileContentPartSchema;
+  file: components.FileContentPartSchema;
 };
 
-export type Two =
-  | (TextContentPartSchema & { type: "text" })
-  | ImageContentPartSchema
-  | AudioContentPartSchema
+export type Content2 =
+  | (components.TextContentPartSchema & { type: "text" })
+  | components.ImageContentPartSchema
+  | components.AudioContentPartSchema
   | Four;
 
 /**
  * The contents of the user message.
  */
-export type InvokeDeploymentRequestPrefixMessagesContent =
+export type DeploymentInvokePrefixMessagesDeploymentsContent =
   | string
   | Array<
-    | (TextContentPartSchema & { type: "text" })
-    | ImageContentPartSchema
-    | AudioContentPartSchema
+    | (components.TextContentPartSchema & { type: "text" })
+    | components.ImageContentPartSchema
+    | components.AudioContentPartSchema
     | Four
   >;
 
@@ -332,9 +297,9 @@ export type UserMessage = {
   content:
     | string
     | Array<
-      | (TextContentPartSchema & { type: "text" })
-      | ImageContentPartSchema
-      | AudioContentPartSchema
+      | (components.TextContentPartSchema & { type: "text" })
+      | components.ImageContentPartSchema
+      | components.AudioContentPartSchema
       | Four
     >;
 };
@@ -342,7 +307,9 @@ export type UserMessage = {
 /**
  * The contents of the developer message.
  */
-export type PrefixMessagesContent = string | Array<TextContentPartSchema>;
+export type DeploymentInvokePrefixMessagesContent =
+  | string
+  | Array<components.TextContentPartSchema>;
 
 export type DeveloperMessage = {
   /**
@@ -352,7 +319,7 @@ export type DeveloperMessage = {
   /**
    * The contents of the developer message.
    */
-  content: string | Array<TextContentPartSchema>;
+  content: string | Array<components.TextContentPartSchema>;
   /**
    * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
    */
@@ -362,7 +329,9 @@ export type DeveloperMessage = {
 /**
  * The contents of the system message.
  */
-export type Content = string | Array<TextContentPartSchema>;
+export type PrefixMessagesContent =
+  | string
+  | Array<components.TextContentPartSchema>;
 
 /**
  * Developer-provided instructions that the model should follow, regardless of messages sent by the user.
@@ -375,7 +344,7 @@ export type SystemMessage = {
   /**
    * The contents of the system message.
    */
-  content: string | Array<TextContentPartSchema>;
+  content: string | Array<components.TextContentPartSchema>;
   /**
    * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
    */
@@ -389,26 +358,27 @@ export type PrefixMessages =
   | AssistantMessage
   | ToolMessage;
 
-export type InvokeDeploymentRequestContentMessages52 = TextContentPartSchema;
+export type DeploymentInvokeContentDeploymentsRequestRequestBodyMessages2 =
+  components.TextContentPartSchema;
 
 /**
  * The contents of the tool message.
  */
-export type InvokeDeploymentRequestMessages5Content =
+export type DeploymentInvokeMessagesDeploymentsRequestRequestBodyContent =
   | string
-  | Array<TextContentPartSchema>;
+  | Array<components.TextContentPartSchema>;
 
 /**
  * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
  */
-export const InvokeDeploymentRequestMessagesType = {
+export const DeploymentInvokeMessagesType = {
   Ephemeral: "ephemeral",
 } as const;
 /**
  * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
  */
-export type InvokeDeploymentRequestMessagesType = ClosedEnum<
-  typeof InvokeDeploymentRequestMessagesType
+export type DeploymentInvokeMessagesType = ClosedEnum<
+  typeof DeploymentInvokeMessagesType
 >;
 
 /**
@@ -441,7 +411,7 @@ export type MessagesCacheControl = {
   /**
    * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
    */
-  type: InvokeDeploymentRequestMessagesType;
+  type: DeploymentInvokeMessagesType;
   /**
    * The time-to-live for the cache control breakpoint. This may be one of the following values:
    *
@@ -463,7 +433,7 @@ export type MessagesToolMessage = {
   /**
    * The contents of the tool message.
    */
-  content: string | Array<TextContentPartSchema>;
+  content: string | Array<components.TextContentPartSchema>;
   /**
    * Tool call that this message is responding to.
    */
@@ -471,22 +441,22 @@ export type MessagesToolMessage = {
   cacheControl?: MessagesCacheControl | undefined;
 };
 
-export type InvokeDeploymentRequestContentMessages42 =
-  | (TextContentPartSchema & { type: "text" })
-  | RefusalPartSchema
-  | ReasoningPartSchema
-  | RedactedReasoningPartSchema;
+export type DeploymentInvokeContentDeploymentsRequestRequestBody2 =
+  | (components.TextContentPartSchema & { type: "text" })
+  | components.RefusalPartSchema
+  | components.ReasoningPartSchema
+  | components.RedactedReasoningPartSchema;
 
 /**
  * The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified.
  */
-export type InvokeDeploymentRequestMessages4Content =
+export type DeploymentInvokeMessagesDeploymentsRequestContent =
   | string
   | Array<
-    | (TextContentPartSchema & { type: "text" })
-    | RefusalPartSchema
-    | ReasoningPartSchema
-    | RedactedReasoningPartSchema
+    | (components.TextContentPartSchema & { type: "text" })
+    | components.RefusalPartSchema
+    | components.ReasoningPartSchema
+    | components.RedactedReasoningPartSchema
   >;
 
 /**
@@ -544,10 +514,10 @@ export type MessagesAssistantMessage = {
   content?:
     | string
     | Array<
-      | (TextContentPartSchema & { type: "text" })
-      | RefusalPartSchema
-      | ReasoningPartSchema
-      | RedactedReasoningPartSchema
+      | (components.TextContentPartSchema & { type: "text" })
+      | components.RefusalPartSchema
+      | components.ReasoningPartSchema
+      | components.RedactedReasoningPartSchema
     >
     | null
     | undefined;
@@ -576,14 +546,14 @@ export type MessagesAssistantMessage = {
 /**
  * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
  */
-export const InvokeDeploymentRequest2MessagesType = {
+export const DeploymentInvoke2DeploymentsRequestRequestBodyType = {
   Ephemeral: "ephemeral",
 } as const;
 /**
  * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
  */
-export type InvokeDeploymentRequest2MessagesType = ClosedEnum<
-  typeof InvokeDeploymentRequest2MessagesType
+export type DeploymentInvoke2DeploymentsRequestRequestBodyType = ClosedEnum<
+  typeof DeploymentInvoke2DeploymentsRequestRequestBodyType
 >;
 
 /**
@@ -596,7 +566,7 @@ export type InvokeDeploymentRequest2MessagesType = ClosedEnum<
  *
  * Defaults to `5m`. Only supported by `Anthropic` Claude models.
  */
-export const InvokeDeploymentRequest2Ttl = {
+export const TwoTtl = {
   Fivem: "5m",
   Oneh: "1h",
 } as const;
@@ -610,15 +580,13 @@ export const InvokeDeploymentRequest2Ttl = {
  *
  * Defaults to `5m`. Only supported by `Anthropic` Claude models.
  */
-export type InvokeDeploymentRequest2Ttl = ClosedEnum<
-  typeof InvokeDeploymentRequest2Ttl
->;
+export type TwoTtl = ClosedEnum<typeof TwoTtl>;
 
-export type InvokeDeploymentRequest2CacheControl = {
+export type TwoCacheControl = {
   /**
    * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
    */
-  type: InvokeDeploymentRequest2MessagesType;
+  type: DeploymentInvoke2DeploymentsRequestRequestBodyType;
   /**
    * The time-to-live for the cache control breakpoint. This may be one of the following values:
    *
@@ -629,7 +597,7 @@ export type InvokeDeploymentRequest2CacheControl = {
    *
    * Defaults to `5m`. Only supported by `Anthropic` Claude models.
    */
-  ttl?: InvokeDeploymentRequest2Ttl | undefined;
+  ttl?: TwoTtl | undefined;
 };
 
 export type Two4 = {
@@ -637,28 +605,28 @@ export type Two4 = {
    * The type of the content part. Always `file`.
    */
   type: "file";
-  cacheControl?: InvokeDeploymentRequest2CacheControl | undefined;
+  cacheControl?: TwoCacheControl | undefined;
   /**
    * File data for the content part. Must contain either file_data or uri, but not both.
    */
-  file: FileContentPartSchema;
+  file: components.FileContentPartSchema;
 };
 
-export type InvokeDeploymentRequestContentMessages2 =
-  | (TextContentPartSchema & { type: "text" })
-  | ImageContentPartSchema
-  | AudioContentPartSchema
+export type DeploymentInvokeContentDeploymentsRequest2 =
+  | (components.TextContentPartSchema & { type: "text" })
+  | components.ImageContentPartSchema
+  | components.AudioContentPartSchema
   | Two4;
 
 /**
  * The contents of the user message.
  */
-export type InvokeDeploymentRequestMessages3Content =
+export type DeploymentInvokeMessagesDeploymentsContent =
   | string
   | Array<
-    | (TextContentPartSchema & { type: "text" })
-    | ImageContentPartSchema
-    | AudioContentPartSchema
+    | (components.TextContentPartSchema & { type: "text" })
+    | components.ImageContentPartSchema
+    | components.AudioContentPartSchema
     | Two4
   >;
 
@@ -677,9 +645,9 @@ export type MessagesUserMessage = {
   content:
     | string
     | Array<
-      | (TextContentPartSchema & { type: "text" })
-      | ImageContentPartSchema
-      | AudioContentPartSchema
+      | (components.TextContentPartSchema & { type: "text" })
+      | components.ImageContentPartSchema
+      | components.AudioContentPartSchema
       | Two4
     >;
 };
@@ -687,9 +655,9 @@ export type MessagesUserMessage = {
 /**
  * The contents of the developer message.
  */
-export type InvokeDeploymentRequestMessagesContent =
+export type DeploymentInvokeMessagesContent =
   | string
-  | Array<TextContentPartSchema>;
+  | Array<components.TextContentPartSchema>;
 
 export type MessagesDeveloperMessage = {
   /**
@@ -699,7 +667,7 @@ export type MessagesDeveloperMessage = {
   /**
    * The contents of the developer message.
    */
-  content: string | Array<TextContentPartSchema>;
+  content: string | Array<components.TextContentPartSchema>;
   /**
    * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
    */
@@ -709,7 +677,7 @@ export type MessagesDeveloperMessage = {
 /**
  * The contents of the system message.
  */
-export type MessagesContent = string | Array<TextContentPartSchema>;
+export type MessagesContent = string | Array<components.TextContentPartSchema>;
 
 /**
  * Developer-provided instructions that the model should follow, regardless of messages sent by the user.
@@ -722,14 +690,14 @@ export type MessagesSystemMessage = {
   /**
    * The contents of the system message.
    */
-  content: string | Array<TextContentPartSchema>;
+  content: string | Array<components.TextContentPartSchema>;
   /**
    * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
    */
   name?: string | undefined;
 };
 
-export type Messages =
+export type DeploymentInvokeMessages =
   | MessagesSystemMessage
   | MessagesDeveloperMessage
   | MessagesUserMessage
@@ -798,21 +766,21 @@ export type OrExists = {
   exists: boolean;
 };
 
-export type OrNin = string | number | boolean;
+export type DeploymentInvokeOrNin = string | number | boolean;
 
 /**
  * Not in
  */
-export type InvokeDeploymentRequestOrNin = {
+export type OrNin = {
   nin: Array<string | number | boolean>;
 };
 
-export type OrIn = string | number | boolean;
+export type DeploymentInvokeOrIn = string | number | boolean;
 
 /**
  * In
  */
-export type InvokeDeploymentRequestOrIn = {
+export type OrIn = {
   in: Array<string | number | boolean>;
 };
 
@@ -844,50 +812,50 @@ export type OrGt = {
   gt: number;
 };
 
-export type OrNe = string | number | boolean;
+export type DeploymentInvokeOrNe = string | number | boolean;
 
 /**
  * Not equal to
  */
-export type InvokeDeploymentRequestOrNe = {
+export type OrNe = {
   ne: string | number | boolean;
 };
 
-export type OrEq = string | number | boolean;
+export type DeploymentInvokeOrEq = string | number | boolean;
 
 /**
  * Equal to
  */
-export type InvokeDeploymentRequestOrEq = {
+export type OrEq = {
   eq: string | number | boolean;
 };
 
-export type Or =
-  | InvokeDeploymentRequestOrEq
-  | InvokeDeploymentRequestOrNe
+export type KnowledgeFilterOr =
+  | OrEq
+  | OrNe
   | OrGt
   | OrGte
   | OrLt
   | OrLte
-  | InvokeDeploymentRequestOrIn
-  | InvokeDeploymentRequestOrNin
+  | OrIn
+  | OrNin
   | OrExists;
 
 /**
  * Or
  */
-export type KnowledgeFilterOr = {
+export type Or = {
   or: Array<
     {
       [k: string]:
-        | InvokeDeploymentRequestOrEq
-        | InvokeDeploymentRequestOrNe
+        | OrEq
+        | OrNe
         | OrGt
         | OrGte
         | OrLt
         | OrLte
-        | InvokeDeploymentRequestOrIn
-        | InvokeDeploymentRequestOrNin
+        | OrIn
+        | OrNin
         | OrExists;
     }
   >;
@@ -900,21 +868,21 @@ export type AndExists = {
   exists: boolean;
 };
 
-export type AndNin = string | number | boolean;
+export type DeploymentInvokeAndNin = string | number | boolean;
 
 /**
  * Not in
  */
-export type InvokeDeploymentRequestAndNin = {
+export type AndNin = {
   nin: Array<string | number | boolean>;
 };
 
-export type AndIn = string | number | boolean;
+export type DeploymentInvokeAndIn = string | number | boolean;
 
 /**
  * In
  */
-export type InvokeDeploymentRequestAndIn = {
+export type AndIn = {
   in: Array<string | number | boolean>;
 };
 
@@ -946,50 +914,50 @@ export type AndGt = {
   gt: number;
 };
 
-export type AndNe = string | number | boolean;
+export type DeploymentInvokeAndNe = string | number | boolean;
 
 /**
  * Not equal to
  */
-export type InvokeDeploymentRequestAndNe = {
+export type AndNe = {
   ne: string | number | boolean;
 };
 
-export type AndEq = string | number | boolean;
+export type DeploymentInvokeAndEq = string | number | boolean;
 
 /**
  * Equal to
  */
-export type InvokeDeploymentRequestAndEq = {
+export type AndEq = {
   eq: string | number | boolean;
 };
 
-export type And =
-  | InvokeDeploymentRequestAndEq
-  | InvokeDeploymentRequestAndNe
+export type KnowledgeFilterAnd =
+  | AndEq
+  | AndNe
   | AndGt
   | AndGte
   | AndLt
   | AndLte
-  | InvokeDeploymentRequestAndIn
-  | InvokeDeploymentRequestAndNin
+  | AndIn
+  | AndNin
   | AndExists;
 
 /**
  * And
  */
-export type KnowledgeFilterAnd = {
+export type And = {
   and: Array<
     {
       [k: string]:
-        | InvokeDeploymentRequestAndEq
-        | InvokeDeploymentRequestAndNe
+        | AndEq
+        | AndNe
         | AndGt
         | AndGte
         | AndLt
         | AndLte
-        | InvokeDeploymentRequestAndIn
-        | InvokeDeploymentRequestAndNin
+        | AndIn
+        | AndNin
         | AndExists;
     }
   >;
@@ -1002,21 +970,21 @@ export type Exists = {
   exists: boolean;
 };
 
-export type Nin = string | number | boolean;
+export type OneNin = string | number | boolean;
 
 /**
  * Not in
  */
-export type OneNin = {
+export type Nin = {
   nin: Array<string | number | boolean>;
 };
 
-export type In = string | number | boolean;
+export type OneIn = string | number | boolean;
 
 /**
  * In
  */
-export type OneIn = {
+export type In = {
   in: Array<string | number | boolean>;
 };
 
@@ -1048,37 +1016,43 @@ export type Gt = {
   gt: number;
 };
 
-export type Ne = string | number | boolean;
+export type OneNe = string | number | boolean;
 
 /**
  * Not equal to
  */
-export type OneNe = {
+export type Ne = {
   ne: string | number | boolean;
 };
 
-export type Eq = string | number | boolean;
+export type OneEq = string | number | boolean;
 
 /**
  * Equal to
  */
-export type OneEq = {
+export type Eq = {
   eq: string | number | boolean;
 };
 
-export type One = OneEq | OneNe | Gt | Gte | Lt | Lte | OneIn | OneNin | Exists;
+export type KnowledgeFilter1 =
+  | Eq
+  | Ne
+  | Gt
+  | Gte
+  | Lt
+  | Lte
+  | In
+  | Nin
+  | Exists;
 
 /**
  * A filter to apply to the knowledge base chunk metadata when using  knowledge bases in the deployment.
  */
-export type KnowledgeFilter = KnowledgeFilterAnd | KnowledgeFilterOr | {
-  [k: string]: OneEq | OneNe | Gt | Gte | Lt | Lte | OneIn | OneNin | Exists;
+export type KnowledgeFilter = And | Or | {
+  [k: string]: Eq | Ne | Gt | Gte | Lt | Lte | In | Nin | Exists;
 };
 
-/**
- * The deployment request payload
- */
-export type InvokeDeploymentRequest = {
+export type DeploymentInvokeRequestBody = {
   /**
    * The deployment key to invoke
    */
@@ -1122,7 +1096,7 @@ export type InvokeDeploymentRequest = {
   /**
    * Information about the identity making the request. If the identity does not exist, it will be created automatically.
    */
-  identity?: PublicIdentity | undefined;
+  identity?: components.PublicIdentity | undefined;
   /**
    * A list of file IDs that are associated with the deployment request.
    */
@@ -1144,60 +1118,390 @@ export type InvokeDeploymentRequest = {
   /**
    * A filter to apply to the knowledge base chunk metadata when using  knowledge bases in the deployment.
    */
-  knowledgeFilter?: KnowledgeFilterAnd | KnowledgeFilterOr | {
-    [k: string]: OneEq | OneNe | Gt | Gte | Lt | Lte | OneIn | OneNin | Exists;
+  knowledgeFilter?: And | Or | {
+    [k: string]: Eq | Ne | Gt | Gte | Lt | Lte | In | Nin | Exists;
   } | undefined;
 };
 
+/**
+ * Indicates the type of model used to generate the response
+ */
+export const DeploymentInvokeObject = {
+  Chat: "chat",
+  Completion: "completion",
+  Image: "image",
+} as const;
+/**
+ * Indicates the type of model used to generate the response
+ */
+export type DeploymentInvokeObject = ClosedEnum<typeof DeploymentInvokeObject>;
+
+/**
+ * The provider used to generate the response
+ */
+export const Provider = {
+  Openai: "openai",
+  Groq: "groq",
+  Cohere: "cohere",
+  Azure: "azure",
+  Aws: "aws",
+  Google: "google",
+  GoogleAi: "google-ai",
+  Huggingface: "huggingface",
+  Togetherai: "togetherai",
+  Perplexity: "perplexity",
+  Anthropic: "anthropic",
+  Leonardoai: "leonardoai",
+  Fal: "fal",
+  Nvidia: "nvidia",
+  Jina: "jina",
+  Elevenlabs: "elevenlabs",
+  Litellm: "litellm",
+  Cerebras: "cerebras",
+  Openailike: "openailike",
+  Bytedance: "bytedance",
+  Mistral: "mistral",
+  Deepseek: "deepseek",
+  Contextualai: "contextualai",
+  Moonshotai: "moonshotai",
+  Zai: "zai",
+  Minimax: "minimax",
+  Xai: "xai",
+  Alibaba: "alibaba",
+  Tensorix: "tensorix",
+  Scaleway: "scaleway",
+  Hcompany: "hcompany",
+  Inceptron: "inceptron",
+  Slack: "slack",
+  Orq: "orq",
+} as const;
+/**
+ * The provider used to generate the response
+ */
+export type Provider = ClosedEnum<typeof Provider>;
+
+export type Telemetry = {
+  /**
+   * The trace id for the request that generated this response
+   */
+  traceId: string;
+  /**
+   * The span id for the request that generated this response
+   */
+  spanId: string;
+};
+
+/**
+ * Metadata of the retrieved chunk from the knowledge base
+ */
+export type DeploymentInvokeMetadata = {
+  /**
+   * Name of the file
+   */
+  fileName: string;
+  /**
+   * Page number of the chunk
+   */
+  pageNumber: number | null;
+  /**
+   * Type of the file
+   */
+  fileType: string;
+  /**
+   * Rerank scores are normalized to be in the range [0, 1]. Scores close to 1 indicate a high relevance to the query, and scores closer to 0 indicate low relevance. It is not accurate to assume a score of 0.9 means the document is 2x more relevant than a document with a score of 0.45
+   */
+  rerankScore?: number | undefined;
+  /**
+   * Search scores are normalized to be in the range [0, 1]. Search score is calculated based on `[Cosine Similarity](https://en.wikipedia.org/wiki/Cosine_similarity)` algorithm. Scores close to 1 indicate the document is closer to the query, and scores closer to 0 indicate the document is farther from the query.
+   */
+  searchScore: number;
+};
+
+export type Retrievals = {
+  /**
+   * Content of the retrieved chunk from the knowledge base
+   */
+  document: string;
+  /**
+   * Metadata of the retrieved chunk from the knowledge base
+   */
+  metadata: DeploymentInvokeMetadata;
+};
+
+export type PromptTokensDetails = {
+  cachedTokens?: number | null | undefined;
+};
+
+export type CompletionTokensDetails = {
+  reasoningTokens?: number | null | undefined;
+};
+
+/**
+ * Usage metrics for the response
+ */
+export type Usage = {
+  totalTokens?: number | undefined;
+  promptTokens?: number | undefined;
+  completionTokens?: number | undefined;
+  promptTokensDetails?: PromptTokensDetails | undefined;
+  completionTokensDetails?: CompletionTokensDetails | null | undefined;
+};
+
+/**
+ * The role of the prompt message
+ */
+export const DeploymentInvokeMessageDeploymentsRole = {
+  System: "system",
+  Developer: "developer",
+  Assistant: "assistant",
+  User: "user",
+  Exception: "exception",
+  Tool: "tool",
+  Prompt: "prompt",
+  Correction: "correction",
+  ExpectedOutput: "expected_output",
+} as const;
+/**
+ * The role of the prompt message
+ */
+export type DeploymentInvokeMessageDeploymentsRole = ClosedEnum<
+  typeof DeploymentInvokeMessageDeploymentsRole
+>;
+
+export type Message3 = {
+  type: "image";
+  /**
+   * The role of the prompt message
+   */
+  role: DeploymentInvokeMessageDeploymentsRole;
+  url: string;
+};
+
+/**
+ * The role of the prompt message
+ */
+export const DeploymentInvokeMessageRole = {
+  System: "system",
+  Developer: "developer",
+  Assistant: "assistant",
+  User: "user",
+  Exception: "exception",
+  Tool: "tool",
+  Prompt: "prompt",
+  Correction: "correction",
+  ExpectedOutput: "expected_output",
+} as const;
+/**
+ * The role of the prompt message
+ */
+export type DeploymentInvokeMessageRole = ClosedEnum<
+  typeof DeploymentInvokeMessageRole
+>;
+
+export type Message2 = {
+  type: "content";
+  /**
+   * The role of the prompt message
+   */
+  role: DeploymentInvokeMessageRole;
+  content: string | null;
+  /**
+   * Internal thought process of the model
+   */
+  reasoning?: string | undefined;
+  /**
+   * The signature holds a cryptographic token which verifies that the thinking block was generated by the model, and is verified when thinking is part of a multiturn conversation. This value should not be modified and should always be sent to the API when the reasoning is redacted. Currently only supported by `Anthropic`.
+   */
+  reasoningSignature?: string | undefined;
+  /**
+   * Occasionally the model's internal reasoning will be flagged by the safety systems of the provider. When this occurs, the provider will encrypt the reasoning. These redacted reasoning is decrypted when passed back to the API, allowing the model to continue its response without losing context.
+   */
+  redactedReasoning?: string | undefined;
+};
+
+/**
+ * The role of the prompt message
+ */
+export const MessageRole = {
+  System: "system",
+  Developer: "developer",
+  Assistant: "assistant",
+  User: "user",
+  Exception: "exception",
+  Tool: "tool",
+  Prompt: "prompt",
+  Correction: "correction",
+  ExpectedOutput: "expected_output",
+} as const;
+/**
+ * The role of the prompt message
+ */
+export type MessageRole = ClosedEnum<typeof MessageRole>;
+
+export const DeploymentInvokeMessageDeploymentsResponseType = {
+  Function: "function",
+} as const;
+export type DeploymentInvokeMessageDeploymentsResponseType = ClosedEnum<
+  typeof DeploymentInvokeMessageDeploymentsResponseType
+>;
+
+export type MessageFunction = {
+  name: string;
+  /**
+   * JSON string arguments for the functions
+   */
+  arguments: string;
+};
+
+export type MessageToolCalls = {
+  id?: string | undefined;
+  index?: number | undefined;
+  type: DeploymentInvokeMessageDeploymentsResponseType;
+  function: MessageFunction;
+};
+
+export type Message1 = {
+  type: "tool_calls";
+  /**
+   * The role of the prompt message
+   */
+  role: MessageRole;
+  content?: string | null | undefined;
+  toolCalls: Array<MessageToolCalls>;
+  /**
+   * Internal thought process of the model
+   */
+  reasoning?: string | undefined;
+  /**
+   * The signature holds a cryptographic token which verifies that the thinking block was generated by the model, and is verified when thinking is part of a multiturn conversation. This value should not be modified and should always be sent to the API when the reasoning is redacted. Currently only supported by `Anthropic`.
+   */
+  reasoningSignature?: string | undefined;
+  /**
+   * Occasionally the model's internal reasoning will be flagged by the safety systems of the provider. When this occurs, the provider will encrypt the reasoning. These redacted reasoning is decrypted when passed back to the API, allowing the model to continue its response without losing context.
+   */
+  redactedReasoning?: string | undefined;
+};
+
+export type Message = Message1 | Message2 | Message3;
+
+export type Choices = {
+  index: number;
+  message: Message1 | Message2 | Message3;
+  finishReason?: string | null | undefined;
+};
+
+/**
+ * Successful operation
+ */
+export type DeploymentInvokeResponseBody = {
+  /**
+   * A unique identifier for the response. Can be used to add metrics to the transaction.
+   */
+  id: string;
+  /**
+   * A timestamp indicating when the object was created. Usually in a standardized format like ISO 8601
+   */
+  created: Date;
+  /**
+   * Indicates the type of model used to generate the response
+   */
+  object: DeploymentInvokeObject;
+  /**
+   * The model used to generate the response
+   */
+  model: string;
+  /**
+   * The provider used to generate the response
+   */
+  provider: Provider;
+  /**
+   * Indicates if the response is the final response
+   */
+  isFinal: boolean;
+  /**
+   * Indicates integration id used to generate the response
+   */
+  integrationId?: string | undefined;
+  telemetry: Telemetry;
+  /**
+   * A timestamp indicating when the object was finalized. Usually in a standardized format like ISO 8601
+   */
+  finalized?: Date | undefined;
+  /**
+   * Provider backed system fingerprint.
+   */
+  systemFingerprint?: string | null | undefined;
+  /**
+   * List of documents retrieved from the knowledge base. This property is only available when the `include_retrievals` flag is set to `true` in the invoke settings. When stream is set to true, the `retrievals` property will be returned in the last streamed chunk where the property `is_final` is set to `true`.
+   */
+  retrievals?: Array<Retrievals> | undefined;
+  /**
+   * Response returned by the model provider. This functionality is only supported when streaming is not used. If streaming is used, the `provider_response` property will be set to `null`.
+   */
+  providerResponse?: any | undefined;
+  /**
+   * Usage metrics for the response
+   */
+  usage?: Usage | null | undefined;
+  /**
+   * A list of choices generated by the model
+   */
+  choices: Array<Choices>;
+};
+
 /** @internal */
-export type InvokeDeploymentRequestContent2$Outbound =
-  TextContentPartSchema$Outbound;
+export type DeploymentInvokeContentDeployments2$Outbound =
+  components.TextContentPartSchema$Outbound;
 
 /** @internal */
-export const InvokeDeploymentRequestContent2$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestContent2$Outbound,
+export const DeploymentInvokeContentDeployments2$outboundSchema: z.ZodType<
+  DeploymentInvokeContentDeployments2$Outbound,
   z.ZodTypeDef,
-  InvokeDeploymentRequestContent2
-> = TextContentPartSchema$outboundSchema;
+  DeploymentInvokeContentDeployments2
+> = components.TextContentPartSchema$outboundSchema;
 
-export function invokeDeploymentRequestContent2ToJSON(
-  invokeDeploymentRequestContent2: InvokeDeploymentRequestContent2,
+export function deploymentInvokeContentDeployments2ToJSON(
+  deploymentInvokeContentDeployments2: DeploymentInvokeContentDeployments2,
 ): string {
   return JSON.stringify(
-    InvokeDeploymentRequestContent2$outboundSchema.parse(
-      invokeDeploymentRequestContent2,
+    DeploymentInvokeContentDeployments2$outboundSchema.parse(
+      deploymentInvokeContentDeployments2,
     ),
   );
 }
 
 /** @internal */
-export type InvokeDeploymentRequestPrefixMessages5Content$Outbound =
+export type DeploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent$Outbound =
   | string
-  | Array<TextContentPartSchema$Outbound>;
+  | Array<components.TextContentPartSchema$Outbound>;
 
 /** @internal */
-export const InvokeDeploymentRequestPrefixMessages5Content$outboundSchema:
+export const DeploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent$outboundSchema:
   z.ZodType<
-    InvokeDeploymentRequestPrefixMessages5Content$Outbound,
+    DeploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent$Outbound,
     z.ZodTypeDef,
-    InvokeDeploymentRequestPrefixMessages5Content
-  > = z.union([z.string(), z.array(TextContentPartSchema$outboundSchema)]);
+    DeploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent
+  > = z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]);
 
-export function invokeDeploymentRequestPrefixMessages5ContentToJSON(
-  invokeDeploymentRequestPrefixMessages5Content:
-    InvokeDeploymentRequestPrefixMessages5Content,
+export function deploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContentToJSON(
+  deploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent:
+    DeploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent,
 ): string {
   return JSON.stringify(
-    InvokeDeploymentRequestPrefixMessages5Content$outboundSchema.parse(
-      invokeDeploymentRequestPrefixMessages5Content,
-    ),
+    DeploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent$outboundSchema
+      .parse(
+        deploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent,
+      ),
   );
 }
 
 /** @internal */
-export const InvokeDeploymentRequestPrefixMessagesType$outboundSchema:
-  z.ZodNativeEnum<typeof InvokeDeploymentRequestPrefixMessagesType> = z
-    .nativeEnum(InvokeDeploymentRequestPrefixMessagesType);
+export const DeploymentInvokePrefixMessagesType$outboundSchema: z.ZodNativeEnum<
+  typeof DeploymentInvokePrefixMessagesType
+> = z.nativeEnum(DeploymentInvokePrefixMessagesType);
 
 /** @internal */
 export const PrefixMessagesTtl$outboundSchema: z.ZodNativeEnum<
@@ -1216,7 +1520,7 @@ export const PrefixMessagesCacheControl$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   PrefixMessagesCacheControl
 > = z.object({
-  type: InvokeDeploymentRequestPrefixMessagesType$outboundSchema,
+  type: DeploymentInvokePrefixMessagesType$outboundSchema,
   ttl: PrefixMessagesTtl$outboundSchema.default("5m"),
 });
 
@@ -1231,7 +1535,7 @@ export function prefixMessagesCacheControlToJSON(
 /** @internal */
 export type ToolMessage$Outbound = {
   role: "tool";
-  content: string | Array<TextContentPartSchema$Outbound>;
+  content: string | Array<components.TextContentPartSchema$Outbound>;
   tool_call_id: string | null;
   cache_control?: PrefixMessagesCacheControl$Outbound | undefined;
 };
@@ -1243,7 +1547,10 @@ export const ToolMessage$outboundSchema: z.ZodType<
   ToolMessage
 > = z.object({
   role: z.literal("tool"),
-  content: z.union([z.string(), z.array(TextContentPartSchema$outboundSchema)]),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]),
   toolCallId: z.nullable(z.string()),
   cacheControl: z.lazy(() => PrefixMessagesCacheControl$outboundSchema)
     .optional(),
@@ -1259,68 +1566,71 @@ export function toolMessageToJSON(toolMessage: ToolMessage): string {
 }
 
 /** @internal */
-export type Content2$Outbound =
-  | (TextContentPartSchema$Outbound & { type: "text" })
-  | RefusalPartSchema$Outbound
-  | ReasoningPartSchema$Outbound
-  | RedactedReasoningPartSchema$Outbound;
+export type DeploymentInvokeContent2$Outbound =
+  | (components.TextContentPartSchema$Outbound & { type: "text" })
+  | components.RefusalPartSchema$Outbound
+  | components.ReasoningPartSchema$Outbound
+  | components.RedactedReasoningPartSchema$Outbound;
 
 /** @internal */
-export const Content2$outboundSchema: z.ZodType<
-  Content2$Outbound,
+export const DeploymentInvokeContent2$outboundSchema: z.ZodType<
+  DeploymentInvokeContent2$Outbound,
   z.ZodTypeDef,
-  Content2
+  DeploymentInvokeContent2
 > = z.union([
-  TextContentPartSchema$outboundSchema.and(
+  components.TextContentPartSchema$outboundSchema.and(
     z.object({ type: z.literal("text") }),
   ),
-  RefusalPartSchema$outboundSchema,
-  ReasoningPartSchema$outboundSchema,
-  RedactedReasoningPartSchema$outboundSchema,
+  components.RefusalPartSchema$outboundSchema,
+  components.ReasoningPartSchema$outboundSchema,
+  components.RedactedReasoningPartSchema$outboundSchema,
 ]);
 
-export function content2ToJSON(content2: Content2): string {
-  return JSON.stringify(Content2$outboundSchema.parse(content2));
+export function deploymentInvokeContent2ToJSON(
+  deploymentInvokeContent2: DeploymentInvokeContent2,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeContent2$outboundSchema.parse(deploymentInvokeContent2),
+  );
 }
 
 /** @internal */
-export type InvokeDeploymentRequestPrefixMessages4Content$Outbound =
+export type DeploymentInvokePrefixMessagesDeploymentsRequestContent$Outbound =
   | string
   | Array<
-    | (TextContentPartSchema$Outbound & { type: "text" })
-    | RefusalPartSchema$Outbound
-    | ReasoningPartSchema$Outbound
-    | RedactedReasoningPartSchema$Outbound
+    | (components.TextContentPartSchema$Outbound & { type: "text" })
+    | components.RefusalPartSchema$Outbound
+    | components.ReasoningPartSchema$Outbound
+    | components.RedactedReasoningPartSchema$Outbound
   >;
 
 /** @internal */
-export const InvokeDeploymentRequestPrefixMessages4Content$outboundSchema:
+export const DeploymentInvokePrefixMessagesDeploymentsRequestContent$outboundSchema:
   z.ZodType<
-    InvokeDeploymentRequestPrefixMessages4Content$Outbound,
+    DeploymentInvokePrefixMessagesDeploymentsRequestContent$Outbound,
     z.ZodTypeDef,
-    InvokeDeploymentRequestPrefixMessages4Content
+    DeploymentInvokePrefixMessagesDeploymentsRequestContent
   > = z.union([
     z.string(),
     z.array(
       z.union([
-        TextContentPartSchema$outboundSchema.and(
+        components.TextContentPartSchema$outboundSchema.and(
           z.object({ type: z.literal("text") }),
         ),
-        RefusalPartSchema$outboundSchema,
-        ReasoningPartSchema$outboundSchema,
-        RedactedReasoningPartSchema$outboundSchema,
+        components.RefusalPartSchema$outboundSchema,
+        components.ReasoningPartSchema$outboundSchema,
+        components.RedactedReasoningPartSchema$outboundSchema,
       ]),
     ),
   ]);
 
-export function invokeDeploymentRequestPrefixMessages4ContentToJSON(
-  invokeDeploymentRequestPrefixMessages4Content:
-    InvokeDeploymentRequestPrefixMessages4Content,
+export function deploymentInvokePrefixMessagesDeploymentsRequestContentToJSON(
+  deploymentInvokePrefixMessagesDeploymentsRequestContent:
+    DeploymentInvokePrefixMessagesDeploymentsRequestContent,
 ): string {
   return JSON.stringify(
-    InvokeDeploymentRequestPrefixMessages4Content$outboundSchema.parse(
-      invokeDeploymentRequestPrefixMessages4Content,
-    ),
+    DeploymentInvokePrefixMessagesDeploymentsRequestContent$outboundSchema
+      .parse(deploymentInvokePrefixMessagesDeploymentsRequestContent),
   );
 }
 
@@ -1372,7 +1682,7 @@ export function prefixMessagesFunctionToJSON(
 }
 
 /** @internal */
-export type ToolCalls$Outbound = {
+export type PrefixMessagesToolCalls$Outbound = {
   id: string;
   type: string;
   function: PrefixMessagesFunction$Outbound;
@@ -1380,10 +1690,10 @@ export type ToolCalls$Outbound = {
 };
 
 /** @internal */
-export const ToolCalls$outboundSchema: z.ZodType<
-  ToolCalls$Outbound,
+export const PrefixMessagesToolCalls$outboundSchema: z.ZodType<
+  PrefixMessagesToolCalls$Outbound,
   z.ZodTypeDef,
-  ToolCalls
+  PrefixMessagesToolCalls
 > = z.object({
   id: z.string(),
   type: PrefixMessagesType$outboundSchema,
@@ -1395,8 +1705,12 @@ export const ToolCalls$outboundSchema: z.ZodType<
   });
 });
 
-export function toolCallsToJSON(toolCalls: ToolCalls): string {
-  return JSON.stringify(ToolCalls$outboundSchema.parse(toolCalls));
+export function prefixMessagesToolCallsToJSON(
+  prefixMessagesToolCalls: PrefixMessagesToolCalls,
+): string {
+  return JSON.stringify(
+    PrefixMessagesToolCalls$outboundSchema.parse(prefixMessagesToolCalls),
+  );
 }
 
 /** @internal */
@@ -1404,10 +1718,10 @@ export type AssistantMessage$Outbound = {
   content?:
     | string
     | Array<
-      | (TextContentPartSchema$Outbound & { type: "text" })
-      | RefusalPartSchema$Outbound
-      | ReasoningPartSchema$Outbound
-      | RedactedReasoningPartSchema$Outbound
+      | (components.TextContentPartSchema$Outbound & { type: "text" })
+      | components.RefusalPartSchema$Outbound
+      | components.ReasoningPartSchema$Outbound
+      | components.RedactedReasoningPartSchema$Outbound
     >
     | null
     | undefined;
@@ -1415,7 +1729,7 @@ export type AssistantMessage$Outbound = {
   role: "assistant";
   name?: string | undefined;
   audio?: Audio$Outbound | null | undefined;
-  tool_calls?: Array<ToolCalls$Outbound> | undefined;
+  tool_calls?: Array<PrefixMessagesToolCalls$Outbound> | undefined;
 };
 
 /** @internal */
@@ -1429,12 +1743,12 @@ export const AssistantMessage$outboundSchema: z.ZodType<
       z.string(),
       z.array(
         z.union([
-          TextContentPartSchema$outboundSchema.and(
+          components.TextContentPartSchema$outboundSchema.and(
             z.object({ type: z.literal("text") }),
           ),
-          RefusalPartSchema$outboundSchema,
-          ReasoningPartSchema$outboundSchema,
-          RedactedReasoningPartSchema$outboundSchema,
+          components.RefusalPartSchema$outboundSchema,
+          components.ReasoningPartSchema$outboundSchema,
+          components.RedactedReasoningPartSchema$outboundSchema,
         ]),
       ),
     ]),
@@ -1443,7 +1757,8 @@ export const AssistantMessage$outboundSchema: z.ZodType<
   role: z.literal("assistant"),
   name: z.string().optional(),
   audio: z.nullable(z.lazy(() => Audio$outboundSchema)).optional(),
-  toolCalls: z.array(z.lazy(() => ToolCalls$outboundSchema)).optional(),
+  toolCalls: z.array(z.lazy(() => PrefixMessagesToolCalls$outboundSchema))
+    .optional(),
 }).transform((v) => {
   return remap$(v, {
     toolCalls: "tool_calls",
@@ -1459,49 +1774,48 @@ export function assistantMessageToJSON(
 }
 
 /** @internal */
-export const InvokeDeploymentRequest2PrefixMessagesType$outboundSchema:
-  z.ZodNativeEnum<typeof InvokeDeploymentRequest2PrefixMessagesType> = z
-    .nativeEnum(InvokeDeploymentRequest2PrefixMessagesType);
+export const DeploymentInvoke2DeploymentsType$outboundSchema: z.ZodNativeEnum<
+  typeof DeploymentInvoke2DeploymentsType
+> = z.nativeEnum(DeploymentInvoke2DeploymentsType);
 
 /** @internal */
-export const TwoTtl$outboundSchema: z.ZodNativeEnum<typeof TwoTtl> = z
-  .nativeEnum(TwoTtl);
+export const Ttl$outboundSchema: z.ZodNativeEnum<typeof Ttl> = z.nativeEnum(
+  Ttl,
+);
 
 /** @internal */
-export type TwoCacheControl$Outbound = {
+export type CacheControl$Outbound = {
   type: string;
   ttl: string;
 };
 
 /** @internal */
-export const TwoCacheControl$outboundSchema: z.ZodType<
-  TwoCacheControl$Outbound,
+export const CacheControl$outboundSchema: z.ZodType<
+  CacheControl$Outbound,
   z.ZodTypeDef,
-  TwoCacheControl
+  CacheControl
 > = z.object({
-  type: InvokeDeploymentRequest2PrefixMessagesType$outboundSchema,
-  ttl: TwoTtl$outboundSchema.default("5m"),
+  type: DeploymentInvoke2DeploymentsType$outboundSchema,
+  ttl: Ttl$outboundSchema.default("5m"),
 });
 
-export function twoCacheControlToJSON(
-  twoCacheControl: TwoCacheControl,
-): string {
-  return JSON.stringify(TwoCacheControl$outboundSchema.parse(twoCacheControl));
+export function cacheControlToJSON(cacheControl: CacheControl): string {
+  return JSON.stringify(CacheControl$outboundSchema.parse(cacheControl));
 }
 
 /** @internal */
 export type Four$Outbound = {
   type: "file";
-  cache_control?: TwoCacheControl$Outbound | undefined;
-  file: FileContentPartSchema$Outbound;
+  cache_control?: CacheControl$Outbound | undefined;
+  file: components.FileContentPartSchema$Outbound;
 };
 
 /** @internal */
 export const Four$outboundSchema: z.ZodType<Four$Outbound, z.ZodTypeDef, Four> =
   z.object({
     type: z.literal("file"),
-    cacheControl: z.lazy(() => TwoCacheControl$outboundSchema).optional(),
-    file: FileContentPartSchema$outboundSchema,
+    cacheControl: z.lazy(() => CacheControl$outboundSchema).optional(),
+    file: components.FileContentPartSchema$outboundSchema,
   }).transform((v) => {
     return remap$(v, {
       cacheControl: "cache_control",
@@ -1513,64 +1827,67 @@ export function fourToJSON(four: Four): string {
 }
 
 /** @internal */
-export type Two$Outbound =
-  | (TextContentPartSchema$Outbound & { type: "text" })
-  | ImageContentPartSchema$Outbound
-  | AudioContentPartSchema$Outbound
+export type Content2$Outbound =
+  | (components.TextContentPartSchema$Outbound & { type: "text" })
+  | components.ImageContentPartSchema$Outbound
+  | components.AudioContentPartSchema$Outbound
   | Four$Outbound;
 
 /** @internal */
-export const Two$outboundSchema: z.ZodType<Two$Outbound, z.ZodTypeDef, Two> = z
-  .union([
-    TextContentPartSchema$outboundSchema.and(
-      z.object({ type: z.literal("text") }),
-    ),
-    ImageContentPartSchema$outboundSchema,
-    AudioContentPartSchema$outboundSchema,
-    z.lazy(() => Four$outboundSchema),
-  ]);
+export const Content2$outboundSchema: z.ZodType<
+  Content2$Outbound,
+  z.ZodTypeDef,
+  Content2
+> = z.union([
+  components.TextContentPartSchema$outboundSchema.and(
+    z.object({ type: z.literal("text") }),
+  ),
+  components.ImageContentPartSchema$outboundSchema,
+  components.AudioContentPartSchema$outboundSchema,
+  z.lazy(() => Four$outboundSchema),
+]);
 
-export function twoToJSON(two: Two): string {
-  return JSON.stringify(Two$outboundSchema.parse(two));
+export function content2ToJSON(content2: Content2): string {
+  return JSON.stringify(Content2$outboundSchema.parse(content2));
 }
 
 /** @internal */
-export type InvokeDeploymentRequestPrefixMessagesContent$Outbound =
+export type DeploymentInvokePrefixMessagesDeploymentsContent$Outbound =
   | string
   | Array<
-    | (TextContentPartSchema$Outbound & { type: "text" })
-    | ImageContentPartSchema$Outbound
-    | AudioContentPartSchema$Outbound
+    | (components.TextContentPartSchema$Outbound & { type: "text" })
+    | components.ImageContentPartSchema$Outbound
+    | components.AudioContentPartSchema$Outbound
     | Four$Outbound
   >;
 
 /** @internal */
-export const InvokeDeploymentRequestPrefixMessagesContent$outboundSchema:
+export const DeploymentInvokePrefixMessagesDeploymentsContent$outboundSchema:
   z.ZodType<
-    InvokeDeploymentRequestPrefixMessagesContent$Outbound,
+    DeploymentInvokePrefixMessagesDeploymentsContent$Outbound,
     z.ZodTypeDef,
-    InvokeDeploymentRequestPrefixMessagesContent
+    DeploymentInvokePrefixMessagesDeploymentsContent
   > = z.union([
     z.string(),
     z.array(
       z.union([
-        TextContentPartSchema$outboundSchema.and(
+        components.TextContentPartSchema$outboundSchema.and(
           z.object({ type: z.literal("text") }),
         ),
-        ImageContentPartSchema$outboundSchema,
-        AudioContentPartSchema$outboundSchema,
+        components.ImageContentPartSchema$outboundSchema,
+        components.AudioContentPartSchema$outboundSchema,
         z.lazy(() => Four$outboundSchema),
       ]),
     ),
   ]);
 
-export function invokeDeploymentRequestPrefixMessagesContentToJSON(
-  invokeDeploymentRequestPrefixMessagesContent:
-    InvokeDeploymentRequestPrefixMessagesContent,
+export function deploymentInvokePrefixMessagesDeploymentsContentToJSON(
+  deploymentInvokePrefixMessagesDeploymentsContent:
+    DeploymentInvokePrefixMessagesDeploymentsContent,
 ): string {
   return JSON.stringify(
-    InvokeDeploymentRequestPrefixMessagesContent$outboundSchema.parse(
-      invokeDeploymentRequestPrefixMessagesContent,
+    DeploymentInvokePrefixMessagesDeploymentsContent$outboundSchema.parse(
+      deploymentInvokePrefixMessagesDeploymentsContent,
     ),
   );
 }
@@ -1582,9 +1899,9 @@ export type UserMessage$Outbound = {
   content:
     | string
     | Array<
-      | (TextContentPartSchema$Outbound & { type: "text" })
-      | ImageContentPartSchema$Outbound
-      | AudioContentPartSchema$Outbound
+      | (components.TextContentPartSchema$Outbound & { type: "text" })
+      | components.ImageContentPartSchema$Outbound
+      | components.AudioContentPartSchema$Outbound
       | Four$Outbound
     >;
 };
@@ -1601,11 +1918,11 @@ export const UserMessage$outboundSchema: z.ZodType<
     z.string(),
     z.array(
       z.union([
-        TextContentPartSchema$outboundSchema.and(
+        components.TextContentPartSchema$outboundSchema.and(
           z.object({ type: z.literal("text") }),
         ),
-        ImageContentPartSchema$outboundSchema,
-        AudioContentPartSchema$outboundSchema,
+        components.ImageContentPartSchema$outboundSchema,
+        components.AudioContentPartSchema$outboundSchema,
         z.lazy(() => Four$outboundSchema),
       ]),
     ),
@@ -1617,29 +1934,34 @@ export function userMessageToJSON(userMessage: UserMessage): string {
 }
 
 /** @internal */
-export type PrefixMessagesContent$Outbound =
+export type DeploymentInvokePrefixMessagesContent$Outbound =
   | string
-  | Array<TextContentPartSchema$Outbound>;
+  | Array<components.TextContentPartSchema$Outbound>;
 
 /** @internal */
-export const PrefixMessagesContent$outboundSchema: z.ZodType<
-  PrefixMessagesContent$Outbound,
+export const DeploymentInvokePrefixMessagesContent$outboundSchema: z.ZodType<
+  DeploymentInvokePrefixMessagesContent$Outbound,
   z.ZodTypeDef,
-  PrefixMessagesContent
-> = z.union([z.string(), z.array(TextContentPartSchema$outboundSchema)]);
+  DeploymentInvokePrefixMessagesContent
+> = z.union([
+  z.string(),
+  z.array(components.TextContentPartSchema$outboundSchema),
+]);
 
-export function prefixMessagesContentToJSON(
-  prefixMessagesContent: PrefixMessagesContent,
+export function deploymentInvokePrefixMessagesContentToJSON(
+  deploymentInvokePrefixMessagesContent: DeploymentInvokePrefixMessagesContent,
 ): string {
   return JSON.stringify(
-    PrefixMessagesContent$outboundSchema.parse(prefixMessagesContent),
+    DeploymentInvokePrefixMessagesContent$outboundSchema.parse(
+      deploymentInvokePrefixMessagesContent,
+    ),
   );
 }
 
 /** @internal */
 export type DeveloperMessage$Outbound = {
   role: "developer";
-  content: string | Array<TextContentPartSchema$Outbound>;
+  content: string | Array<components.TextContentPartSchema$Outbound>;
   name?: string | undefined;
 };
 
@@ -1650,7 +1972,10 @@ export const DeveloperMessage$outboundSchema: z.ZodType<
   DeveloperMessage
 > = z.object({
   role: z.literal("developer"),
-  content: z.union([z.string(), z.array(TextContentPartSchema$outboundSchema)]),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]),
   name: z.string().optional(),
 });
 
@@ -1663,23 +1988,32 @@ export function developerMessageToJSON(
 }
 
 /** @internal */
-export type Content$Outbound = string | Array<TextContentPartSchema$Outbound>;
+export type PrefixMessagesContent$Outbound =
+  | string
+  | Array<components.TextContentPartSchema$Outbound>;
 
 /** @internal */
-export const Content$outboundSchema: z.ZodType<
-  Content$Outbound,
+export const PrefixMessagesContent$outboundSchema: z.ZodType<
+  PrefixMessagesContent$Outbound,
   z.ZodTypeDef,
-  Content
-> = z.union([z.string(), z.array(TextContentPartSchema$outboundSchema)]);
+  PrefixMessagesContent
+> = z.union([
+  z.string(),
+  z.array(components.TextContentPartSchema$outboundSchema),
+]);
 
-export function contentToJSON(content: Content): string {
-  return JSON.stringify(Content$outboundSchema.parse(content));
+export function prefixMessagesContentToJSON(
+  prefixMessagesContent: PrefixMessagesContent,
+): string {
+  return JSON.stringify(
+    PrefixMessagesContent$outboundSchema.parse(prefixMessagesContent),
+  );
 }
 
 /** @internal */
 export type SystemMessage$Outbound = {
   role: "system";
-  content: string | Array<TextContentPartSchema$Outbound>;
+  content: string | Array<components.TextContentPartSchema$Outbound>;
   name?: string | undefined;
 };
 
@@ -1690,7 +2024,10 @@ export const SystemMessage$outboundSchema: z.ZodType<
   SystemMessage
 > = z.object({
   role: z.literal("system"),
-  content: z.union([z.string(), z.array(TextContentPartSchema$outboundSchema)]),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]),
   name: z.string().optional(),
 });
 
@@ -1724,55 +2061,57 @@ export function prefixMessagesToJSON(prefixMessages: PrefixMessages): string {
 }
 
 /** @internal */
-export type InvokeDeploymentRequestContentMessages52$Outbound =
-  TextContentPartSchema$Outbound;
+export type DeploymentInvokeContentDeploymentsRequestRequestBodyMessages2$Outbound =
+  components.TextContentPartSchema$Outbound;
 
 /** @internal */
-export const InvokeDeploymentRequestContentMessages52$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestContentMessages52$Outbound,
-  z.ZodTypeDef,
-  InvokeDeploymentRequestContentMessages52
-> = TextContentPartSchema$outboundSchema;
+export const DeploymentInvokeContentDeploymentsRequestRequestBodyMessages2$outboundSchema:
+  z.ZodType<
+    DeploymentInvokeContentDeploymentsRequestRequestBodyMessages2$Outbound,
+    z.ZodTypeDef,
+    DeploymentInvokeContentDeploymentsRequestRequestBodyMessages2
+  > = components.TextContentPartSchema$outboundSchema;
 
-export function invokeDeploymentRequestContentMessages52ToJSON(
-  invokeDeploymentRequestContentMessages52:
-    InvokeDeploymentRequestContentMessages52,
+export function deploymentInvokeContentDeploymentsRequestRequestBodyMessages2ToJSON(
+  deploymentInvokeContentDeploymentsRequestRequestBodyMessages2:
+    DeploymentInvokeContentDeploymentsRequestRequestBodyMessages2,
 ): string {
   return JSON.stringify(
-    InvokeDeploymentRequestContentMessages52$outboundSchema.parse(
-      invokeDeploymentRequestContentMessages52,
-    ),
+    DeploymentInvokeContentDeploymentsRequestRequestBodyMessages2$outboundSchema
+      .parse(deploymentInvokeContentDeploymentsRequestRequestBodyMessages2),
   );
 }
 
 /** @internal */
-export type InvokeDeploymentRequestMessages5Content$Outbound =
+export type DeploymentInvokeMessagesDeploymentsRequestRequestBodyContent$Outbound =
   | string
-  | Array<TextContentPartSchema$Outbound>;
+  | Array<components.TextContentPartSchema$Outbound>;
 
 /** @internal */
-export const InvokeDeploymentRequestMessages5Content$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestMessages5Content$Outbound,
-  z.ZodTypeDef,
-  InvokeDeploymentRequestMessages5Content
-> = z.union([z.string(), z.array(TextContentPartSchema$outboundSchema)]);
+export const DeploymentInvokeMessagesDeploymentsRequestRequestBodyContent$outboundSchema:
+  z.ZodType<
+    DeploymentInvokeMessagesDeploymentsRequestRequestBodyContent$Outbound,
+    z.ZodTypeDef,
+    DeploymentInvokeMessagesDeploymentsRequestRequestBodyContent
+  > = z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]);
 
-export function invokeDeploymentRequestMessages5ContentToJSON(
-  invokeDeploymentRequestMessages5Content:
-    InvokeDeploymentRequestMessages5Content,
+export function deploymentInvokeMessagesDeploymentsRequestRequestBodyContentToJSON(
+  deploymentInvokeMessagesDeploymentsRequestRequestBodyContent:
+    DeploymentInvokeMessagesDeploymentsRequestRequestBodyContent,
 ): string {
   return JSON.stringify(
-    InvokeDeploymentRequestMessages5Content$outboundSchema.parse(
-      invokeDeploymentRequestMessages5Content,
-    ),
+    DeploymentInvokeMessagesDeploymentsRequestRequestBodyContent$outboundSchema
+      .parse(deploymentInvokeMessagesDeploymentsRequestRequestBodyContent),
   );
 }
 
 /** @internal */
-export const InvokeDeploymentRequestMessagesType$outboundSchema:
-  z.ZodNativeEnum<typeof InvokeDeploymentRequestMessagesType> = z.nativeEnum(
-    InvokeDeploymentRequestMessagesType,
-  );
+export const DeploymentInvokeMessagesType$outboundSchema: z.ZodNativeEnum<
+  typeof DeploymentInvokeMessagesType
+> = z.nativeEnum(DeploymentInvokeMessagesType);
 
 /** @internal */
 export const MessagesTtl$outboundSchema: z.ZodNativeEnum<typeof MessagesTtl> = z
@@ -1790,7 +2129,7 @@ export const MessagesCacheControl$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   MessagesCacheControl
 > = z.object({
-  type: InvokeDeploymentRequestMessagesType$outboundSchema,
+  type: DeploymentInvokeMessagesType$outboundSchema,
   ttl: MessagesTtl$outboundSchema.default("5m"),
 });
 
@@ -1805,7 +2144,7 @@ export function messagesCacheControlToJSON(
 /** @internal */
 export type MessagesToolMessage$Outbound = {
   role: "tool";
-  content: string | Array<TextContentPartSchema$Outbound>;
+  content: string | Array<components.TextContentPartSchema$Outbound>;
   tool_call_id: string | null;
   cache_control?: MessagesCacheControl$Outbound | undefined;
 };
@@ -1817,7 +2156,10 @@ export const MessagesToolMessage$outboundSchema: z.ZodType<
   MessagesToolMessage
 > = z.object({
   role: z.literal("tool"),
-  content: z.union([z.string(), z.array(TextContentPartSchema$outboundSchema)]),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]),
   toolCallId: z.nullable(z.string()),
   cacheControl: z.lazy(() => MessagesCacheControl$outboundSchema).optional(),
 }).transform((v) => {
@@ -1836,73 +2178,75 @@ export function messagesToolMessageToJSON(
 }
 
 /** @internal */
-export type InvokeDeploymentRequestContentMessages42$Outbound =
-  | (TextContentPartSchema$Outbound & { type: "text" })
-  | RefusalPartSchema$Outbound
-  | ReasoningPartSchema$Outbound
-  | RedactedReasoningPartSchema$Outbound;
+export type DeploymentInvokeContentDeploymentsRequestRequestBody2$Outbound =
+  | (components.TextContentPartSchema$Outbound & { type: "text" })
+  | components.RefusalPartSchema$Outbound
+  | components.ReasoningPartSchema$Outbound
+  | components.RedactedReasoningPartSchema$Outbound;
 
 /** @internal */
-export const InvokeDeploymentRequestContentMessages42$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestContentMessages42$Outbound,
-  z.ZodTypeDef,
-  InvokeDeploymentRequestContentMessages42
-> = z.union([
-  TextContentPartSchema$outboundSchema.and(
-    z.object({ type: z.literal("text") }),
-  ),
-  RefusalPartSchema$outboundSchema,
-  ReasoningPartSchema$outboundSchema,
-  RedactedReasoningPartSchema$outboundSchema,
-]);
-
-export function invokeDeploymentRequestContentMessages42ToJSON(
-  invokeDeploymentRequestContentMessages42:
-    InvokeDeploymentRequestContentMessages42,
-): string {
-  return JSON.stringify(
-    InvokeDeploymentRequestContentMessages42$outboundSchema.parse(
-      invokeDeploymentRequestContentMessages42,
-    ),
+export const DeploymentInvokeContentDeploymentsRequestRequestBody2$outboundSchema:
+  z.ZodType<
+    DeploymentInvokeContentDeploymentsRequestRequestBody2$Outbound,
+    z.ZodTypeDef,
+    DeploymentInvokeContentDeploymentsRequestRequestBody2
+  > = z.union([
+    components.TextContentPartSchema$outboundSchema.and(
+      z.object({ type: z.literal("text") }),
+    ),
+    components.RefusalPartSchema$outboundSchema,
+    components.ReasoningPartSchema$outboundSchema,
+    components.RedactedReasoningPartSchema$outboundSchema,
+  ]);
+
+export function deploymentInvokeContentDeploymentsRequestRequestBody2ToJSON(
+  deploymentInvokeContentDeploymentsRequestRequestBody2:
+    DeploymentInvokeContentDeploymentsRequestRequestBody2,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeContentDeploymentsRequestRequestBody2$outboundSchema.parse(
+      deploymentInvokeContentDeploymentsRequestRequestBody2,
+    ),
   );
 }
 
 /** @internal */
-export type InvokeDeploymentRequestMessages4Content$Outbound =
+export type DeploymentInvokeMessagesDeploymentsRequestContent$Outbound =
   | string
   | Array<
-    | (TextContentPartSchema$Outbound & { type: "text" })
-    | RefusalPartSchema$Outbound
-    | ReasoningPartSchema$Outbound
-    | RedactedReasoningPartSchema$Outbound
+    | (components.TextContentPartSchema$Outbound & { type: "text" })
+    | components.RefusalPartSchema$Outbound
+    | components.ReasoningPartSchema$Outbound
+    | components.RedactedReasoningPartSchema$Outbound
   >;
 
 /** @internal */
-export const InvokeDeploymentRequestMessages4Content$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestMessages4Content$Outbound,
-  z.ZodTypeDef,
-  InvokeDeploymentRequestMessages4Content
-> = z.union([
-  z.string(),
-  z.array(
-    z.union([
-      TextContentPartSchema$outboundSchema.and(
-        z.object({ type: z.literal("text") }),
-      ),
-      RefusalPartSchema$outboundSchema,
-      ReasoningPartSchema$outboundSchema,
-      RedactedReasoningPartSchema$outboundSchema,
-    ]),
-  ),
-]);
+export const DeploymentInvokeMessagesDeploymentsRequestContent$outboundSchema:
+  z.ZodType<
+    DeploymentInvokeMessagesDeploymentsRequestContent$Outbound,
+    z.ZodTypeDef,
+    DeploymentInvokeMessagesDeploymentsRequestContent
+  > = z.union([
+    z.string(),
+    z.array(
+      z.union([
+        components.TextContentPartSchema$outboundSchema.and(
+          z.object({ type: z.literal("text") }),
+        ),
+        components.RefusalPartSchema$outboundSchema,
+        components.ReasoningPartSchema$outboundSchema,
+        components.RedactedReasoningPartSchema$outboundSchema,
+      ]),
+    ),
+  ]);
 
-export function invokeDeploymentRequestMessages4ContentToJSON(
-  invokeDeploymentRequestMessages4Content:
-    InvokeDeploymentRequestMessages4Content,
+export function deploymentInvokeMessagesDeploymentsRequestContentToJSON(
+  deploymentInvokeMessagesDeploymentsRequestContent:
+    DeploymentInvokeMessagesDeploymentsRequestContent,
 ): string {
   return JSON.stringify(
-    InvokeDeploymentRequestMessages4Content$outboundSchema.parse(
-      invokeDeploymentRequestMessages4Content,
+    DeploymentInvokeMessagesDeploymentsRequestContent$outboundSchema.parse(
+      deploymentInvokeMessagesDeploymentsRequestContent,
     ),
   );
 }
@@ -1990,10 +2334,10 @@ export type MessagesAssistantMessage$Outbound = {
   content?:
     | string
     | Array<
-      | (TextContentPartSchema$Outbound & { type: "text" })
-      | RefusalPartSchema$Outbound
-      | ReasoningPartSchema$Outbound
-      | RedactedReasoningPartSchema$Outbound
+      | (components.TextContentPartSchema$Outbound & { type: "text" })
+      | components.RefusalPartSchema$Outbound
+      | components.ReasoningPartSchema$Outbound
+      | components.RedactedReasoningPartSchema$Outbound
     >
     | null
     | undefined;
@@ -2015,12 +2359,12 @@ export const MessagesAssistantMessage$outboundSchema: z.ZodType<
       z.string(),
       z.array(
         z.union([
-          TextContentPartSchema$outboundSchema.and(
+          components.TextContentPartSchema$outboundSchema.and(
             z.object({ type: z.literal("text") }),
           ),
-          RefusalPartSchema$outboundSchema,
-          ReasoningPartSchema$outboundSchema,
-          RedactedReasoningPartSchema$outboundSchema,
+          components.RefusalPartSchema$outboundSchema,
+          components.ReasoningPartSchema$outboundSchema,
+          components.RedactedReasoningPartSchema$outboundSchema,
         ]),
       ),
     ]),
@@ -2045,57 +2389,49 @@ export function messagesAssistantMessageToJSON(
 }
 
 /** @internal */
-export const InvokeDeploymentRequest2MessagesType$outboundSchema:
-  z.ZodNativeEnum<typeof InvokeDeploymentRequest2MessagesType> = z.nativeEnum(
-    InvokeDeploymentRequest2MessagesType,
-  );
+export const DeploymentInvoke2DeploymentsRequestRequestBodyType$outboundSchema:
+  z.ZodNativeEnum<typeof DeploymentInvoke2DeploymentsRequestRequestBodyType> = z
+    .nativeEnum(DeploymentInvoke2DeploymentsRequestRequestBodyType);
 
 /** @internal */
-export const InvokeDeploymentRequest2Ttl$outboundSchema: z.ZodNativeEnum<
-  typeof InvokeDeploymentRequest2Ttl
-> = z.nativeEnum(InvokeDeploymentRequest2Ttl);
+export const TwoTtl$outboundSchema: z.ZodNativeEnum<typeof TwoTtl> = z
+  .nativeEnum(TwoTtl);
 
 /** @internal */
-export type InvokeDeploymentRequest2CacheControl$Outbound = {
+export type TwoCacheControl$Outbound = {
   type: string;
   ttl: string;
 };
 
 /** @internal */
-export const InvokeDeploymentRequest2CacheControl$outboundSchema: z.ZodType<
-  InvokeDeploymentRequest2CacheControl$Outbound,
+export const TwoCacheControl$outboundSchema: z.ZodType<
+  TwoCacheControl$Outbound,
   z.ZodTypeDef,
-  InvokeDeploymentRequest2CacheControl
+  TwoCacheControl
 > = z.object({
-  type: InvokeDeploymentRequest2MessagesType$outboundSchema,
-  ttl: InvokeDeploymentRequest2Ttl$outboundSchema.default("5m"),
+  type: DeploymentInvoke2DeploymentsRequestRequestBodyType$outboundSchema,
+  ttl: TwoTtl$outboundSchema.default("5m"),
 });
 
-export function invokeDeploymentRequest2CacheControlToJSON(
-  invokeDeploymentRequest2CacheControl: InvokeDeploymentRequest2CacheControl,
+export function twoCacheControlToJSON(
+  twoCacheControl: TwoCacheControl,
 ): string {
-  return JSON.stringify(
-    InvokeDeploymentRequest2CacheControl$outboundSchema.parse(
-      invokeDeploymentRequest2CacheControl,
-    ),
-  );
+  return JSON.stringify(TwoCacheControl$outboundSchema.parse(twoCacheControl));
 }
 
 /** @internal */
 export type Two4$Outbound = {
   type: "file";
-  cache_control?: InvokeDeploymentRequest2CacheControl$Outbound | undefined;
-  file: FileContentPartSchema$Outbound;
+  cache_control?: TwoCacheControl$Outbound | undefined;
+  file: components.FileContentPartSchema$Outbound;
 };
 
 /** @internal */
 export const Two4$outboundSchema: z.ZodType<Two4$Outbound, z.ZodTypeDef, Two4> =
   z.object({
     type: z.literal("file"),
-    cacheControl: z.lazy(() =>
-      InvokeDeploymentRequest2CacheControl$outboundSchema
-    ).optional(),
-    file: FileContentPartSchema$outboundSchema,
+    cacheControl: z.lazy(() => TwoCacheControl$outboundSchema).optional(),
+    file: components.FileContentPartSchema$outboundSchema,
   }).transform((v) => {
     return remap$(v, {
       cacheControl: "cache_control",
@@ -2107,73 +2443,75 @@ export function two4ToJSON(two4: Two4): string {
 }
 
 /** @internal */
-export type InvokeDeploymentRequestContentMessages2$Outbound =
-  | (TextContentPartSchema$Outbound & { type: "text" })
-  | ImageContentPartSchema$Outbound
-  | AudioContentPartSchema$Outbound
+export type DeploymentInvokeContentDeploymentsRequest2$Outbound =
+  | (components.TextContentPartSchema$Outbound & { type: "text" })
+  | components.ImageContentPartSchema$Outbound
+  | components.AudioContentPartSchema$Outbound
   | Two4$Outbound;
 
 /** @internal */
-export const InvokeDeploymentRequestContentMessages2$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestContentMessages2$Outbound,
-  z.ZodTypeDef,
-  InvokeDeploymentRequestContentMessages2
-> = z.union([
-  TextContentPartSchema$outboundSchema.and(
-    z.object({ type: z.literal("text") }),
-  ),
-  ImageContentPartSchema$outboundSchema,
-  AudioContentPartSchema$outboundSchema,
-  z.lazy(() => Two4$outboundSchema),
-]);
+export const DeploymentInvokeContentDeploymentsRequest2$outboundSchema:
+  z.ZodType<
+    DeploymentInvokeContentDeploymentsRequest2$Outbound,
+    z.ZodTypeDef,
+    DeploymentInvokeContentDeploymentsRequest2
+  > = z.union([
+    components.TextContentPartSchema$outboundSchema.and(
+      z.object({ type: z.literal("text") }),
+    ),
+    components.ImageContentPartSchema$outboundSchema,
+    components.AudioContentPartSchema$outboundSchema,
+    z.lazy(() => Two4$outboundSchema),
+  ]);
 
-export function invokeDeploymentRequestContentMessages2ToJSON(
-  invokeDeploymentRequestContentMessages2:
-    InvokeDeploymentRequestContentMessages2,
+export function deploymentInvokeContentDeploymentsRequest2ToJSON(
+  deploymentInvokeContentDeploymentsRequest2:
+    DeploymentInvokeContentDeploymentsRequest2,
 ): string {
   return JSON.stringify(
-    InvokeDeploymentRequestContentMessages2$outboundSchema.parse(
-      invokeDeploymentRequestContentMessages2,
+    DeploymentInvokeContentDeploymentsRequest2$outboundSchema.parse(
+      deploymentInvokeContentDeploymentsRequest2,
     ),
   );
 }
 
 /** @internal */
-export type InvokeDeploymentRequestMessages3Content$Outbound =
+export type DeploymentInvokeMessagesDeploymentsContent$Outbound =
   | string
   | Array<
-    | (TextContentPartSchema$Outbound & { type: "text" })
-    | ImageContentPartSchema$Outbound
-    | AudioContentPartSchema$Outbound
+    | (components.TextContentPartSchema$Outbound & { type: "text" })
+    | components.ImageContentPartSchema$Outbound
+    | components.AudioContentPartSchema$Outbound
     | Two4$Outbound
   >;
 
 /** @internal */
-export const InvokeDeploymentRequestMessages3Content$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestMessages3Content$Outbound,
-  z.ZodTypeDef,
-  InvokeDeploymentRequestMessages3Content
-> = z.union([
-  z.string(),
-  z.array(
-    z.union([
-      TextContentPartSchema$outboundSchema.and(
-        z.object({ type: z.literal("text") }),
-      ),
-      ImageContentPartSchema$outboundSchema,
-      AudioContentPartSchema$outboundSchema,
-      z.lazy(() => Two4$outboundSchema),
-    ]),
-  ),
-]);
+export const DeploymentInvokeMessagesDeploymentsContent$outboundSchema:
+  z.ZodType<
+    DeploymentInvokeMessagesDeploymentsContent$Outbound,
+    z.ZodTypeDef,
+    DeploymentInvokeMessagesDeploymentsContent
+  > = z.union([
+    z.string(),
+    z.array(
+      z.union([
+        components.TextContentPartSchema$outboundSchema.and(
+          z.object({ type: z.literal("text") }),
+        ),
+        components.ImageContentPartSchema$outboundSchema,
+        components.AudioContentPartSchema$outboundSchema,
+        z.lazy(() => Two4$outboundSchema),
+      ]),
+    ),
+  ]);
 
-export function invokeDeploymentRequestMessages3ContentToJSON(
-  invokeDeploymentRequestMessages3Content:
-    InvokeDeploymentRequestMessages3Content,
+export function deploymentInvokeMessagesDeploymentsContentToJSON(
+  deploymentInvokeMessagesDeploymentsContent:
+    DeploymentInvokeMessagesDeploymentsContent,
 ): string {
   return JSON.stringify(
-    InvokeDeploymentRequestMessages3Content$outboundSchema.parse(
-      invokeDeploymentRequestMessages3Content,
+    DeploymentInvokeMessagesDeploymentsContent$outboundSchema.parse(
+      deploymentInvokeMessagesDeploymentsContent,
     ),
   );
 }
@@ -2185,9 +2523,9 @@ export type MessagesUserMessage$Outbound = {
   content:
     | string
     | Array<
-      | (TextContentPartSchema$Outbound & { type: "text" })
-      | ImageContentPartSchema$Outbound
-      | AudioContentPartSchema$Outbound
+      | (components.TextContentPartSchema$Outbound & { type: "text" })
+      | components.ImageContentPartSchema$Outbound
+      | components.AudioContentPartSchema$Outbound
       | Two4$Outbound
     >;
 };
@@ -2204,11 +2542,11 @@ export const MessagesUserMessage$outboundSchema: z.ZodType<
     z.string(),
     z.array(
       z.union([
-        TextContentPartSchema$outboundSchema.and(
+        components.TextContentPartSchema$outboundSchema.and(
           z.object({ type: z.literal("text") }),
         ),
-        ImageContentPartSchema$outboundSchema,
-        AudioContentPartSchema$outboundSchema,
+        components.ImageContentPartSchema$outboundSchema,
+        components.AudioContentPartSchema$outboundSchema,
         z.lazy(() => Two4$outboundSchema),
       ]),
     ),
@@ -2224,24 +2562,26 @@ export function messagesUserMessageToJSON(
 }
 
 /** @internal */
-export type InvokeDeploymentRequestMessagesContent$Outbound =
+export type DeploymentInvokeMessagesContent$Outbound =
   | string
-  | Array<TextContentPartSchema$Outbound>;
+  | Array<components.TextContentPartSchema$Outbound>;
 
 /** @internal */
-export const InvokeDeploymentRequestMessagesContent$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestMessagesContent$Outbound,
+export const DeploymentInvokeMessagesContent$outboundSchema: z.ZodType<
+  DeploymentInvokeMessagesContent$Outbound,
   z.ZodTypeDef,
-  InvokeDeploymentRequestMessagesContent
-> = z.union([z.string(), z.array(TextContentPartSchema$outboundSchema)]);
+  DeploymentInvokeMessagesContent
+> = z.union([
+  z.string(),
+  z.array(components.TextContentPartSchema$outboundSchema),
+]);
 
-export function invokeDeploymentRequestMessagesContentToJSON(
-  invokeDeploymentRequestMessagesContent:
-    InvokeDeploymentRequestMessagesContent,
+export function deploymentInvokeMessagesContentToJSON(
+  deploymentInvokeMessagesContent: DeploymentInvokeMessagesContent,
 ): string {
   return JSON.stringify(
-    InvokeDeploymentRequestMessagesContent$outboundSchema.parse(
-      invokeDeploymentRequestMessagesContent,
+    DeploymentInvokeMessagesContent$outboundSchema.parse(
+      deploymentInvokeMessagesContent,
     ),
   );
 }
@@ -2249,7 +2589,7 @@ export function invokeDeploymentRequestMessagesContentToJSON(
 /** @internal */
 export type MessagesDeveloperMessage$Outbound = {
   role: "developer";
-  content: string | Array<TextContentPartSchema$Outbound>;
+  content: string | Array<components.TextContentPartSchema$Outbound>;
   name?: string | undefined;
 };
 
@@ -2260,7 +2600,10 @@ export const MessagesDeveloperMessage$outboundSchema: z.ZodType<
   MessagesDeveloperMessage
 > = z.object({
   role: z.literal("developer"),
-  content: z.union([z.string(), z.array(TextContentPartSchema$outboundSchema)]),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]),
   name: z.string().optional(),
 });
 
@@ -2275,14 +2618,17 @@ export function messagesDeveloperMessageToJSON(
 /** @internal */
 export type MessagesContent$Outbound =
   | string
-  | Array<TextContentPartSchema$Outbound>;
+  | Array<components.TextContentPartSchema$Outbound>;
 
 /** @internal */
 export const MessagesContent$outboundSchema: z.ZodType<
   MessagesContent$Outbound,
   z.ZodTypeDef,
   MessagesContent
-> = z.union([z.string(), z.array(TextContentPartSchema$outboundSchema)]);
+> = z.union([
+  z.string(),
+  z.array(components.TextContentPartSchema$outboundSchema),
+]);
 
 export function messagesContentToJSON(
   messagesContent: MessagesContent,
@@ -2293,7 +2639,7 @@ export function messagesContentToJSON(
 /** @internal */
 export type MessagesSystemMessage$Outbound = {
   role: "system";
-  content: string | Array<TextContentPartSchema$Outbound>;
+  content: string | Array<components.TextContentPartSchema$Outbound>;
   name?: string | undefined;
 };
 
@@ -2304,7 +2650,10 @@ export const MessagesSystemMessage$outboundSchema: z.ZodType<
   MessagesSystemMessage
 > = z.object({
   role: z.literal("system"),
-  content: z.union([z.string(), z.array(TextContentPartSchema$outboundSchema)]),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]),
   name: z.string().optional(),
 });
 
@@ -2317,7 +2666,7 @@ export function messagesSystemMessageToJSON(
 }
 
 /** @internal */
-export type Messages$Outbound =
+export type DeploymentInvokeMessages$Outbound =
   | MessagesSystemMessage$Outbound
   | MessagesDeveloperMessage$Outbound
   | MessagesUserMessage$Outbound
@@ -2325,10 +2674,10 @@ export type Messages$Outbound =
   | MessagesToolMessage$Outbound;
 
 /** @internal */
-export const Messages$outboundSchema: z.ZodType<
-  Messages$Outbound,
+export const DeploymentInvokeMessages$outboundSchema: z.ZodType<
+  DeploymentInvokeMessages$Outbound,
   z.ZodTypeDef,
-  Messages
+  DeploymentInvokeMessages
 > = z.union([
   z.lazy(() => MessagesSystemMessage$outboundSchema),
   z.lazy(() => MessagesDeveloperMessage$outboundSchema),
@@ -2337,8 +2686,12 @@ export const Messages$outboundSchema: z.ZodType<
   z.lazy(() => MessagesToolMessage$outboundSchema),
 ]);
 
-export function messagesToJSON(messages: Messages): string {
-  return JSON.stringify(Messages$outboundSchema.parse(messages));
+export function deploymentInvokeMessagesToJSON(
+  deploymentInvokeMessages: DeploymentInvokeMessages,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeMessages$outboundSchema.parse(deploymentInvokeMessages),
+  );
 }
 
 /** @internal */
@@ -2456,76 +2809,72 @@ export function orExistsToJSON(orExists: OrExists): string {
 }
 
 /** @internal */
-export type OrNin$Outbound = string | number | boolean;
+export type DeploymentInvokeOrNin$Outbound = string | number | boolean;
 
 /** @internal */
-export const OrNin$outboundSchema: z.ZodType<
-  OrNin$Outbound,
+export const DeploymentInvokeOrNin$outboundSchema: z.ZodType<
+  DeploymentInvokeOrNin$Outbound,
   z.ZodTypeDef,
-  OrNin
+  DeploymentInvokeOrNin
 > = z.union([z.string(), z.number(), z.boolean()]);
 
-export function orNinToJSON(orNin: OrNin): string {
-  return JSON.stringify(OrNin$outboundSchema.parse(orNin));
+export function deploymentInvokeOrNinToJSON(
+  deploymentInvokeOrNin: DeploymentInvokeOrNin,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeOrNin$outboundSchema.parse(deploymentInvokeOrNin),
+  );
 }
 
 /** @internal */
-export type InvokeDeploymentRequestOrNin$Outbound = {
+export type OrNin$Outbound = {
   nin: Array<string | number | boolean>;
 };
 
 /** @internal */
-export const InvokeDeploymentRequestOrNin$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestOrNin$Outbound,
+export const OrNin$outboundSchema: z.ZodType<
+  OrNin$Outbound,
   z.ZodTypeDef,
-  InvokeDeploymentRequestOrNin
+  OrNin
 > = z.object({
   nin: z.array(z.union([z.string(), z.number(), z.boolean()])),
 });
 
-export function invokeDeploymentRequestOrNinToJSON(
-  invokeDeploymentRequestOrNin: InvokeDeploymentRequestOrNin,
-): string {
-  return JSON.stringify(
-    InvokeDeploymentRequestOrNin$outboundSchema.parse(
-      invokeDeploymentRequestOrNin,
-    ),
-  );
+export function orNinToJSON(orNin: OrNin): string {
+  return JSON.stringify(OrNin$outboundSchema.parse(orNin));
 }
 
 /** @internal */
-export type OrIn$Outbound = string | number | boolean;
+export type DeploymentInvokeOrIn$Outbound = string | number | boolean;
 
 /** @internal */
-export const OrIn$outboundSchema: z.ZodType<OrIn$Outbound, z.ZodTypeDef, OrIn> =
-  z.union([z.string(), z.number(), z.boolean()]);
+export const DeploymentInvokeOrIn$outboundSchema: z.ZodType<
+  DeploymentInvokeOrIn$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeOrIn
+> = z.union([z.string(), z.number(), z.boolean()]);
 
-export function orInToJSON(orIn: OrIn): string {
-  return JSON.stringify(OrIn$outboundSchema.parse(orIn));
+export function deploymentInvokeOrInToJSON(
+  deploymentInvokeOrIn: DeploymentInvokeOrIn,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeOrIn$outboundSchema.parse(deploymentInvokeOrIn),
+  );
 }
 
 /** @internal */
-export type InvokeDeploymentRequestOrIn$Outbound = {
+export type OrIn$Outbound = {
   in: Array<string | number | boolean>;
 };
 
 /** @internal */
-export const InvokeDeploymentRequestOrIn$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestOrIn$Outbound,
-  z.ZodTypeDef,
-  InvokeDeploymentRequestOrIn
-> = z.object({
-  in: z.array(z.union([z.string(), z.number(), z.boolean()])),
-});
+export const OrIn$outboundSchema: z.ZodType<OrIn$Outbound, z.ZodTypeDef, OrIn> =
+  z.object({
+    in: z.array(z.union([z.string(), z.number(), z.boolean()])),
+  });
 
-export function invokeDeploymentRequestOrInToJSON(
-  invokeDeploymentRequestOrIn: InvokeDeploymentRequestOrIn,
-): string {
-  return JSON.stringify(
-    InvokeDeploymentRequestOrIn$outboundSchema.parse(
-      invokeDeploymentRequestOrIn,
-    ),
-  );
+export function orInToJSON(orIn: OrIn): string {
+  return JSON.stringify(OrIn$outboundSchema.parse(orIn));
 }
 
 /** @internal */
@@ -2595,152 +2944,148 @@ export function orGtToJSON(orGt: OrGt): string {
 }
 
 /** @internal */
-export type OrNe$Outbound = string | number | boolean;
+export type DeploymentInvokeOrNe$Outbound = string | number | boolean;
 
 /** @internal */
-export const OrNe$outboundSchema: z.ZodType<OrNe$Outbound, z.ZodTypeDef, OrNe> =
-  z.union([z.string(), z.number(), z.boolean()]);
+export const DeploymentInvokeOrNe$outboundSchema: z.ZodType<
+  DeploymentInvokeOrNe$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeOrNe
+> = z.union([z.string(), z.number(), z.boolean()]);
 
-export function orNeToJSON(orNe: OrNe): string {
-  return JSON.stringify(OrNe$outboundSchema.parse(orNe));
+export function deploymentInvokeOrNeToJSON(
+  deploymentInvokeOrNe: DeploymentInvokeOrNe,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeOrNe$outboundSchema.parse(deploymentInvokeOrNe),
+  );
 }
 
 /** @internal */
-export type InvokeDeploymentRequestOrNe$Outbound = {
+export type OrNe$Outbound = {
   ne: string | number | boolean;
 };
 
 /** @internal */
-export const InvokeDeploymentRequestOrNe$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestOrNe$Outbound,
-  z.ZodTypeDef,
-  InvokeDeploymentRequestOrNe
-> = z.object({
-  ne: z.union([z.string(), z.number(), z.boolean()]),
-});
+export const OrNe$outboundSchema: z.ZodType<OrNe$Outbound, z.ZodTypeDef, OrNe> =
+  z.object({
+    ne: z.union([z.string(), z.number(), z.boolean()]),
+  });
 
-export function invokeDeploymentRequestOrNeToJSON(
-  invokeDeploymentRequestOrNe: InvokeDeploymentRequestOrNe,
-): string {
-  return JSON.stringify(
-    InvokeDeploymentRequestOrNe$outboundSchema.parse(
-      invokeDeploymentRequestOrNe,
-    ),
-  );
+export function orNeToJSON(orNe: OrNe): string {
+  return JSON.stringify(OrNe$outboundSchema.parse(orNe));
 }
 
 /** @internal */
-export type OrEq$Outbound = string | number | boolean;
+export type DeploymentInvokeOrEq$Outbound = string | number | boolean;
 
 /** @internal */
-export const OrEq$outboundSchema: z.ZodType<OrEq$Outbound, z.ZodTypeDef, OrEq> =
-  z.union([z.string(), z.number(), z.boolean()]);
+export const DeploymentInvokeOrEq$outboundSchema: z.ZodType<
+  DeploymentInvokeOrEq$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeOrEq
+> = z.union([z.string(), z.number(), z.boolean()]);
 
-export function orEqToJSON(orEq: OrEq): string {
-  return JSON.stringify(OrEq$outboundSchema.parse(orEq));
+export function deploymentInvokeOrEqToJSON(
+  deploymentInvokeOrEq: DeploymentInvokeOrEq,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeOrEq$outboundSchema.parse(deploymentInvokeOrEq),
+  );
 }
 
 /** @internal */
-export type InvokeDeploymentRequestOrEq$Outbound = {
+export type OrEq$Outbound = {
   eq: string | number | boolean;
 };
 
 /** @internal */
-export const InvokeDeploymentRequestOrEq$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestOrEq$Outbound,
-  z.ZodTypeDef,
-  InvokeDeploymentRequestOrEq
-> = z.object({
-  eq: z.union([z.string(), z.number(), z.boolean()]),
-});
+export const OrEq$outboundSchema: z.ZodType<OrEq$Outbound, z.ZodTypeDef, OrEq> =
+  z.object({
+    eq: z.union([z.string(), z.number(), z.boolean()]),
+  });
 
-export function invokeDeploymentRequestOrEqToJSON(
-  invokeDeploymentRequestOrEq: InvokeDeploymentRequestOrEq,
-): string {
-  return JSON.stringify(
-    InvokeDeploymentRequestOrEq$outboundSchema.parse(
-      invokeDeploymentRequestOrEq,
-    ),
-  );
+export function orEqToJSON(orEq: OrEq): string {
+  return JSON.stringify(OrEq$outboundSchema.parse(orEq));
 }
 
 /** @internal */
-export type Or$Outbound =
-  | InvokeDeploymentRequestOrEq$Outbound
-  | InvokeDeploymentRequestOrNe$Outbound
+export type KnowledgeFilterOr$Outbound =
+  | OrEq$Outbound
+  | OrNe$Outbound
   | OrGt$Outbound
   | OrGte$Outbound
   | OrLt$Outbound
   | OrLte$Outbound
-  | InvokeDeploymentRequestOrIn$Outbound
-  | InvokeDeploymentRequestOrNin$Outbound
+  | OrIn$Outbound
+  | OrNin$Outbound
   | OrExists$Outbound;
 
 /** @internal */
-export const Or$outboundSchema: z.ZodType<Or$Outbound, z.ZodTypeDef, Or> = z
-  .union([
-    z.lazy(() => InvokeDeploymentRequestOrEq$outboundSchema),
-    z.lazy(() => InvokeDeploymentRequestOrNe$outboundSchema),
-    z.lazy(() => OrGt$outboundSchema),
-    z.lazy(() => OrGte$outboundSchema),
-    z.lazy(() => OrLt$outboundSchema),
-    z.lazy(() => OrLte$outboundSchema),
-    z.lazy(() => InvokeDeploymentRequestOrIn$outboundSchema),
-    z.lazy(() => InvokeDeploymentRequestOrNin$outboundSchema),
-    z.lazy(() => OrExists$outboundSchema),
-  ]);
+export const KnowledgeFilterOr$outboundSchema: z.ZodType<
+  KnowledgeFilterOr$Outbound,
+  z.ZodTypeDef,
+  KnowledgeFilterOr
+> = z.union([
+  z.lazy(() => OrEq$outboundSchema),
+  z.lazy(() => OrNe$outboundSchema),
+  z.lazy(() => OrGt$outboundSchema),
+  z.lazy(() => OrGte$outboundSchema),
+  z.lazy(() => OrLt$outboundSchema),
+  z.lazy(() => OrLte$outboundSchema),
+  z.lazy(() => OrIn$outboundSchema),
+  z.lazy(() => OrNin$outboundSchema),
+  z.lazy(() => OrExists$outboundSchema),
+]);
 
-export function orToJSON(or: Or): string {
-  return JSON.stringify(Or$outboundSchema.parse(or));
+export function knowledgeFilterOrToJSON(
+  knowledgeFilterOr: KnowledgeFilterOr,
+): string {
+  return JSON.stringify(
+    KnowledgeFilterOr$outboundSchema.parse(knowledgeFilterOr),
+  );
 }
 
 /** @internal */
-export type KnowledgeFilterOr$Outbound = {
+export type Or$Outbound = {
   or: Array<
     {
       [k: string]:
-        | InvokeDeploymentRequestOrEq$Outbound
-        | InvokeDeploymentRequestOrNe$Outbound
+        | OrEq$Outbound
+        | OrNe$Outbound
         | OrGt$Outbound
         | OrGte$Outbound
         | OrLt$Outbound
         | OrLte$Outbound
-        | InvokeDeploymentRequestOrIn$Outbound
-        | InvokeDeploymentRequestOrNin$Outbound
+        | OrIn$Outbound
+        | OrNin$Outbound
         | OrExists$Outbound;
     }
   >;
 };
 
 /** @internal */
-export const KnowledgeFilterOr$outboundSchema: z.ZodType<
-  KnowledgeFilterOr$Outbound,
-  z.ZodTypeDef,
-  KnowledgeFilterOr
-> = z.object({
-  or: z.array(
-    z.record(z.union([
-      z.lazy(() => InvokeDeploymentRequestOrEq$outboundSchema),
-      z.lazy(() =>
-        InvokeDeploymentRequestOrNe$outboundSchema
-      ),
-      z.lazy(() => OrGt$outboundSchema),
-      z.lazy(() => OrGte$outboundSchema),
-      z.lazy(() => OrLt$outboundSchema),
-      z.lazy(() => OrLte$outboundSchema),
-      z.lazy(() => InvokeDeploymentRequestOrIn$outboundSchema),
-      z.lazy(() => InvokeDeploymentRequestOrNin$outboundSchema),
-      z.lazy(() => OrExists$outboundSchema),
-    ])),
-  ),
-});
+export const Or$outboundSchema: z.ZodType<Or$Outbound, z.ZodTypeDef, Or> = z
+  .object({
+    or: z.array(
+      z.record(z.union([
+        z.lazy(() => OrEq$outboundSchema),
+        z.lazy(() =>
+          OrNe$outboundSchema
+        ),
+        z.lazy(() => OrGt$outboundSchema),
+        z.lazy(() => OrGte$outboundSchema),
+        z.lazy(() => OrLt$outboundSchema),
+        z.lazy(() => OrLte$outboundSchema),
+        z.lazy(() => OrIn$outboundSchema),
+        z.lazy(() => OrNin$outboundSchema),
+        z.lazy(() => OrExists$outboundSchema),
+      ])),
+    ),
+  });
 
-export function knowledgeFilterOrToJSON(
-  knowledgeFilterOr: KnowledgeFilterOr,
-): string {
-  return JSON.stringify(
-    KnowledgeFilterOr$outboundSchema.parse(knowledgeFilterOr),
-  );
+export function orToJSON(or: Or): string {
+  return JSON.stringify(Or$outboundSchema.parse(or));
 }
 
 /** @internal */
@@ -2762,79 +3107,75 @@ export function andExistsToJSON(andExists: AndExists): string {
 }
 
 /** @internal */
-export type AndNin$Outbound = string | number | boolean;
+export type DeploymentInvokeAndNin$Outbound = string | number | boolean;
 
 /** @internal */
-export const AndNin$outboundSchema: z.ZodType<
-  AndNin$Outbound,
+export const DeploymentInvokeAndNin$outboundSchema: z.ZodType<
+  DeploymentInvokeAndNin$Outbound,
   z.ZodTypeDef,
-  AndNin
+  DeploymentInvokeAndNin
 > = z.union([z.string(), z.number(), z.boolean()]);
 
-export function andNinToJSON(andNin: AndNin): string {
-  return JSON.stringify(AndNin$outboundSchema.parse(andNin));
+export function deploymentInvokeAndNinToJSON(
+  deploymentInvokeAndNin: DeploymentInvokeAndNin,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeAndNin$outboundSchema.parse(deploymentInvokeAndNin),
+  );
 }
 
 /** @internal */
-export type InvokeDeploymentRequestAndNin$Outbound = {
+export type AndNin$Outbound = {
   nin: Array<string | number | boolean>;
 };
 
 /** @internal */
-export const InvokeDeploymentRequestAndNin$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestAndNin$Outbound,
+export const AndNin$outboundSchema: z.ZodType<
+  AndNin$Outbound,
   z.ZodTypeDef,
-  InvokeDeploymentRequestAndNin
+  AndNin
 > = z.object({
   nin: z.array(z.union([z.string(), z.number(), z.boolean()])),
 });
 
-export function invokeDeploymentRequestAndNinToJSON(
-  invokeDeploymentRequestAndNin: InvokeDeploymentRequestAndNin,
-): string {
-  return JSON.stringify(
-    InvokeDeploymentRequestAndNin$outboundSchema.parse(
-      invokeDeploymentRequestAndNin,
-    ),
-  );
+export function andNinToJSON(andNin: AndNin): string {
+  return JSON.stringify(AndNin$outboundSchema.parse(andNin));
 }
 
 /** @internal */
-export type AndIn$Outbound = string | number | boolean;
+export type DeploymentInvokeAndIn$Outbound = string | number | boolean;
 
 /** @internal */
-export const AndIn$outboundSchema: z.ZodType<
-  AndIn$Outbound,
+export const DeploymentInvokeAndIn$outboundSchema: z.ZodType<
+  DeploymentInvokeAndIn$Outbound,
   z.ZodTypeDef,
-  AndIn
+  DeploymentInvokeAndIn
 > = z.union([z.string(), z.number(), z.boolean()]);
 
-export function andInToJSON(andIn: AndIn): string {
-  return JSON.stringify(AndIn$outboundSchema.parse(andIn));
+export function deploymentInvokeAndInToJSON(
+  deploymentInvokeAndIn: DeploymentInvokeAndIn,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeAndIn$outboundSchema.parse(deploymentInvokeAndIn),
+  );
 }
 
 /** @internal */
-export type InvokeDeploymentRequestAndIn$Outbound = {
+export type AndIn$Outbound = {
   in: Array<string | number | boolean>;
 };
 
 /** @internal */
-export const InvokeDeploymentRequestAndIn$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestAndIn$Outbound,
+export const AndIn$outboundSchema: z.ZodType<
+  AndIn$Outbound,
   z.ZodTypeDef,
-  InvokeDeploymentRequestAndIn
+  AndIn
 > = z.object({
   in: z.array(z.union([z.string(), z.number(), z.boolean()])),
 });
 
-export function invokeDeploymentRequestAndInToJSON(
-  invokeDeploymentRequestAndIn: InvokeDeploymentRequestAndIn,
-): string {
-  return JSON.stringify(
-    InvokeDeploymentRequestAndIn$outboundSchema.parse(
-      invokeDeploymentRequestAndIn,
-    ),
-  );
+export function andInToJSON(andIn: AndIn): string {
+  return JSON.stringify(AndIn$outboundSchema.parse(andIn));
 }
 
 /** @internal */
@@ -2910,158 +3251,154 @@ export function andGtToJSON(andGt: AndGt): string {
 }
 
 /** @internal */
-export type AndNe$Outbound = string | number | boolean;
+export type DeploymentInvokeAndNe$Outbound = string | number | boolean;
 
 /** @internal */
-export const AndNe$outboundSchema: z.ZodType<
-  AndNe$Outbound,
+export const DeploymentInvokeAndNe$outboundSchema: z.ZodType<
+  DeploymentInvokeAndNe$Outbound,
   z.ZodTypeDef,
-  AndNe
+  DeploymentInvokeAndNe
 > = z.union([z.string(), z.number(), z.boolean()]);
 
-export function andNeToJSON(andNe: AndNe): string {
-  return JSON.stringify(AndNe$outboundSchema.parse(andNe));
+export function deploymentInvokeAndNeToJSON(
+  deploymentInvokeAndNe: DeploymentInvokeAndNe,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeAndNe$outboundSchema.parse(deploymentInvokeAndNe),
+  );
 }
 
 /** @internal */
-export type InvokeDeploymentRequestAndNe$Outbound = {
+export type AndNe$Outbound = {
   ne: string | number | boolean;
 };
 
 /** @internal */
-export const InvokeDeploymentRequestAndNe$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestAndNe$Outbound,
+export const AndNe$outboundSchema: z.ZodType<
+  AndNe$Outbound,
   z.ZodTypeDef,
-  InvokeDeploymentRequestAndNe
+  AndNe
 > = z.object({
   ne: z.union([z.string(), z.number(), z.boolean()]),
 });
 
-export function invokeDeploymentRequestAndNeToJSON(
-  invokeDeploymentRequestAndNe: InvokeDeploymentRequestAndNe,
-): string {
-  return JSON.stringify(
-    InvokeDeploymentRequestAndNe$outboundSchema.parse(
-      invokeDeploymentRequestAndNe,
-    ),
-  );
+export function andNeToJSON(andNe: AndNe): string {
+  return JSON.stringify(AndNe$outboundSchema.parse(andNe));
 }
 
 /** @internal */
-export type AndEq$Outbound = string | number | boolean;
+export type DeploymentInvokeAndEq$Outbound = string | number | boolean;
 
 /** @internal */
-export const AndEq$outboundSchema: z.ZodType<
-  AndEq$Outbound,
+export const DeploymentInvokeAndEq$outboundSchema: z.ZodType<
+  DeploymentInvokeAndEq$Outbound,
   z.ZodTypeDef,
-  AndEq
+  DeploymentInvokeAndEq
 > = z.union([z.string(), z.number(), z.boolean()]);
 
-export function andEqToJSON(andEq: AndEq): string {
-  return JSON.stringify(AndEq$outboundSchema.parse(andEq));
+export function deploymentInvokeAndEqToJSON(
+  deploymentInvokeAndEq: DeploymentInvokeAndEq,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeAndEq$outboundSchema.parse(deploymentInvokeAndEq),
+  );
 }
 
 /** @internal */
-export type InvokeDeploymentRequestAndEq$Outbound = {
+export type AndEq$Outbound = {
   eq: string | number | boolean;
 };
 
 /** @internal */
-export const InvokeDeploymentRequestAndEq$outboundSchema: z.ZodType<
-  InvokeDeploymentRequestAndEq$Outbound,
+export const AndEq$outboundSchema: z.ZodType<
+  AndEq$Outbound,
   z.ZodTypeDef,
-  InvokeDeploymentRequestAndEq
+  AndEq
 > = z.object({
   eq: z.union([z.string(), z.number(), z.boolean()]),
 });
 
-export function invokeDeploymentRequestAndEqToJSON(
-  invokeDeploymentRequestAndEq: InvokeDeploymentRequestAndEq,
-): string {
-  return JSON.stringify(
-    InvokeDeploymentRequestAndEq$outboundSchema.parse(
-      invokeDeploymentRequestAndEq,
-    ),
-  );
+export function andEqToJSON(andEq: AndEq): string {
+  return JSON.stringify(AndEq$outboundSchema.parse(andEq));
 }
 
 /** @internal */
-export type And$Outbound =
-  | InvokeDeploymentRequestAndEq$Outbound
-  | InvokeDeploymentRequestAndNe$Outbound
+export type KnowledgeFilterAnd$Outbound =
+  | AndEq$Outbound
+  | AndNe$Outbound
   | AndGt$Outbound
   | AndGte$Outbound
   | AndLt$Outbound
   | AndLte$Outbound
-  | InvokeDeploymentRequestAndIn$Outbound
-  | InvokeDeploymentRequestAndNin$Outbound
+  | AndIn$Outbound
+  | AndNin$Outbound
   | AndExists$Outbound;
 
 /** @internal */
-export const And$outboundSchema: z.ZodType<And$Outbound, z.ZodTypeDef, And> = z
-  .union([
-    z.lazy(() => InvokeDeploymentRequestAndEq$outboundSchema),
-    z.lazy(() => InvokeDeploymentRequestAndNe$outboundSchema),
-    z.lazy(() => AndGt$outboundSchema),
-    z.lazy(() => AndGte$outboundSchema),
-    z.lazy(() => AndLt$outboundSchema),
-    z.lazy(() => AndLte$outboundSchema),
-    z.lazy(() => InvokeDeploymentRequestAndIn$outboundSchema),
-    z.lazy(() => InvokeDeploymentRequestAndNin$outboundSchema),
-    z.lazy(() => AndExists$outboundSchema),
-  ]);
+export const KnowledgeFilterAnd$outboundSchema: z.ZodType<
+  KnowledgeFilterAnd$Outbound,
+  z.ZodTypeDef,
+  KnowledgeFilterAnd
+> = z.union([
+  z.lazy(() => AndEq$outboundSchema),
+  z.lazy(() => AndNe$outboundSchema),
+  z.lazy(() => AndGt$outboundSchema),
+  z.lazy(() => AndGte$outboundSchema),
+  z.lazy(() => AndLt$outboundSchema),
+  z.lazy(() => AndLte$outboundSchema),
+  z.lazy(() => AndIn$outboundSchema),
+  z.lazy(() => AndNin$outboundSchema),
+  z.lazy(() => AndExists$outboundSchema),
+]);
 
-export function andToJSON(and: And): string {
-  return JSON.stringify(And$outboundSchema.parse(and));
+export function knowledgeFilterAndToJSON(
+  knowledgeFilterAnd: KnowledgeFilterAnd,
+): string {
+  return JSON.stringify(
+    KnowledgeFilterAnd$outboundSchema.parse(knowledgeFilterAnd),
+  );
 }
 
 /** @internal */
-export type KnowledgeFilterAnd$Outbound = {
+export type And$Outbound = {
   and: Array<
     {
       [k: string]:
-        | InvokeDeploymentRequestAndEq$Outbound
-        | InvokeDeploymentRequestAndNe$Outbound
+        | AndEq$Outbound
+        | AndNe$Outbound
         | AndGt$Outbound
         | AndGte$Outbound
         | AndLt$Outbound
         | AndLte$Outbound
-        | InvokeDeploymentRequestAndIn$Outbound
-        | InvokeDeploymentRequestAndNin$Outbound
+        | AndIn$Outbound
+        | AndNin$Outbound
         | AndExists$Outbound;
     }
   >;
 };
 
 /** @internal */
-export const KnowledgeFilterAnd$outboundSchema: z.ZodType<
-  KnowledgeFilterAnd$Outbound,
-  z.ZodTypeDef,
-  KnowledgeFilterAnd
-> = z.object({
-  and: z.array(
-    z.record(z.union([
-      z.lazy(() => InvokeDeploymentRequestAndEq$outboundSchema),
-      z.lazy(() =>
-        InvokeDeploymentRequestAndNe$outboundSchema
-      ),
-      z.lazy(() => AndGt$outboundSchema),
-      z.lazy(() => AndGte$outboundSchema),
-      z.lazy(() => AndLt$outboundSchema),
-      z.lazy(() => AndLte$outboundSchema),
-      z.lazy(() => InvokeDeploymentRequestAndIn$outboundSchema),
-      z.lazy(() => InvokeDeploymentRequestAndNin$outboundSchema),
-      z.lazy(() => AndExists$outboundSchema),
-    ])),
-  ),
-});
+export const And$outboundSchema: z.ZodType<And$Outbound, z.ZodTypeDef, And> = z
+  .object({
+    and: z.array(
+      z.record(z.union([
+        z.lazy(() => AndEq$outboundSchema),
+        z.lazy(() =>
+          AndNe$outboundSchema
+        ),
+        z.lazy(() => AndGt$outboundSchema),
+        z.lazy(() => AndGte$outboundSchema),
+        z.lazy(() => AndLt$outboundSchema),
+        z.lazy(() => AndLte$outboundSchema),
+        z.lazy(() => AndIn$outboundSchema),
+        z.lazy(() => AndNin$outboundSchema),
+        z.lazy(() => AndExists$outboundSchema),
+      ])),
+    ),
+  });
 
-export function knowledgeFilterAndToJSON(
-  knowledgeFilterAnd: KnowledgeFilterAnd,
-): string {
-  return JSON.stringify(
-    KnowledgeFilterAnd$outboundSchema.parse(knowledgeFilterAnd),
-  );
+export function andToJSON(and: And): string {
+  return JSON.stringify(And$outboundSchema.parse(and));
 }
 
 /** @internal */
@@ -3083,63 +3420,63 @@ export function existsToJSON(exists: Exists): string {
 }
 
 /** @internal */
-export type Nin$Outbound = string | number | boolean;
-
-/** @internal */
-export const Nin$outboundSchema: z.ZodType<Nin$Outbound, z.ZodTypeDef, Nin> = z
-  .union([z.string(), z.number(), z.boolean()]);
-
-export function ninToJSON(nin: Nin): string {
-  return JSON.stringify(Nin$outboundSchema.parse(nin));
-}
-
-/** @internal */
-export type OneNin$Outbound = {
-  nin: Array<string | number | boolean>;
-};
+export type OneNin$Outbound = string | number | boolean;
 
 /** @internal */
 export const OneNin$outboundSchema: z.ZodType<
   OneNin$Outbound,
   z.ZodTypeDef,
   OneNin
-> = z.object({
-  nin: z.array(z.union([z.string(), z.number(), z.boolean()])),
-});
+> = z.union([z.string(), z.number(), z.boolean()]);
 
 export function oneNinToJSON(oneNin: OneNin): string {
   return JSON.stringify(OneNin$outboundSchema.parse(oneNin));
 }
 
 /** @internal */
-export type In$Outbound = string | number | boolean;
+export type Nin$Outbound = {
+  nin: Array<string | number | boolean>;
+};
 
 /** @internal */
-export const In$outboundSchema: z.ZodType<In$Outbound, z.ZodTypeDef, In> = z
-  .union([z.string(), z.number(), z.boolean()]);
+export const Nin$outboundSchema: z.ZodType<Nin$Outbound, z.ZodTypeDef, Nin> = z
+  .object({
+    nin: z.array(z.union([z.string(), z.number(), z.boolean()])),
+  });
 
-export function inToJSON(value: In): string {
-  return JSON.stringify(In$outboundSchema.parse(value));
+export function ninToJSON(nin: Nin): string {
+  return JSON.stringify(Nin$outboundSchema.parse(nin));
 }
 
 /** @internal */
-export type OneIn$Outbound = {
-  in: Array<string | number | boolean>;
-};
+export type OneIn$Outbound = string | number | boolean;
 
 /** @internal */
 export const OneIn$outboundSchema: z.ZodType<
   OneIn$Outbound,
   z.ZodTypeDef,
   OneIn
-> = z.object({
-  in: z.array(z.union([z.string(), z.number(), z.boolean()])),
-});
+> = z.union([z.string(), z.number(), z.boolean()]);
 
 export function oneInToJSON(oneIn: OneIn): string {
   return JSON.stringify(OneIn$outboundSchema.parse(oneIn));
 }
 
+/** @internal */
+export type In$Outbound = {
+  in: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const In$outboundSchema: z.ZodType<In$Outbound, z.ZodTypeDef, In> = z
+  .object({
+    in: z.array(z.union([z.string(), z.number(), z.boolean()])),
+  });
+
+export function inToJSON(value: In): string {
+  return JSON.stringify(In$outboundSchema.parse(value));
+}
+
 /** @internal */
 export type Lte$Outbound = {
   lte: number;
@@ -3201,109 +3538,113 @@ export function gtToJSON(gt: Gt): string {
 }
 
 /** @internal */
-export type Ne$Outbound = string | number | boolean;
-
-/** @internal */
-export const Ne$outboundSchema: z.ZodType<Ne$Outbound, z.ZodTypeDef, Ne> = z
-  .union([z.string(), z.number(), z.boolean()]);
-
-export function neToJSON(ne: Ne): string {
-  return JSON.stringify(Ne$outboundSchema.parse(ne));
-}
-
-/** @internal */
-export type OneNe$Outbound = {
-  ne: string | number | boolean;
-};
+export type OneNe$Outbound = string | number | boolean;
 
 /** @internal */
 export const OneNe$outboundSchema: z.ZodType<
   OneNe$Outbound,
   z.ZodTypeDef,
   OneNe
-> = z.object({
-  ne: z.union([z.string(), z.number(), z.boolean()]),
-});
+> = z.union([z.string(), z.number(), z.boolean()]);
 
 export function oneNeToJSON(oneNe: OneNe): string {
   return JSON.stringify(OneNe$outboundSchema.parse(oneNe));
 }
 
 /** @internal */
-export type Eq$Outbound = string | number | boolean;
+export type Ne$Outbound = {
+  ne: string | number | boolean;
+};
 
 /** @internal */
-export const Eq$outboundSchema: z.ZodType<Eq$Outbound, z.ZodTypeDef, Eq> = z
-  .union([z.string(), z.number(), z.boolean()]);
+export const Ne$outboundSchema: z.ZodType<Ne$Outbound, z.ZodTypeDef, Ne> = z
+  .object({
+    ne: z.union([z.string(), z.number(), z.boolean()]),
+  });
 
-export function eqToJSON(eq: Eq): string {
-  return JSON.stringify(Eq$outboundSchema.parse(eq));
+export function neToJSON(ne: Ne): string {
+  return JSON.stringify(Ne$outboundSchema.parse(ne));
 }
 
 /** @internal */
-export type OneEq$Outbound = {
-  eq: string | number | boolean;
-};
+export type OneEq$Outbound = string | number | boolean;
 
 /** @internal */
 export const OneEq$outboundSchema: z.ZodType<
   OneEq$Outbound,
   z.ZodTypeDef,
   OneEq
-> = z.object({
-  eq: z.union([z.string(), z.number(), z.boolean()]),
-});
+> = z.union([z.string(), z.number(), z.boolean()]);
 
 export function oneEqToJSON(oneEq: OneEq): string {
   return JSON.stringify(OneEq$outboundSchema.parse(oneEq));
 }
 
 /** @internal */
-export type One$Outbound =
-  | OneEq$Outbound
-  | OneNe$Outbound
+export type Eq$Outbound = {
+  eq: string | number | boolean;
+};
+
+/** @internal */
+export const Eq$outboundSchema: z.ZodType<Eq$Outbound, z.ZodTypeDef, Eq> = z
+  .object({
+    eq: z.union([z.string(), z.number(), z.boolean()]),
+  });
+
+export function eqToJSON(eq: Eq): string {
+  return JSON.stringify(Eq$outboundSchema.parse(eq));
+}
+
+/** @internal */
+export type KnowledgeFilter1$Outbound =
+  | Eq$Outbound
+  | Ne$Outbound
   | Gt$Outbound
   | Gte$Outbound
   | Lt$Outbound
   | Lte$Outbound
-  | OneIn$Outbound
-  | OneNin$Outbound
+  | In$Outbound
+  | Nin$Outbound
   | Exists$Outbound;
 
 /** @internal */
-export const One$outboundSchema: z.ZodType<One$Outbound, z.ZodTypeDef, One> = z
-  .union([
-    z.lazy(() => OneEq$outboundSchema),
-    z.lazy(() => OneNe$outboundSchema),
-    z.lazy(() => Gt$outboundSchema),
-    z.lazy(() => Gte$outboundSchema),
-    z.lazy(() => Lt$outboundSchema),
-    z.lazy(() => Lte$outboundSchema),
-    z.lazy(() => OneIn$outboundSchema),
-    z.lazy(() => OneNin$outboundSchema),
-    z.lazy(() => Exists$outboundSchema),
-  ]);
+export const KnowledgeFilter1$outboundSchema: z.ZodType<
+  KnowledgeFilter1$Outbound,
+  z.ZodTypeDef,
+  KnowledgeFilter1
+> = z.union([
+  z.lazy(() => Eq$outboundSchema),
+  z.lazy(() => Ne$outboundSchema),
+  z.lazy(() => Gt$outboundSchema),
+  z.lazy(() => Gte$outboundSchema),
+  z.lazy(() => Lt$outboundSchema),
+  z.lazy(() => Lte$outboundSchema),
+  z.lazy(() => In$outboundSchema),
+  z.lazy(() => Nin$outboundSchema),
+  z.lazy(() => Exists$outboundSchema),
+]);
 
-export function oneToJSON(one: One): string {
-  return JSON.stringify(One$outboundSchema.parse(one));
+export function knowledgeFilter1ToJSON(
+  knowledgeFilter1: KnowledgeFilter1,
+): string {
+  return JSON.stringify(
+    KnowledgeFilter1$outboundSchema.parse(knowledgeFilter1),
+  );
 }
 
 /** @internal */
-export type KnowledgeFilter$Outbound =
-  | KnowledgeFilterAnd$Outbound
-  | KnowledgeFilterOr$Outbound
-  | {
-    [k: string]:
-      | OneEq$Outbound
-      | OneNe$Outbound
-      | Gt$Outbound
-      | Gte$Outbound
-      | Lt$Outbound
-      | Lte$Outbound
-      | OneIn$Outbound
-      | OneNin$Outbound
-      | Exists$Outbound;
-  };
+export type KnowledgeFilter$Outbound = And$Outbound | Or$Outbound | {
+  [k: string]:
+    | Eq$Outbound
+    | Ne$Outbound
+    | Gt$Outbound
+    | Gte$Outbound
+    | Lt$Outbound
+    | Lte$Outbound
+    | In$Outbound
+    | Nin$Outbound
+    | Exists$Outbound;
+};
 
 /** @internal */
 export const KnowledgeFilter$outboundSchema: z.ZodType<
@@ -3311,17 +3652,17 @@ export const KnowledgeFilter$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   KnowledgeFilter
 > = z.union([
-  z.lazy(() => KnowledgeFilterAnd$outboundSchema),
-  z.lazy(() => KnowledgeFilterOr$outboundSchema),
+  z.lazy(() => And$outboundSchema),
+  z.lazy(() => Or$outboundSchema),
   z.record(z.union([
-    z.lazy(() => OneEq$outboundSchema),
-    z.lazy(() => OneNe$outboundSchema),
+    z.lazy(() => Eq$outboundSchema),
+    z.lazy(() => Ne$outboundSchema),
     z.lazy(() => Gt$outboundSchema),
     z.lazy(() => Gte$outboundSchema),
     z.lazy(() => Lt$outboundSchema),
     z.lazy(() => Lte$outboundSchema),
-    z.lazy(() => OneIn$outboundSchema),
-    z.lazy(() => OneNin$outboundSchema),
+    z.lazy(() => In$outboundSchema),
+    z.lazy(() => Nin$outboundSchema),
     z.lazy(() => Exists$outboundSchema),
   ])),
 ]);
@@ -3333,7 +3674,7 @@ export function knowledgeFilterToJSON(
 }
 
 /** @internal */
-export type InvokeDeploymentRequest$Outbound = {
+export type DeploymentInvokeRequestBody$Outbound = {
   key: string;
   stream: boolean;
   inputs?: { [k: string]: any } | undefined;
@@ -3356,36 +3697,32 @@ export type InvokeDeploymentRequest$Outbound = {
       | MessagesToolMessage$Outbound
     >
     | undefined;
-  identity?: PublicIdentity$Outbound | undefined;
+  identity?: components.PublicIdentity$Outbound | undefined;
   file_ids?: Array<string> | undefined;
   metadata?: { [k: string]: any } | undefined;
   extra_params?: { [k: string]: any } | undefined;
   documents?: Array<Documents$Outbound> | undefined;
   invoke_options?: InvokeOptions$Outbound | undefined;
   thread?: Thread$Outbound | undefined;
-  knowledge_filter?:
-    | KnowledgeFilterAnd$Outbound
-    | KnowledgeFilterOr$Outbound
-    | {
-      [k: string]:
-        | OneEq$Outbound
-        | OneNe$Outbound
-        | Gt$Outbound
-        | Gte$Outbound
-        | Lt$Outbound
-        | Lte$Outbound
-        | OneIn$Outbound
-        | OneNin$Outbound
-        | Exists$Outbound;
-    }
-    | undefined;
+  knowledge_filter?: And$Outbound | Or$Outbound | {
+    [k: string]:
+      | Eq$Outbound
+      | Ne$Outbound
+      | Gt$Outbound
+      | Gte$Outbound
+      | Lt$Outbound
+      | Lte$Outbound
+      | In$Outbound
+      | Nin$Outbound
+      | Exists$Outbound;
+  } | undefined;
 };
 
 /** @internal */
-export const InvokeDeploymentRequest$outboundSchema: z.ZodType<
-  InvokeDeploymentRequest$Outbound,
+export const DeploymentInvokeRequestBody$outboundSchema: z.ZodType<
+  DeploymentInvokeRequestBody$Outbound,
   z.ZodTypeDef,
-  InvokeDeploymentRequest
+  DeploymentInvokeRequestBody
 > = z.object({
   key: z.string(),
   stream: z.boolean().default(false),
@@ -3409,7 +3746,7 @@ export const InvokeDeploymentRequest$outboundSchema: z.ZodType<
       z.lazy(() => MessagesToolMessage$outboundSchema),
     ]),
   ).optional(),
-  identity: PublicIdentity$outboundSchema.optional(),
+  identity: components.PublicIdentity$outboundSchema.optional(),
   fileIds: z.array(z.string()).optional(),
   metadata: z.record(z.any()).optional(),
   extraParams: z.record(z.any()).optional(),
@@ -3417,17 +3754,17 @@ export const InvokeDeploymentRequest$outboundSchema: z.ZodType<
   invokeOptions: z.lazy(() => InvokeOptions$outboundSchema).optional(),
   thread: z.lazy(() => Thread$outboundSchema).optional(),
   knowledgeFilter: z.union([
-    z.lazy(() => KnowledgeFilterAnd$outboundSchema),
-    z.lazy(() => KnowledgeFilterOr$outboundSchema),
+    z.lazy(() => And$outboundSchema),
+    z.lazy(() => Or$outboundSchema),
     z.record(z.union([
-      z.lazy(() => OneEq$outboundSchema),
-      z.lazy(() => OneNe$outboundSchema),
+      z.lazy(() => Eq$outboundSchema),
+      z.lazy(() => Ne$outboundSchema),
       z.lazy(() => Gt$outboundSchema),
       z.lazy(() => Gte$outboundSchema),
       z.lazy(() => Lt$outboundSchema),
       z.lazy(() => Lte$outboundSchema),
-      z.lazy(() => OneIn$outboundSchema),
-      z.lazy(() => OneNin$outboundSchema),
+      z.lazy(() => In$outboundSchema),
+      z.lazy(() => Nin$outboundSchema),
       z.lazy(() => Exists$outboundSchema),
     ])),
   ]).optional(),
@@ -3441,10 +3778,401 @@ export const InvokeDeploymentRequest$outboundSchema: z.ZodType<
   });
 });
 
-export function invokeDeploymentRequestToJSON(
-  invokeDeploymentRequest: InvokeDeploymentRequest,
+export function deploymentInvokeRequestBodyToJSON(
+  deploymentInvokeRequestBody: DeploymentInvokeRequestBody,
 ): string {
   return JSON.stringify(
-    InvokeDeploymentRequest$outboundSchema.parse(invokeDeploymentRequest),
+    DeploymentInvokeRequestBody$outboundSchema.parse(
+      deploymentInvokeRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export const DeploymentInvokeObject$inboundSchema: z.ZodNativeEnum<
+  typeof DeploymentInvokeObject
+> = z.nativeEnum(DeploymentInvokeObject);
+
+/** @internal */
+export const Provider$inboundSchema: z.ZodNativeEnum<typeof Provider> = z
+  .nativeEnum(Provider);
+
+/** @internal */
+export const Telemetry$inboundSchema: z.ZodType<
+  Telemetry,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  trace_id: z.string(),
+  span_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "trace_id": "traceId",
+    "span_id": "spanId",
+  });
+});
+
+export function telemetryFromJSON(
+  jsonString: string,
+): SafeParseResult<Telemetry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Telemetry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Telemetry' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInvokeMetadata$inboundSchema: z.ZodType<
+  DeploymentInvokeMetadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  file_name: z.string(),
+  page_number: z.nullable(z.number()),
+  file_type: z.string(),
+  rerank_score: z.number().optional(),
+  search_score: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    "file_name": "fileName",
+    "page_number": "pageNumber",
+    "file_type": "fileType",
+    "rerank_score": "rerankScore",
+    "search_score": "searchScore",
+  });
+});
+
+export function deploymentInvokeMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInvokeMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInvokeMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInvokeMetadata' from JSON`,
+  );
+}
+
+/** @internal */
+export const Retrievals$inboundSchema: z.ZodType<
+  Retrievals,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  document: z.string(),
+  metadata: z.lazy(() => DeploymentInvokeMetadata$inboundSchema),
+});
+
+export function retrievalsFromJSON(
+  jsonString: string,
+): SafeParseResult<Retrievals, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Retrievals$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Retrievals' from JSON`,
+  );
+}
+
+/** @internal */
+export const PromptTokensDetails$inboundSchema: z.ZodType<
+  PromptTokensDetails,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  cached_tokens: z.nullable(z.number()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "cached_tokens": "cachedTokens",
+  });
+});
+
+export function promptTokensDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<PromptTokensDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PromptTokensDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PromptTokensDetails' from JSON`,
+  );
+}
+
+/** @internal */
+export const CompletionTokensDetails$inboundSchema: z.ZodType<
+  CompletionTokensDetails,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  reasoning_tokens: z.nullable(z.number()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "reasoning_tokens": "reasoningTokens",
+  });
+});
+
+export function completionTokensDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<CompletionTokensDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CompletionTokensDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CompletionTokensDetails' from JSON`,
+  );
+}
+
+/** @internal */
+export const Usage$inboundSchema: z.ZodType<Usage, z.ZodTypeDef, unknown> = z
+  .object({
+    total_tokens: z.number().optional(),
+    prompt_tokens: z.number().optional(),
+    completion_tokens: z.number().optional(),
+    prompt_tokens_details: z.lazy(() => PromptTokensDetails$inboundSchema)
+      .optional(),
+    completion_tokens_details: z.nullable(
+      z.lazy(() => CompletionTokensDetails$inboundSchema),
+    ).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "total_tokens": "totalTokens",
+      "prompt_tokens": "promptTokens",
+      "completion_tokens": "completionTokens",
+      "prompt_tokens_details": "promptTokensDetails",
+      "completion_tokens_details": "completionTokensDetails",
+    });
+  });
+
+export function usageFromJSON(
+  jsonString: string,
+): SafeParseResult<Usage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Usage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Usage' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInvokeMessageDeploymentsRole$inboundSchema:
+  z.ZodNativeEnum<typeof DeploymentInvokeMessageDeploymentsRole> = z.nativeEnum(
+    DeploymentInvokeMessageDeploymentsRole,
+  );
+
+/** @internal */
+export const Message3$inboundSchema: z.ZodType<
+  Message3,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("image"),
+  role: DeploymentInvokeMessageDeploymentsRole$inboundSchema,
+  url: z.string(),
+});
+
+export function message3FromJSON(
+  jsonString: string,
+): SafeParseResult<Message3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Message3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Message3' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInvokeMessageRole$inboundSchema: z.ZodNativeEnum<
+  typeof DeploymentInvokeMessageRole
+> = z.nativeEnum(DeploymentInvokeMessageRole);
+
+/** @internal */
+export const Message2$inboundSchema: z.ZodType<
+  Message2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("content"),
+  role: DeploymentInvokeMessageRole$inboundSchema,
+  content: z.nullable(z.string()),
+  reasoning: z.string().optional(),
+  reasoning_signature: z.string().optional(),
+  redacted_reasoning: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "reasoning_signature": "reasoningSignature",
+    "redacted_reasoning": "redactedReasoning",
+  });
+});
+
+export function message2FromJSON(
+  jsonString: string,
+): SafeParseResult<Message2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Message2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Message2' from JSON`,
+  );
+}
+
+/** @internal */
+export const MessageRole$inboundSchema: z.ZodNativeEnum<typeof MessageRole> = z
+  .nativeEnum(MessageRole);
+
+/** @internal */
+export const DeploymentInvokeMessageDeploymentsResponseType$inboundSchema:
+  z.ZodNativeEnum<typeof DeploymentInvokeMessageDeploymentsResponseType> = z
+    .nativeEnum(DeploymentInvokeMessageDeploymentsResponseType);
+
+/** @internal */
+export const MessageFunction$inboundSchema: z.ZodType<
+  MessageFunction,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string(),
+  arguments: z.string(),
+});
+
+export function messageFunctionFromJSON(
+  jsonString: string,
+): SafeParseResult<MessageFunction, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MessageFunction$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MessageFunction' from JSON`,
+  );
+}
+
+/** @internal */
+export const MessageToolCalls$inboundSchema: z.ZodType<
+  MessageToolCalls,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  index: z.number().optional(),
+  type: DeploymentInvokeMessageDeploymentsResponseType$inboundSchema,
+  function: z.lazy(() => MessageFunction$inboundSchema),
+});
+
+export function messageToolCallsFromJSON(
+  jsonString: string,
+): SafeParseResult<MessageToolCalls, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MessageToolCalls$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MessageToolCalls' from JSON`,
+  );
+}
+
+/** @internal */
+export const Message1$inboundSchema: z.ZodType<
+  Message1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("tool_calls"),
+  role: MessageRole$inboundSchema,
+  content: z.nullable(z.string()).optional(),
+  tool_calls: z.array(z.lazy(() => MessageToolCalls$inboundSchema)),
+  reasoning: z.string().optional(),
+  reasoning_signature: z.string().optional(),
+  redacted_reasoning: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "tool_calls": "toolCalls",
+    "reasoning_signature": "reasoningSignature",
+    "redacted_reasoning": "redactedReasoning",
+  });
+});
+
+export function message1FromJSON(
+  jsonString: string,
+): SafeParseResult<Message1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Message1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Message1' from JSON`,
+  );
+}
+
+/** @internal */
+export const Message$inboundSchema: z.ZodType<Message, z.ZodTypeDef, unknown> =
+  z.union([
+    z.lazy(() => Message1$inboundSchema),
+    z.lazy(() => Message2$inboundSchema),
+    z.lazy(() => Message3$inboundSchema),
+  ]);
+
+export function messageFromJSON(
+  jsonString: string,
+): SafeParseResult<Message, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Message$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Message' from JSON`,
+  );
+}
+
+/** @internal */
+export const Choices$inboundSchema: z.ZodType<Choices, z.ZodTypeDef, unknown> =
+  z.object({
+    index: z.number(),
+    message: z.union([
+      z.lazy(() => Message1$inboundSchema),
+      z.lazy(() => Message2$inboundSchema),
+      z.lazy(() => Message3$inboundSchema),
+    ]),
+    finish_reason: z.nullable(z.string()).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "finish_reason": "finishReason",
+    });
+  });
+
+export function choicesFromJSON(
+  jsonString: string,
+): SafeParseResult<Choices, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Choices$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Choices' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentInvokeResponseBody$inboundSchema: z.ZodType<
+  DeploymentInvokeResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  created: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  object: DeploymentInvokeObject$inboundSchema,
+  model: z.string(),
+  provider: Provider$inboundSchema,
+  is_final: z.boolean(),
+  integration_id: z.string().optional(),
+  telemetry: z.lazy(() => Telemetry$inboundSchema),
+  finalized: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  system_fingerprint: z.nullable(z.string()).optional(),
+  retrievals: z.array(z.lazy(() => Retrievals$inboundSchema)).optional(),
+  provider_response: z.any().optional(),
+  usage: z.nullable(z.lazy(() => Usage$inboundSchema)).optional(),
+  choices: z.array(z.lazy(() => Choices$inboundSchema)),
+}).transform((v) => {
+  return remap$(v, {
+    "is_final": "isFinal",
+    "integration_id": "integrationId",
+    "system_fingerprint": "systemFingerprint",
+    "provider_response": "providerResponse",
+  });
+});
+
+export function deploymentInvokeResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentInvokeResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentInvokeResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentInvokeResponseBody' from JSON`,
   );
 }