@orq-ai/node 4.10.0-rc.45 → 4.10.0-rc.47

package/src/models/operations/deploymentinvoke.ts

@@ -7,334 +7,3787 @@ import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
+export type DeploymentInvokeContentDeployments2 =
+  components.TextContentPartSchema;
+
 /**
- * Indicates the type of model used to generate the response
+ * The contents of the tool message.
  */
-export const DeploymentInvokeObject = {
-  Chat: "chat",
-  Completion: "completion",
-  Image: "image",
+export type DeploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent =
+  | string
+  | Array<components.TextContentPartSchema>;
+
+/**
+ * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+ */
+export const DeploymentInvokePrefixMessagesType = {
+  Ephemeral: "ephemeral",
 } as const;
 /**
- * Indicates the type of model used to generate the response
+ * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
  */
-export type DeploymentInvokeObject = ClosedEnum<typeof DeploymentInvokeObject>;
+export type DeploymentInvokePrefixMessagesType = ClosedEnum<
+  typeof DeploymentInvokePrefixMessagesType
+>;
 
 /**
- * The provider used to generate the response
+ * The time-to-live for the cache control breakpoint. This may be one of the following values:
+ *
+ * @remarks
+ *
+ * - `5m`: 5 minutes
+ * - `1h`: 1 hour
+ *
+ * Defaults to `5m`. Only supported by `Anthropic` Claude models.
  */
-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",
+export const PrefixMessagesTtl = {
+  Fivem: "5m",
+  Oneh: "1h",
 } as const;
 /**
- * The provider used to generate the response
+ * The time-to-live for the cache control breakpoint. This may be one of the following values:
+ *
+ * @remarks
+ *
+ * - `5m`: 5 minutes
+ * - `1h`: 1 hour
+ *
+ * Defaults to `5m`. Only supported by `Anthropic` Claude models.
  */
-export type Provider = ClosedEnum<typeof Provider>;
+export type PrefixMessagesTtl = ClosedEnum<typeof PrefixMessagesTtl>;
 
-export type Telemetry = {
+export type PrefixMessagesCacheControl = {
   /**
-   * The trace id for the request that generated this response
+   * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
    */
-  traceId: string;
+  type: DeploymentInvokePrefixMessagesType;
   /**
-   * The span id for the request that generated this response
+   * The time-to-live for the cache control breakpoint. This may be one of the following values:
+   *
+   * @remarks
+   *
+   * - `5m`: 5 minutes
+   * - `1h`: 1 hour
+   *
+   * Defaults to `5m`. Only supported by `Anthropic` Claude models.
    */
-  spanId: string;
+  ttl?: PrefixMessagesTtl | undefined;
+};
+
+export type ToolMessage = {
+  /**
+   * The role of the messages author, in this case tool.
+   */
+  role: "tool";
+  /**
+   * The contents of the tool message.
+   */
+  content: string | Array<components.TextContentPartSchema>;
+  /**
+   * Tool call that this message is responding to.
+   */
+  toolCallId: string | null;
+  cacheControl?: PrefixMessagesCacheControl | undefined;
+};
+
+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 DeploymentInvokePrefixMessagesDeploymentsRequestContent =
+  | string
+  | Array<
+    | (components.TextContentPartSchema & { type: "text" })
+    | components.RefusalPartSchema
+    | components.ReasoningPartSchema
+    | components.RedactedReasoningPartSchema
+  >;
+
+/**
+ * Data about a previous audio response from the model.
+ */
+export type Audio = {
+  /**
+   * Unique identifier for a previous audio response from the model.
+   */
+  id: string;
 };
 
 /**
- * Metadata of the retrieved chunk from the knowledge base
+ * The type of the tool. Currently, only `function` is supported.
  */
-export type DeploymentInvokeMetadata = {
+export const PrefixMessagesType = {
+  Function: "function",
+} as const;
+/**
+ * The type of the tool. Currently, only `function` is supported.
+ */
+export type PrefixMessagesType = ClosedEnum<typeof PrefixMessagesType>;
+
+export type PrefixMessagesFunction = {
   /**
-   * Name of the file
+   * The name of the function to call.
    */
-  fileName: string;
+  name?: string | undefined;
   /**
-   * Page number of the chunk
+   * The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function.
    */
-  pageNumber: number | null;
+  arguments?: string | undefined;
+};
+
+export type PrefixMessagesToolCalls = {
   /**
-   * Type of the file
+   * The ID of the tool call.
    */
-  fileType: string;
+  id: 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
+   * The type of the tool. Currently, only `function` is supported.
    */
-  rerankScore?: number | undefined;
+  type: PrefixMessagesType;
+  function: PrefixMessagesFunction;
   /**
-   * 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.
+   * Encrypted representation of the model internal reasoning state during function calling. Required by Gemini 3 models when continuing a conversation after a tool call.
    */
-  searchScore: number;
+  thoughtSignature?: string | undefined;
 };
 
-export type Retrievals = {
+export type AssistantMessage = {
   /**
-   * Content of the retrieved chunk from the knowledge base
+   * The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified.
    */
-  document: string;
+  content?:
+    | string
+    | Array<
+      | (components.TextContentPartSchema & { type: "text" })
+      | components.RefusalPartSchema
+      | components.ReasoningPartSchema
+      | components.RedactedReasoningPartSchema
+    >
+    | null
+    | undefined;
   /**
-   * Metadata of the retrieved chunk from the knowledge base
+   * The refusal message by the assistant.
    */
-  metadata: DeploymentInvokeMetadata;
+  refusal?: string | null | undefined;
+  /**
+   * The role of the messages author, in this case `assistant`.
+   */
+  role: "assistant";
+  /**
+   * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
+   */
+  name?: string | undefined;
+  /**
+   * Data about a previous audio response from the model.
+   */
+  audio?: Audio | null | undefined;
+  /**
+   * The tool calls generated by the model, such as function calls.
+   */
+  toolCalls?: Array<PrefixMessagesToolCalls> | undefined;
+};
+
+/**
+ * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+ */
+export const DeploymentInvoke2DeploymentsType = {
+  Ephemeral: "ephemeral",
+} as const;
+/**
+ * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+ */
+export type DeploymentInvoke2DeploymentsType = ClosedEnum<
+  typeof DeploymentInvoke2DeploymentsType
+>;
+
+/**
+ * The time-to-live for the cache control breakpoint. This may be one of the following values:
+ *
+ * @remarks
+ *
+ * - `5m`: 5 minutes
+ * - `1h`: 1 hour
+ *
+ * Defaults to `5m`. Only supported by `Anthropic` Claude models.
+ */
+export const Ttl = {
+  Fivem: "5m",
+  Oneh: "1h",
+} as const;
+/**
+ * The time-to-live for the cache control breakpoint. This may be one of the following values:
+ *
+ * @remarks
+ *
+ * - `5m`: 5 minutes
+ * - `1h`: 1 hour
+ *
+ * Defaults to `5m`. Only supported by `Anthropic` Claude models.
+ */
+export type Ttl = ClosedEnum<typeof Ttl>;
+
+export type CacheControl = {
+  /**
+   * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+   */
+  type: DeploymentInvoke2DeploymentsType;
+  /**
+   * The time-to-live for the cache control breakpoint. This may be one of the following values:
+   *
+   * @remarks
+   *
+   * - `5m`: 5 minutes
+   * - `1h`: 1 hour
+   *
+   * Defaults to `5m`. Only supported by `Anthropic` Claude models.
+   */
+  ttl?: Ttl | undefined;
+};
+
+export type Four = {
+  /**
+   * The type of the content part. Always `file`.
+   */
+  type: "file";
+  cacheControl?: CacheControl | undefined;
+  /**
+   * File data for the content part. Must contain either file_data or uri, but not both.
+   */
+  file: components.FileContentPartSchema;
+};
+
+export type Content2 =
+  | (components.TextContentPartSchema & { type: "text" })
+  | components.ImageContentPartSchema
+  | components.AudioContentPartSchema
+  | Four;
+
+/**
+ * The contents of the user message.
+ */
+export type DeploymentInvokePrefixMessagesDeploymentsContent =
+  | string
+  | Array<
+    | (components.TextContentPartSchema & { type: "text" })
+    | components.ImageContentPartSchema
+    | components.AudioContentPartSchema
+    | Four
+  >;
+
+export type UserMessage = {
+  /**
+   * The role of the messages author, in this case `user`.
+   */
+  role: "user";
+  /**
+   * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
+   */
+  name?: string | undefined;
+  /**
+   * The contents of the user message.
+   */
+  content:
+    | string
+    | Array<
+      | (components.TextContentPartSchema & { type: "text" })
+      | components.ImageContentPartSchema
+      | components.AudioContentPartSchema
+      | Four
+    >;
+};
+
+/**
+ * The contents of the developer message.
+ */
+export type DeploymentInvokePrefixMessagesContent =
+  | string
+  | Array<components.TextContentPartSchema>;
+
+export type DeveloperMessage = {
+  /**
+   * The role of the messages author, in this case  `developer`.
+   */
+  role: "developer";
+  /**
+   * The contents of the developer message.
+   */
+  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;
+};
+
+/**
+ * The contents of the system message.
+ */
+export type PrefixMessagesContent =
+  | string
+  | Array<components.TextContentPartSchema>;
+
+/**
+ * Developer-provided instructions that the model should follow, regardless of messages sent by the user.
+ */
+export type SystemMessage = {
+  /**
+   * The role of the messages author, in this case `system`.
+   */
+  role: "system";
+  /**
+   * The contents of the system message.
+   */
+  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 PrefixMessages =
+  | SystemMessage
+  | DeveloperMessage
+  | UserMessage
+  | AssistantMessage
+  | ToolMessage;
+
+export type DeploymentInvokeContentDeploymentsRequestRequestBodyMessages2 =
+  components.TextContentPartSchema;
+
+/**
+ * The contents of the tool message.
+ */
+export type DeploymentInvokeMessagesDeploymentsRequestRequestBodyContent =
+  | string
+  | Array<components.TextContentPartSchema>;
+
+/**
+ * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+ */
+export const DeploymentInvokeMessagesType = {
+  Ephemeral: "ephemeral",
+} as const;
+/**
+ * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+ */
+export type DeploymentInvokeMessagesType = ClosedEnum<
+  typeof DeploymentInvokeMessagesType
+>;
+
+/**
+ * The time-to-live for the cache control breakpoint. This may be one of the following values:
+ *
+ * @remarks
+ *
+ * - `5m`: 5 minutes
+ * - `1h`: 1 hour
+ *
+ * Defaults to `5m`. Only supported by `Anthropic` Claude models.
+ */
+export const MessagesTtl = {
+  Fivem: "5m",
+  Oneh: "1h",
+} as const;
+/**
+ * The time-to-live for the cache control breakpoint. This may be one of the following values:
+ *
+ * @remarks
+ *
+ * - `5m`: 5 minutes
+ * - `1h`: 1 hour
+ *
+ * Defaults to `5m`. Only supported by `Anthropic` Claude models.
+ */
+export type MessagesTtl = ClosedEnum<typeof MessagesTtl>;
+
+export type MessagesCacheControl = {
+  /**
+   * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+   */
+  type: DeploymentInvokeMessagesType;
+  /**
+   * The time-to-live for the cache control breakpoint. This may be one of the following values:
+   *
+   * @remarks
+   *
+   * - `5m`: 5 minutes
+   * - `1h`: 1 hour
+   *
+   * Defaults to `5m`. Only supported by `Anthropic` Claude models.
+   */
+  ttl?: MessagesTtl | undefined;
 };
 
-export type PromptTokensDetails = {
-  cachedTokens?: number | null | undefined;
-};
+export type MessagesToolMessage = {
+  /**
+   * The role of the messages author, in this case tool.
+   */
+  role: "tool";
+  /**
+   * The contents of the tool message.
+   */
+  content: string | Array<components.TextContentPartSchema>;
+  /**
+   * Tool call that this message is responding to.
+   */
+  toolCallId: string | null;
+  cacheControl?: MessagesCacheControl | undefined;
+};
+
+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 DeploymentInvokeMessagesDeploymentsRequestContent =
+  | string
+  | Array<
+    | (components.TextContentPartSchema & { type: "text" })
+    | components.RefusalPartSchema
+    | components.ReasoningPartSchema
+    | components.RedactedReasoningPartSchema
+  >;
+
+/**
+ * Data about a previous audio response from the model.
+ */
+export type MessagesAudio = {
+  /**
+   * Unique identifier for a previous audio response from the model.
+   */
+  id: string;
+};
+
+/**
+ * The type of the tool. Currently, only `function` is supported.
+ */
+export const MessagesType = {
+  Function: "function",
+} as const;
+/**
+ * The type of the tool. Currently, only `function` is supported.
+ */
+export type MessagesType = ClosedEnum<typeof MessagesType>;
+
+export type MessagesFunction = {
+  /**
+   * The name of the function to call.
+   */
+  name?: string | undefined;
+  /**
+   * The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function.
+   */
+  arguments?: string | undefined;
+};
+
+export type MessagesToolCalls = {
+  /**
+   * The ID of the tool call.
+   */
+  id: string;
+  /**
+   * The type of the tool. Currently, only `function` is supported.
+   */
+  type: MessagesType;
+  function: MessagesFunction;
+  /**
+   * Encrypted representation of the model internal reasoning state during function calling. Required by Gemini 3 models when continuing a conversation after a tool call.
+   */
+  thoughtSignature?: string | undefined;
+};
+
+export type MessagesAssistantMessage = {
+  /**
+   * The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified.
+   */
+  content?:
+    | string
+    | Array<
+      | (components.TextContentPartSchema & { type: "text" })
+      | components.RefusalPartSchema
+      | components.ReasoningPartSchema
+      | components.RedactedReasoningPartSchema
+    >
+    | null
+    | undefined;
+  /**
+   * The refusal message by the assistant.
+   */
+  refusal?: string | null | undefined;
+  /**
+   * The role of the messages author, in this case `assistant`.
+   */
+  role: "assistant";
+  /**
+   * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
+   */
+  name?: string | undefined;
+  /**
+   * Data about a previous audio response from the model.
+   */
+  audio?: MessagesAudio | null | undefined;
+  /**
+   * The tool calls generated by the model, such as function calls.
+   */
+  toolCalls?: Array<MessagesToolCalls> | undefined;
+};
+
+/**
+ * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+ */
+export const DeploymentInvoke2DeploymentsRequestRequestBodyType = {
+  Ephemeral: "ephemeral",
+} as const;
+/**
+ * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+ */
+export type DeploymentInvoke2DeploymentsRequestRequestBodyType = ClosedEnum<
+  typeof DeploymentInvoke2DeploymentsRequestRequestBodyType
+>;
+
+/**
+ * The time-to-live for the cache control breakpoint. This may be one of the following values:
+ *
+ * @remarks
+ *
+ * - `5m`: 5 minutes
+ * - `1h`: 1 hour
+ *
+ * Defaults to `5m`. Only supported by `Anthropic` Claude models.
+ */
+export const TwoTtl = {
+  Fivem: "5m",
+  Oneh: "1h",
+} as const;
+/**
+ * The time-to-live for the cache control breakpoint. This may be one of the following values:
+ *
+ * @remarks
+ *
+ * - `5m`: 5 minutes
+ * - `1h`: 1 hour
+ *
+ * Defaults to `5m`. Only supported by `Anthropic` Claude models.
+ */
+export type TwoTtl = ClosedEnum<typeof TwoTtl>;
+
+export type TwoCacheControl = {
+  /**
+   * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+   */
+  type: DeploymentInvoke2DeploymentsRequestRequestBodyType;
+  /**
+   * The time-to-live for the cache control breakpoint. This may be one of the following values:
+   *
+   * @remarks
+   *
+   * - `5m`: 5 minutes
+   * - `1h`: 1 hour
+   *
+   * Defaults to `5m`. Only supported by `Anthropic` Claude models.
+   */
+  ttl?: TwoTtl | undefined;
+};
+
+export type Two4 = {
+  /**
+   * The type of the content part. Always `file`.
+   */
+  type: "file";
+  cacheControl?: TwoCacheControl | undefined;
+  /**
+   * File data for the content part. Must contain either file_data or uri, but not both.
+   */
+  file: components.FileContentPartSchema;
+};
+
+export type DeploymentInvokeContentDeploymentsRequest2 =
+  | (components.TextContentPartSchema & { type: "text" })
+  | components.ImageContentPartSchema
+  | components.AudioContentPartSchema
+  | Two4;
+
+/**
+ * The contents of the user message.
+ */
+export type DeploymentInvokeMessagesDeploymentsContent =
+  | string
+  | Array<
+    | (components.TextContentPartSchema & { type: "text" })
+    | components.ImageContentPartSchema
+    | components.AudioContentPartSchema
+    | Two4
+  >;
+
+export type MessagesUserMessage = {
+  /**
+   * The role of the messages author, in this case `user`.
+   */
+  role: "user";
+  /**
+   * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
+   */
+  name?: string | undefined;
+  /**
+   * The contents of the user message.
+   */
+  content:
+    | string
+    | Array<
+      | (components.TextContentPartSchema & { type: "text" })
+      | components.ImageContentPartSchema
+      | components.AudioContentPartSchema
+      | Two4
+    >;
+};
+
+/**
+ * The contents of the developer message.
+ */
+export type DeploymentInvokeMessagesContent =
+  | string
+  | Array<components.TextContentPartSchema>;
+
+export type MessagesDeveloperMessage = {
+  /**
+   * The role of the messages author, in this case  `developer`.
+   */
+  role: "developer";
+  /**
+   * The contents of the developer message.
+   */
+  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;
+};
+
+/**
+ * The contents of the system message.
+ */
+export type MessagesContent = string | Array<components.TextContentPartSchema>;
+
+/**
+ * Developer-provided instructions that the model should follow, regardless of messages sent by the user.
+ */
+export type MessagesSystemMessage = {
+  /**
+   * The role of the messages author, in this case `system`.
+   */
+  role: "system";
+  /**
+   * The contents of the system message.
+   */
+  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 DeploymentInvokeMessages =
+  | MessagesSystemMessage
+  | MessagesDeveloperMessage
+  | MessagesUserMessage
+  | MessagesAssistantMessage
+  | MessagesToolMessage;
+
+/**
+ * Metadata about the document
+ */
+export type Metadata = {
+  /**
+   * Name of the file the text is from.
+   */
+  fileName?: string | undefined;
+  /**
+   * Content type of the file the text is from.
+   */
+  fileType?: string | undefined;
+  /**
+   * The page number the text is from.
+   */
+  pageNumber?: number | undefined;
+};
+
+export type Documents = {
+  /**
+   * The text content of the document
+   */
+  text: string;
+  /**
+   * Metadata about the document
+   */
+  metadata?: Metadata | undefined;
+};
+
+export type InvokeOptions = {
+  /**
+   * Whether to include the retrieved knowledge chunks in the response.
+   */
+  includeRetrievals?: boolean | undefined;
+  /**
+   * Whether to include the usage metrics in the response.
+   */
+  includeUsage?: boolean | undefined;
+  /**
+   * A mock response to use instead of calling the LLM API. This is useful for testing purposes. When provided, the system will return a response object with this content as the completion, without making an actual API call to the LLM provider. This works for both streaming and non-streaming requests. Mock responses will not generate logs, traces or be counted for your plan usage.
+   */
+  mockResponse?: string | undefined;
+};
+
+export type Thread = {
+  /**
+   * Unique thread identifier to group related invocations.
+   */
+  id: string;
+  /**
+   * Optional tags to differentiate or categorize threads
+   */
+  tags?: Array<string> | undefined;
+};
+
+/**
+ * Exists
+ */
+export type OrExists = {
+  exists: boolean;
+};
+
+export type DeploymentInvokeOrNin = string | number | boolean;
+
+/**
+ * Not in
+ */
+export type OrNin = {
+  nin: Array<string | number | boolean>;
+};
+
+export type DeploymentInvokeOrIn = string | number | boolean;
+
+/**
+ * In
+ */
+export type OrIn = {
+  in: Array<string | number | boolean>;
+};
+
+/**
+ * Less than or equal to
+ */
+export type OrLte = {
+  lte: number;
+};
+
+/**
+ * Less than
+ */
+export type OrLt = {
+  lt: number;
+};
+
+/**
+ * Greater than or equal to
+ */
+export type OrGte = {
+  gte: number;
+};
+
+/**
+ * Greater than
+ */
+export type OrGt = {
+  gt: number;
+};
+
+export type DeploymentInvokeOrNe = string | number | boolean;
+
+/**
+ * Not equal to
+ */
+export type OrNe = {
+  ne: string | number | boolean;
+};
+
+export type DeploymentInvokeOrEq = string | number | boolean;
+
+/**
+ * Equal to
+ */
+export type OrEq = {
+  eq: string | number | boolean;
+};
+
+export type KnowledgeFilterOr =
+  | OrEq
+  | OrNe
+  | OrGt
+  | OrGte
+  | OrLt
+  | OrLte
+  | OrIn
+  | OrNin
+  | OrExists;
+
+/**
+ * Or
+ */
+export type Or = {
+  or: Array<
+    {
+      [k: string]:
+        | OrEq
+        | OrNe
+        | OrGt
+        | OrGte
+        | OrLt
+        | OrLte
+        | OrIn
+        | OrNin
+        | OrExists;
+    }
+  >;
+};
+
+/**
+ * Exists
+ */
+export type AndExists = {
+  exists: boolean;
+};
+
+export type DeploymentInvokeAndNin = string | number | boolean;
+
+/**
+ * Not in
+ */
+export type AndNin = {
+  nin: Array<string | number | boolean>;
+};
+
+export type DeploymentInvokeAndIn = string | number | boolean;
+
+/**
+ * In
+ */
+export type AndIn = {
+  in: Array<string | number | boolean>;
+};
+
+/**
+ * Less than or equal to
+ */
+export type AndLte = {
+  lte: number;
+};
+
+/**
+ * Less than
+ */
+export type AndLt = {
+  lt: number;
+};
+
+/**
+ * Greater than or equal to
+ */
+export type AndGte = {
+  gte: number;
+};
+
+/**
+ * Greater than
+ */
+export type AndGt = {
+  gt: number;
+};
+
+export type DeploymentInvokeAndNe = string | number | boolean;
+
+/**
+ * Not equal to
+ */
+export type AndNe = {
+  ne: string | number | boolean;
+};
+
+export type DeploymentInvokeAndEq = string | number | boolean;
+
+/**
+ * Equal to
+ */
+export type AndEq = {
+  eq: string | number | boolean;
+};
+
+export type KnowledgeFilterAnd =
+  | AndEq
+  | AndNe
+  | AndGt
+  | AndGte
+  | AndLt
+  | AndLte
+  | AndIn
+  | AndNin
+  | AndExists;
+
+/**
+ * And
+ */
+export type And = {
+  and: Array<
+    {
+      [k: string]:
+        | AndEq
+        | AndNe
+        | AndGt
+        | AndGte
+        | AndLt
+        | AndLte
+        | AndIn
+        | AndNin
+        | AndExists;
+    }
+  >;
+};
+
+/**
+ * Exists
+ */
+export type Exists = {
+  exists: boolean;
+};
+
+export type OneNin = string | number | boolean;
+
+/**
+ * Not in
+ */
+export type Nin = {
+  nin: Array<string | number | boolean>;
+};
+
+export type OneIn = string | number | boolean;
+
+/**
+ * In
+ */
+export type In = {
+  in: Array<string | number | boolean>;
+};
+
+/**
+ * Less than or equal to
+ */
+export type Lte = {
+  lte: number;
+};
+
+/**
+ * Less than
+ */
+export type Lt = {
+  lt: number;
+};
+
+/**
+ * Greater than or equal to
+ */
+export type Gte = {
+  gte: number;
+};
+
+/**
+ * Greater than
+ */
+export type Gt = {
+  gt: number;
+};
+
+export type OneNe = string | number | boolean;
+
+/**
+ * Not equal to
+ */
+export type Ne = {
+  ne: string | number | boolean;
+};
+
+export type OneEq = string | number | boolean;
+
+/**
+ * Equal to
+ */
+export type Eq = {
+  eq: string | number | boolean;
+};
+
+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 = And | Or | {
+  [k: string]: Eq | Ne | Gt | Gte | Lt | Lte | In | Nin | Exists;
+};
+
+export type DeploymentInvokeRequestBody = {
+  /**
+   * The deployment key to invoke
+   */
+  key: string;
+  /**
+   * If set, partial message content will be sent. Tokens will be sent as data-only `server-sent events` as they become available, with the stream terminated by a `data: [DONE]` message.
+   */
+  stream?: boolean | undefined;
+  /**
+   * Key-value pairs variables to replace in your prompts. If a variable is not provided that is defined in the prompt, the default variables are used.
+   */
+  inputs?: { [k: string]: any } | undefined;
+  /**
+   * Key-value pairs that match your data model and fields declared in your deployment routing configuration
+   */
+  context?: { [k: string]: any } | undefined;
+  /**
+   * A list of messages to include after the `System` message, but before the  `User` and `Assistant` pairs configured in your deployment.
+   */
+  prefixMessages?:
+    | Array<
+      | SystemMessage
+      | DeveloperMessage
+      | UserMessage
+      | AssistantMessage
+      | ToolMessage
+    >
+    | undefined;
+  /**
+   * A list of messages to send to the deployment.
+   */
+  messages?:
+    | Array<
+      | MessagesSystemMessage
+      | MessagesDeveloperMessage
+      | MessagesUserMessage
+      | MessagesAssistantMessage
+      | MessagesToolMessage
+    >
+    | undefined;
+  /**
+   * Information about the identity making the request. If the identity does not exist, it will be created automatically.
+   */
+  identity?: components.PublicIdentity | undefined;
+  /**
+   * A list of file IDs that are associated with the deployment request.
+   */
+  fileIds?: Array<string> | undefined;
+  /**
+   * Key-value pairs that you want to attach to the log generated by this request.
+   */
+  metadata?: { [k: string]: any } | undefined;
+  /**
+   * Utilized for passing additional parameters to the model provider. Exercise caution when using this feature, as the included parameters will overwrite any parameters specified in the deployment prompt configuration.
+   */
+  extraParams?: { [k: string]: any } | undefined;
+  /**
+   * A list of documents from your external knowledge base (e.g., chunks retrieved from your own vector database or RAG pipeline) that provide context for the model response. These documents can be used by evaluators and guardrails to assess the relevance and accuracy of the model output against the provided context.
+   */
+  documents?: Array<Documents> | undefined;
+  invokeOptions?: InvokeOptions | undefined;
+  thread?: Thread | undefined;
+  /**
+   * A filter to apply to the knowledge base chunk metadata when using  knowledge bases in the deployment.
+   */
+  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 DeploymentInvokeContentDeployments2$Outbound =
+  components.TextContentPartSchema$Outbound;
+
+/** @internal */
+export const DeploymentInvokeContentDeployments2$outboundSchema: z.ZodType<
+  DeploymentInvokeContentDeployments2$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeContentDeployments2
+> = components.TextContentPartSchema$outboundSchema;
+
+export function deploymentInvokeContentDeployments2ToJSON(
+  deploymentInvokeContentDeployments2: DeploymentInvokeContentDeployments2,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeContentDeployments2$outboundSchema.parse(
+      deploymentInvokeContentDeployments2,
+    ),
+  );
+}
+
+/** @internal */
+export type DeploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent$Outbound =
+  | string
+  | Array<components.TextContentPartSchema$Outbound>;
+
+/** @internal */
+export const DeploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent$outboundSchema:
+  z.ZodType<
+    DeploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent$Outbound,
+    z.ZodTypeDef,
+    DeploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent
+  > = z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]);
+
+export function deploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContentToJSON(
+  deploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent:
+    DeploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent,
+): string {
+  return JSON.stringify(
+    DeploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent$outboundSchema
+      .parse(
+        deploymentInvokePrefixMessagesDeploymentsRequestRequestBodyContent,
+      ),
+  );
+}
+
+/** @internal */
+export const DeploymentInvokePrefixMessagesType$outboundSchema: z.ZodNativeEnum<
+  typeof DeploymentInvokePrefixMessagesType
+> = z.nativeEnum(DeploymentInvokePrefixMessagesType);
+
+/** @internal */
+export const PrefixMessagesTtl$outboundSchema: z.ZodNativeEnum<
+  typeof PrefixMessagesTtl
+> = z.nativeEnum(PrefixMessagesTtl);
+
+/** @internal */
+export type PrefixMessagesCacheControl$Outbound = {
+  type: string;
+  ttl: string;
+};
+
+/** @internal */
+export const PrefixMessagesCacheControl$outboundSchema: z.ZodType<
+  PrefixMessagesCacheControl$Outbound,
+  z.ZodTypeDef,
+  PrefixMessagesCacheControl
+> = z.object({
+  type: DeploymentInvokePrefixMessagesType$outboundSchema,
+  ttl: PrefixMessagesTtl$outboundSchema.default("5m"),
+});
+
+export function prefixMessagesCacheControlToJSON(
+  prefixMessagesCacheControl: PrefixMessagesCacheControl,
+): string {
+  return JSON.stringify(
+    PrefixMessagesCacheControl$outboundSchema.parse(prefixMessagesCacheControl),
+  );
+}
+
+/** @internal */
+export type ToolMessage$Outbound = {
+  role: "tool";
+  content: string | Array<components.TextContentPartSchema$Outbound>;
+  tool_call_id: string | null;
+  cache_control?: PrefixMessagesCacheControl$Outbound | undefined;
+};
+
+/** @internal */
+export const ToolMessage$outboundSchema: z.ZodType<
+  ToolMessage$Outbound,
+  z.ZodTypeDef,
+  ToolMessage
+> = z.object({
+  role: z.literal("tool"),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]),
+  toolCallId: z.nullable(z.string()),
+  cacheControl: z.lazy(() => PrefixMessagesCacheControl$outboundSchema)
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    toolCallId: "tool_call_id",
+    cacheControl: "cache_control",
+  });
+});
+
+export function toolMessageToJSON(toolMessage: ToolMessage): string {
+  return JSON.stringify(ToolMessage$outboundSchema.parse(toolMessage));
+}
+
+/** @internal */
+export type DeploymentInvokeContent2$Outbound =
+  | (components.TextContentPartSchema$Outbound & { type: "text" })
+  | components.RefusalPartSchema$Outbound
+  | components.ReasoningPartSchema$Outbound
+  | components.RedactedReasoningPartSchema$Outbound;
+
+/** @internal */
+export const DeploymentInvokeContent2$outboundSchema: z.ZodType<
+  DeploymentInvokeContent2$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeContent2
+> = z.union([
+  components.TextContentPartSchema$outboundSchema.and(
+    z.object({ type: z.literal("text") }),
+  ),
+  components.RefusalPartSchema$outboundSchema,
+  components.ReasoningPartSchema$outboundSchema,
+  components.RedactedReasoningPartSchema$outboundSchema,
+]);
+
+export function deploymentInvokeContent2ToJSON(
+  deploymentInvokeContent2: DeploymentInvokeContent2,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeContent2$outboundSchema.parse(deploymentInvokeContent2),
+  );
+}
+
+/** @internal */
+export type DeploymentInvokePrefixMessagesDeploymentsRequestContent$Outbound =
+  | string
+  | Array<
+    | (components.TextContentPartSchema$Outbound & { type: "text" })
+    | components.RefusalPartSchema$Outbound
+    | components.ReasoningPartSchema$Outbound
+    | components.RedactedReasoningPartSchema$Outbound
+  >;
+
+/** @internal */
+export const DeploymentInvokePrefixMessagesDeploymentsRequestContent$outboundSchema:
+  z.ZodType<
+    DeploymentInvokePrefixMessagesDeploymentsRequestContent$Outbound,
+    z.ZodTypeDef,
+    DeploymentInvokePrefixMessagesDeploymentsRequestContent
+  > = 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 deploymentInvokePrefixMessagesDeploymentsRequestContentToJSON(
+  deploymentInvokePrefixMessagesDeploymentsRequestContent:
+    DeploymentInvokePrefixMessagesDeploymentsRequestContent,
+): string {
+  return JSON.stringify(
+    DeploymentInvokePrefixMessagesDeploymentsRequestContent$outboundSchema
+      .parse(deploymentInvokePrefixMessagesDeploymentsRequestContent),
+  );
+}
+
+/** @internal */
+export type Audio$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const Audio$outboundSchema: z.ZodType<
+  Audio$Outbound,
+  z.ZodTypeDef,
+  Audio
+> = z.object({
+  id: z.string(),
+});
+
+export function audioToJSON(audio: Audio): string {
+  return JSON.stringify(Audio$outboundSchema.parse(audio));
+}
+
+/** @internal */
+export const PrefixMessagesType$outboundSchema: z.ZodNativeEnum<
+  typeof PrefixMessagesType
+> = z.nativeEnum(PrefixMessagesType);
+
+/** @internal */
+export type PrefixMessagesFunction$Outbound = {
+  name?: string | undefined;
+  arguments?: string | undefined;
+};
+
+/** @internal */
+export const PrefixMessagesFunction$outboundSchema: z.ZodType<
+  PrefixMessagesFunction$Outbound,
+  z.ZodTypeDef,
+  PrefixMessagesFunction
+> = z.object({
+  name: z.string().optional(),
+  arguments: z.string().optional(),
+});
+
+export function prefixMessagesFunctionToJSON(
+  prefixMessagesFunction: PrefixMessagesFunction,
+): string {
+  return JSON.stringify(
+    PrefixMessagesFunction$outboundSchema.parse(prefixMessagesFunction),
+  );
+}
+
+/** @internal */
+export type PrefixMessagesToolCalls$Outbound = {
+  id: string;
+  type: string;
+  function: PrefixMessagesFunction$Outbound;
+  thought_signature?: string | undefined;
+};
+
+/** @internal */
+export const PrefixMessagesToolCalls$outboundSchema: z.ZodType<
+  PrefixMessagesToolCalls$Outbound,
+  z.ZodTypeDef,
+  PrefixMessagesToolCalls
+> = z.object({
+  id: z.string(),
+  type: PrefixMessagesType$outboundSchema,
+  function: z.lazy(() => PrefixMessagesFunction$outboundSchema),
+  thoughtSignature: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    thoughtSignature: "thought_signature",
+  });
+});
+
+export function prefixMessagesToolCallsToJSON(
+  prefixMessagesToolCalls: PrefixMessagesToolCalls,
+): string {
+  return JSON.stringify(
+    PrefixMessagesToolCalls$outboundSchema.parse(prefixMessagesToolCalls),
+  );
+}
+
+/** @internal */
+export type AssistantMessage$Outbound = {
+  content?:
+    | string
+    | Array<
+      | (components.TextContentPartSchema$Outbound & { type: "text" })
+      | components.RefusalPartSchema$Outbound
+      | components.ReasoningPartSchema$Outbound
+      | components.RedactedReasoningPartSchema$Outbound
+    >
+    | null
+    | undefined;
+  refusal?: string | null | undefined;
+  role: "assistant";
+  name?: string | undefined;
+  audio?: Audio$Outbound | null | undefined;
+  tool_calls?: Array<PrefixMessagesToolCalls$Outbound> | undefined;
+};
+
+/** @internal */
+export const AssistantMessage$outboundSchema: z.ZodType<
+  AssistantMessage$Outbound,
+  z.ZodTypeDef,
+  AssistantMessage
+> = z.object({
+  content: z.nullable(
+    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,
+        ]),
+      ),
+    ]),
+  ).optional(),
+  refusal: z.nullable(z.string()).optional(),
+  role: z.literal("assistant"),
+  name: z.string().optional(),
+  audio: z.nullable(z.lazy(() => Audio$outboundSchema)).optional(),
+  toolCalls: z.array(z.lazy(() => PrefixMessagesToolCalls$outboundSchema))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    toolCalls: "tool_calls",
+  });
+});
+
+export function assistantMessageToJSON(
+  assistantMessage: AssistantMessage,
+): string {
+  return JSON.stringify(
+    AssistantMessage$outboundSchema.parse(assistantMessage),
+  );
+}
+
+/** @internal */
+export const DeploymentInvoke2DeploymentsType$outboundSchema: z.ZodNativeEnum<
+  typeof DeploymentInvoke2DeploymentsType
+> = z.nativeEnum(DeploymentInvoke2DeploymentsType);
+
+/** @internal */
+export const Ttl$outboundSchema: z.ZodNativeEnum<typeof Ttl> = z.nativeEnum(
+  Ttl,
+);
+
+/** @internal */
+export type CacheControl$Outbound = {
+  type: string;
+  ttl: string;
+};
+
+/** @internal */
+export const CacheControl$outboundSchema: z.ZodType<
+  CacheControl$Outbound,
+  z.ZodTypeDef,
+  CacheControl
+> = z.object({
+  type: DeploymentInvoke2DeploymentsType$outboundSchema,
+  ttl: Ttl$outboundSchema.default("5m"),
+});
+
+export function cacheControlToJSON(cacheControl: CacheControl): string {
+  return JSON.stringify(CacheControl$outboundSchema.parse(cacheControl));
+}
+
+/** @internal */
+export type Four$Outbound = {
+  type: "file";
+  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(() => CacheControl$outboundSchema).optional(),
+    file: components.FileContentPartSchema$outboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      cacheControl: "cache_control",
+    });
+  });
+
+export function fourToJSON(four: Four): string {
+  return JSON.stringify(Four$outboundSchema.parse(four));
+}
+
+/** @internal */
+export type Content2$Outbound =
+  | (components.TextContentPartSchema$Outbound & { type: "text" })
+  | components.ImageContentPartSchema$Outbound
+  | components.AudioContentPartSchema$Outbound
+  | Four$Outbound;
+
+/** @internal */
+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 content2ToJSON(content2: Content2): string {
+  return JSON.stringify(Content2$outboundSchema.parse(content2));
+}
+
+/** @internal */
+export type DeploymentInvokePrefixMessagesDeploymentsContent$Outbound =
+  | string
+  | Array<
+    | (components.TextContentPartSchema$Outbound & { type: "text" })
+    | components.ImageContentPartSchema$Outbound
+    | components.AudioContentPartSchema$Outbound
+    | Four$Outbound
+  >;
+
+/** @internal */
+export const DeploymentInvokePrefixMessagesDeploymentsContent$outboundSchema:
+  z.ZodType<
+    DeploymentInvokePrefixMessagesDeploymentsContent$Outbound,
+    z.ZodTypeDef,
+    DeploymentInvokePrefixMessagesDeploymentsContent
+  > = 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(() => Four$outboundSchema),
+      ]),
+    ),
+  ]);
+
+export function deploymentInvokePrefixMessagesDeploymentsContentToJSON(
+  deploymentInvokePrefixMessagesDeploymentsContent:
+    DeploymentInvokePrefixMessagesDeploymentsContent,
+): string {
+  return JSON.stringify(
+    DeploymentInvokePrefixMessagesDeploymentsContent$outboundSchema.parse(
+      deploymentInvokePrefixMessagesDeploymentsContent,
+    ),
+  );
+}
+
+/** @internal */
+export type UserMessage$Outbound = {
+  role: "user";
+  name?: string | undefined;
+  content:
+    | string
+    | Array<
+      | (components.TextContentPartSchema$Outbound & { type: "text" })
+      | components.ImageContentPartSchema$Outbound
+      | components.AudioContentPartSchema$Outbound
+      | Four$Outbound
+    >;
+};
+
+/** @internal */
+export const UserMessage$outboundSchema: z.ZodType<
+  UserMessage$Outbound,
+  z.ZodTypeDef,
+  UserMessage
+> = z.object({
+  role: z.literal("user"),
+  name: z.string().optional(),
+  content: 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(() => Four$outboundSchema),
+      ]),
+    ),
+  ]),
+});
+
+export function userMessageToJSON(userMessage: UserMessage): string {
+  return JSON.stringify(UserMessage$outboundSchema.parse(userMessage));
+}
+
+/** @internal */
+export type DeploymentInvokePrefixMessagesContent$Outbound =
+  | string
+  | Array<components.TextContentPartSchema$Outbound>;
+
+/** @internal */
+export const DeploymentInvokePrefixMessagesContent$outboundSchema: z.ZodType<
+  DeploymentInvokePrefixMessagesContent$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokePrefixMessagesContent
+> = z.union([
+  z.string(),
+  z.array(components.TextContentPartSchema$outboundSchema),
+]);
+
+export function deploymentInvokePrefixMessagesContentToJSON(
+  deploymentInvokePrefixMessagesContent: DeploymentInvokePrefixMessagesContent,
+): string {
+  return JSON.stringify(
+    DeploymentInvokePrefixMessagesContent$outboundSchema.parse(
+      deploymentInvokePrefixMessagesContent,
+    ),
+  );
+}
+
+/** @internal */
+export type DeveloperMessage$Outbound = {
+  role: "developer";
+  content: string | Array<components.TextContentPartSchema$Outbound>;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const DeveloperMessage$outboundSchema: z.ZodType<
+  DeveloperMessage$Outbound,
+  z.ZodTypeDef,
+  DeveloperMessage
+> = z.object({
+  role: z.literal("developer"),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]),
+  name: z.string().optional(),
+});
+
+export function developerMessageToJSON(
+  developerMessage: DeveloperMessage,
+): string {
+  return JSON.stringify(
+    DeveloperMessage$outboundSchema.parse(developerMessage),
+  );
+}
+
+/** @internal */
+export type PrefixMessagesContent$Outbound =
+  | string
+  | Array<components.TextContentPartSchema$Outbound>;
+
+/** @internal */
+export const PrefixMessagesContent$outboundSchema: z.ZodType<
+  PrefixMessagesContent$Outbound,
+  z.ZodTypeDef,
+  PrefixMessagesContent
+> = z.union([
+  z.string(),
+  z.array(components.TextContentPartSchema$outboundSchema),
+]);
+
+export function prefixMessagesContentToJSON(
+  prefixMessagesContent: PrefixMessagesContent,
+): string {
+  return JSON.stringify(
+    PrefixMessagesContent$outboundSchema.parse(prefixMessagesContent),
+  );
+}
+
+/** @internal */
+export type SystemMessage$Outbound = {
+  role: "system";
+  content: string | Array<components.TextContentPartSchema$Outbound>;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const SystemMessage$outboundSchema: z.ZodType<
+  SystemMessage$Outbound,
+  z.ZodTypeDef,
+  SystemMessage
+> = z.object({
+  role: z.literal("system"),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]),
+  name: z.string().optional(),
+});
+
+export function systemMessageToJSON(systemMessage: SystemMessage): string {
+  return JSON.stringify(SystemMessage$outboundSchema.parse(systemMessage));
+}
+
+/** @internal */
+export type PrefixMessages$Outbound =
+  | SystemMessage$Outbound
+  | DeveloperMessage$Outbound
+  | UserMessage$Outbound
+  | AssistantMessage$Outbound
+  | ToolMessage$Outbound;
+
+/** @internal */
+export const PrefixMessages$outboundSchema: z.ZodType<
+  PrefixMessages$Outbound,
+  z.ZodTypeDef,
+  PrefixMessages
+> = z.union([
+  z.lazy(() => SystemMessage$outboundSchema),
+  z.lazy(() => DeveloperMessage$outboundSchema),
+  z.lazy(() => UserMessage$outboundSchema),
+  z.lazy(() => AssistantMessage$outboundSchema),
+  z.lazy(() => ToolMessage$outboundSchema),
+]);
+
+export function prefixMessagesToJSON(prefixMessages: PrefixMessages): string {
+  return JSON.stringify(PrefixMessages$outboundSchema.parse(prefixMessages));
+}
+
+/** @internal */
+export type DeploymentInvokeContentDeploymentsRequestRequestBodyMessages2$Outbound =
+  components.TextContentPartSchema$Outbound;
+
+/** @internal */
+export const DeploymentInvokeContentDeploymentsRequestRequestBodyMessages2$outboundSchema:
+  z.ZodType<
+    DeploymentInvokeContentDeploymentsRequestRequestBodyMessages2$Outbound,
+    z.ZodTypeDef,
+    DeploymentInvokeContentDeploymentsRequestRequestBodyMessages2
+  > = components.TextContentPartSchema$outboundSchema;
+
+export function deploymentInvokeContentDeploymentsRequestRequestBodyMessages2ToJSON(
+  deploymentInvokeContentDeploymentsRequestRequestBodyMessages2:
+    DeploymentInvokeContentDeploymentsRequestRequestBodyMessages2,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeContentDeploymentsRequestRequestBodyMessages2$outboundSchema
+      .parse(deploymentInvokeContentDeploymentsRequestRequestBodyMessages2),
+  );
+}
+
+/** @internal */
+export type DeploymentInvokeMessagesDeploymentsRequestRequestBodyContent$Outbound =
+  | string
+  | Array<components.TextContentPartSchema$Outbound>;
+
+/** @internal */
+export const DeploymentInvokeMessagesDeploymentsRequestRequestBodyContent$outboundSchema:
+  z.ZodType<
+    DeploymentInvokeMessagesDeploymentsRequestRequestBodyContent$Outbound,
+    z.ZodTypeDef,
+    DeploymentInvokeMessagesDeploymentsRequestRequestBodyContent
+  > = z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]);
+
+export function deploymentInvokeMessagesDeploymentsRequestRequestBodyContentToJSON(
+  deploymentInvokeMessagesDeploymentsRequestRequestBodyContent:
+    DeploymentInvokeMessagesDeploymentsRequestRequestBodyContent,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeMessagesDeploymentsRequestRequestBodyContent$outboundSchema
+      .parse(deploymentInvokeMessagesDeploymentsRequestRequestBodyContent),
+  );
+}
+
+/** @internal */
+export const DeploymentInvokeMessagesType$outboundSchema: z.ZodNativeEnum<
+  typeof DeploymentInvokeMessagesType
+> = z.nativeEnum(DeploymentInvokeMessagesType);
+
+/** @internal */
+export const MessagesTtl$outboundSchema: z.ZodNativeEnum<typeof MessagesTtl> = z
+  .nativeEnum(MessagesTtl);
+
+/** @internal */
+export type MessagesCacheControl$Outbound = {
+  type: string;
+  ttl: string;
+};
+
+/** @internal */
+export const MessagesCacheControl$outboundSchema: z.ZodType<
+  MessagesCacheControl$Outbound,
+  z.ZodTypeDef,
+  MessagesCacheControl
+> = z.object({
+  type: DeploymentInvokeMessagesType$outboundSchema,
+  ttl: MessagesTtl$outboundSchema.default("5m"),
+});
+
+export function messagesCacheControlToJSON(
+  messagesCacheControl: MessagesCacheControl,
+): string {
+  return JSON.stringify(
+    MessagesCacheControl$outboundSchema.parse(messagesCacheControl),
+  );
+}
+
+/** @internal */
+export type MessagesToolMessage$Outbound = {
+  role: "tool";
+  content: string | Array<components.TextContentPartSchema$Outbound>;
+  tool_call_id: string | null;
+  cache_control?: MessagesCacheControl$Outbound | undefined;
+};
+
+/** @internal */
+export const MessagesToolMessage$outboundSchema: z.ZodType<
+  MessagesToolMessage$Outbound,
+  z.ZodTypeDef,
+  MessagesToolMessage
+> = z.object({
+  role: z.literal("tool"),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]),
+  toolCallId: z.nullable(z.string()),
+  cacheControl: z.lazy(() => MessagesCacheControl$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    toolCallId: "tool_call_id",
+    cacheControl: "cache_control",
+  });
+});
+
+export function messagesToolMessageToJSON(
+  messagesToolMessage: MessagesToolMessage,
+): string {
+  return JSON.stringify(
+    MessagesToolMessage$outboundSchema.parse(messagesToolMessage),
+  );
+}
+
+/** @internal */
+export type DeploymentInvokeContentDeploymentsRequestRequestBody2$Outbound =
+  | (components.TextContentPartSchema$Outbound & { type: "text" })
+  | components.RefusalPartSchema$Outbound
+  | components.ReasoningPartSchema$Outbound
+  | components.RedactedReasoningPartSchema$Outbound;
+
+/** @internal */
+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 DeploymentInvokeMessagesDeploymentsRequestContent$Outbound =
+  | string
+  | Array<
+    | (components.TextContentPartSchema$Outbound & { type: "text" })
+    | components.RefusalPartSchema$Outbound
+    | components.ReasoningPartSchema$Outbound
+    | components.RedactedReasoningPartSchema$Outbound
+  >;
+
+/** @internal */
+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 deploymentInvokeMessagesDeploymentsRequestContentToJSON(
+  deploymentInvokeMessagesDeploymentsRequestContent:
+    DeploymentInvokeMessagesDeploymentsRequestContent,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeMessagesDeploymentsRequestContent$outboundSchema.parse(
+      deploymentInvokeMessagesDeploymentsRequestContent,
+    ),
+  );
+}
+
+/** @internal */
+export type MessagesAudio$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const MessagesAudio$outboundSchema: z.ZodType<
+  MessagesAudio$Outbound,
+  z.ZodTypeDef,
+  MessagesAudio
+> = z.object({
+  id: z.string(),
+});
+
+export function messagesAudioToJSON(messagesAudio: MessagesAudio): string {
+  return JSON.stringify(MessagesAudio$outboundSchema.parse(messagesAudio));
+}
+
+/** @internal */
+export const MessagesType$outboundSchema: z.ZodNativeEnum<typeof MessagesType> =
+  z.nativeEnum(MessagesType);
+
+/** @internal */
+export type MessagesFunction$Outbound = {
+  name?: string | undefined;
+  arguments?: string | undefined;
+};
+
+/** @internal */
+export const MessagesFunction$outboundSchema: z.ZodType<
+  MessagesFunction$Outbound,
+  z.ZodTypeDef,
+  MessagesFunction
+> = z.object({
+  name: z.string().optional(),
+  arguments: z.string().optional(),
+});
+
+export function messagesFunctionToJSON(
+  messagesFunction: MessagesFunction,
+): string {
+  return JSON.stringify(
+    MessagesFunction$outboundSchema.parse(messagesFunction),
+  );
+}
+
+/** @internal */
+export type MessagesToolCalls$Outbound = {
+  id: string;
+  type: string;
+  function: MessagesFunction$Outbound;
+  thought_signature?: string | undefined;
+};
+
+/** @internal */
+export const MessagesToolCalls$outboundSchema: z.ZodType<
+  MessagesToolCalls$Outbound,
+  z.ZodTypeDef,
+  MessagesToolCalls
+> = z.object({
+  id: z.string(),
+  type: MessagesType$outboundSchema,
+  function: z.lazy(() => MessagesFunction$outboundSchema),
+  thoughtSignature: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    thoughtSignature: "thought_signature",
+  });
+});
+
+export function messagesToolCallsToJSON(
+  messagesToolCalls: MessagesToolCalls,
+): string {
+  return JSON.stringify(
+    MessagesToolCalls$outboundSchema.parse(messagesToolCalls),
+  );
+}
+
+/** @internal */
+export type MessagesAssistantMessage$Outbound = {
+  content?:
+    | string
+    | Array<
+      | (components.TextContentPartSchema$Outbound & { type: "text" })
+      | components.RefusalPartSchema$Outbound
+      | components.ReasoningPartSchema$Outbound
+      | components.RedactedReasoningPartSchema$Outbound
+    >
+    | null
+    | undefined;
+  refusal?: string | null | undefined;
+  role: "assistant";
+  name?: string | undefined;
+  audio?: MessagesAudio$Outbound | null | undefined;
+  tool_calls?: Array<MessagesToolCalls$Outbound> | undefined;
+};
+
+/** @internal */
+export const MessagesAssistantMessage$outboundSchema: z.ZodType<
+  MessagesAssistantMessage$Outbound,
+  z.ZodTypeDef,
+  MessagesAssistantMessage
+> = z.object({
+  content: z.nullable(
+    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,
+        ]),
+      ),
+    ]),
+  ).optional(),
+  refusal: z.nullable(z.string()).optional(),
+  role: z.literal("assistant"),
+  name: z.string().optional(),
+  audio: z.nullable(z.lazy(() => MessagesAudio$outboundSchema)).optional(),
+  toolCalls: z.array(z.lazy(() => MessagesToolCalls$outboundSchema)).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    toolCalls: "tool_calls",
+  });
+});
+
+export function messagesAssistantMessageToJSON(
+  messagesAssistantMessage: MessagesAssistantMessage,
+): string {
+  return JSON.stringify(
+    MessagesAssistantMessage$outboundSchema.parse(messagesAssistantMessage),
+  );
+}
+
+/** @internal */
+export const DeploymentInvoke2DeploymentsRequestRequestBodyType$outboundSchema:
+  z.ZodNativeEnum<typeof DeploymentInvoke2DeploymentsRequestRequestBodyType> = z
+    .nativeEnum(DeploymentInvoke2DeploymentsRequestRequestBodyType);
+
+/** @internal */
+export const TwoTtl$outboundSchema: z.ZodNativeEnum<typeof TwoTtl> = z
+  .nativeEnum(TwoTtl);
+
+/** @internal */
+export type TwoCacheControl$Outbound = {
+  type: string;
+  ttl: string;
+};
+
+/** @internal */
+export const TwoCacheControl$outboundSchema: z.ZodType<
+  TwoCacheControl$Outbound,
+  z.ZodTypeDef,
+  TwoCacheControl
+> = z.object({
+  type: DeploymentInvoke2DeploymentsRequestRequestBodyType$outboundSchema,
+  ttl: TwoTtl$outboundSchema.default("5m"),
+});
+
+export function twoCacheControlToJSON(
+  twoCacheControl: TwoCacheControl,
+): string {
+  return JSON.stringify(TwoCacheControl$outboundSchema.parse(twoCacheControl));
+}
+
+/** @internal */
+export type Two4$Outbound = {
+  type: "file";
+  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(() => TwoCacheControl$outboundSchema).optional(),
+    file: components.FileContentPartSchema$outboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      cacheControl: "cache_control",
+    });
+  });
+
+export function two4ToJSON(two4: Two4): string {
+  return JSON.stringify(Two4$outboundSchema.parse(two4));
+}
+
+/** @internal */
+export type DeploymentInvokeContentDeploymentsRequest2$Outbound =
+  | (components.TextContentPartSchema$Outbound & { type: "text" })
+  | components.ImageContentPartSchema$Outbound
+  | components.AudioContentPartSchema$Outbound
+  | Two4$Outbound;
+
+/** @internal */
+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 deploymentInvokeContentDeploymentsRequest2ToJSON(
+  deploymentInvokeContentDeploymentsRequest2:
+    DeploymentInvokeContentDeploymentsRequest2,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeContentDeploymentsRequest2$outboundSchema.parse(
+      deploymentInvokeContentDeploymentsRequest2,
+    ),
+  );
+}
+
+/** @internal */
+export type DeploymentInvokeMessagesDeploymentsContent$Outbound =
+  | string
+  | Array<
+    | (components.TextContentPartSchema$Outbound & { type: "text" })
+    | components.ImageContentPartSchema$Outbound
+    | components.AudioContentPartSchema$Outbound
+    | Two4$Outbound
+  >;
+
+/** @internal */
+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 deploymentInvokeMessagesDeploymentsContentToJSON(
+  deploymentInvokeMessagesDeploymentsContent:
+    DeploymentInvokeMessagesDeploymentsContent,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeMessagesDeploymentsContent$outboundSchema.parse(
+      deploymentInvokeMessagesDeploymentsContent,
+    ),
+  );
+}
+
+/** @internal */
+export type MessagesUserMessage$Outbound = {
+  role: "user";
+  name?: string | undefined;
+  content:
+    | string
+    | Array<
+      | (components.TextContentPartSchema$Outbound & { type: "text" })
+      | components.ImageContentPartSchema$Outbound
+      | components.AudioContentPartSchema$Outbound
+      | Two4$Outbound
+    >;
+};
+
+/** @internal */
+export const MessagesUserMessage$outboundSchema: z.ZodType<
+  MessagesUserMessage$Outbound,
+  z.ZodTypeDef,
+  MessagesUserMessage
+> = z.object({
+  role: z.literal("user"),
+  name: z.string().optional(),
+  content: 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 messagesUserMessageToJSON(
+  messagesUserMessage: MessagesUserMessage,
+): string {
+  return JSON.stringify(
+    MessagesUserMessage$outboundSchema.parse(messagesUserMessage),
+  );
+}
+
+/** @internal */
+export type DeploymentInvokeMessagesContent$Outbound =
+  | string
+  | Array<components.TextContentPartSchema$Outbound>;
+
+/** @internal */
+export const DeploymentInvokeMessagesContent$outboundSchema: z.ZodType<
+  DeploymentInvokeMessagesContent$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeMessagesContent
+> = z.union([
+  z.string(),
+  z.array(components.TextContentPartSchema$outboundSchema),
+]);
+
+export function deploymentInvokeMessagesContentToJSON(
+  deploymentInvokeMessagesContent: DeploymentInvokeMessagesContent,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeMessagesContent$outboundSchema.parse(
+      deploymentInvokeMessagesContent,
+    ),
+  );
+}
+
+/** @internal */
+export type MessagesDeveloperMessage$Outbound = {
+  role: "developer";
+  content: string | Array<components.TextContentPartSchema$Outbound>;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const MessagesDeveloperMessage$outboundSchema: z.ZodType<
+  MessagesDeveloperMessage$Outbound,
+  z.ZodTypeDef,
+  MessagesDeveloperMessage
+> = z.object({
+  role: z.literal("developer"),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]),
+  name: z.string().optional(),
+});
+
+export function messagesDeveloperMessageToJSON(
+  messagesDeveloperMessage: MessagesDeveloperMessage,
+): string {
+  return JSON.stringify(
+    MessagesDeveloperMessage$outboundSchema.parse(messagesDeveloperMessage),
+  );
+}
+
+/** @internal */
+export type MessagesContent$Outbound =
+  | string
+  | Array<components.TextContentPartSchema$Outbound>;
+
+/** @internal */
+export const MessagesContent$outboundSchema: z.ZodType<
+  MessagesContent$Outbound,
+  z.ZodTypeDef,
+  MessagesContent
+> = z.union([
+  z.string(),
+  z.array(components.TextContentPartSchema$outboundSchema),
+]);
+
+export function messagesContentToJSON(
+  messagesContent: MessagesContent,
+): string {
+  return JSON.stringify(MessagesContent$outboundSchema.parse(messagesContent));
+}
+
+/** @internal */
+export type MessagesSystemMessage$Outbound = {
+  role: "system";
+  content: string | Array<components.TextContentPartSchema$Outbound>;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const MessagesSystemMessage$outboundSchema: z.ZodType<
+  MessagesSystemMessage$Outbound,
+  z.ZodTypeDef,
+  MessagesSystemMessage
+> = z.object({
+  role: z.literal("system"),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]),
+  name: z.string().optional(),
+});
+
+export function messagesSystemMessageToJSON(
+  messagesSystemMessage: MessagesSystemMessage,
+): string {
+  return JSON.stringify(
+    MessagesSystemMessage$outboundSchema.parse(messagesSystemMessage),
+  );
+}
+
+/** @internal */
+export type DeploymentInvokeMessages$Outbound =
+  | MessagesSystemMessage$Outbound
+  | MessagesDeveloperMessage$Outbound
+  | MessagesUserMessage$Outbound
+  | MessagesAssistantMessage$Outbound
+  | MessagesToolMessage$Outbound;
+
+/** @internal */
+export const DeploymentInvokeMessages$outboundSchema: z.ZodType<
+  DeploymentInvokeMessages$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeMessages
+> = z.union([
+  z.lazy(() => MessagesSystemMessage$outboundSchema),
+  z.lazy(() => MessagesDeveloperMessage$outboundSchema),
+  z.lazy(() => MessagesUserMessage$outboundSchema),
+  z.lazy(() => MessagesAssistantMessage$outboundSchema),
+  z.lazy(() => MessagesToolMessage$outboundSchema),
+]);
+
+export function deploymentInvokeMessagesToJSON(
+  deploymentInvokeMessages: DeploymentInvokeMessages,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeMessages$outboundSchema.parse(deploymentInvokeMessages),
+  );
+}
+
+/** @internal */
+export type Metadata$Outbound = {
+  file_name?: string | undefined;
+  file_type?: string | undefined;
+  page_number?: number | undefined;
+};
+
+/** @internal */
+export const Metadata$outboundSchema: z.ZodType<
+  Metadata$Outbound,
+  z.ZodTypeDef,
+  Metadata
+> = z.object({
+  fileName: z.string().optional(),
+  fileType: z.string().optional(),
+  pageNumber: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    fileName: "file_name",
+    fileType: "file_type",
+    pageNumber: "page_number",
+  });
+});
+
+export function metadataToJSON(metadata: Metadata): string {
+  return JSON.stringify(Metadata$outboundSchema.parse(metadata));
+}
+
+/** @internal */
+export type Documents$Outbound = {
+  text: string;
+  metadata?: Metadata$Outbound | undefined;
+};
+
+/** @internal */
+export const Documents$outboundSchema: z.ZodType<
+  Documents$Outbound,
+  z.ZodTypeDef,
+  Documents
+> = z.object({
+  text: z.string(),
+  metadata: z.lazy(() => Metadata$outboundSchema).optional(),
+});
+
+export function documentsToJSON(documents: Documents): string {
+  return JSON.stringify(Documents$outboundSchema.parse(documents));
+}
+
+/** @internal */
+export type InvokeOptions$Outbound = {
+  include_retrievals: boolean;
+  include_usage: boolean;
+  mock_response?: string | undefined;
+};
+
+/** @internal */
+export const InvokeOptions$outboundSchema: z.ZodType<
+  InvokeOptions$Outbound,
+  z.ZodTypeDef,
+  InvokeOptions
+> = z.object({
+  includeRetrievals: z.boolean().default(false),
+  includeUsage: z.boolean().default(false),
+  mockResponse: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    includeRetrievals: "include_retrievals",
+    includeUsage: "include_usage",
+    mockResponse: "mock_response",
+  });
+});
+
+export function invokeOptionsToJSON(invokeOptions: InvokeOptions): string {
+  return JSON.stringify(InvokeOptions$outboundSchema.parse(invokeOptions));
+}
+
+/** @internal */
+export type Thread$Outbound = {
+  id: string;
+  tags?: Array<string> | undefined;
+};
+
+/** @internal */
+export const Thread$outboundSchema: z.ZodType<
+  Thread$Outbound,
+  z.ZodTypeDef,
+  Thread
+> = z.object({
+  id: z.string(),
+  tags: z.array(z.string()).optional(),
+});
+
+export function threadToJSON(thread: Thread): string {
+  return JSON.stringify(Thread$outboundSchema.parse(thread));
+}
+
+/** @internal */
+export type OrExists$Outbound = {
+  exists: boolean;
+};
+
+/** @internal */
+export const OrExists$outboundSchema: z.ZodType<
+  OrExists$Outbound,
+  z.ZodTypeDef,
+  OrExists
+> = z.object({
+  exists: z.boolean(),
+});
+
+export function orExistsToJSON(orExists: OrExists): string {
+  return JSON.stringify(OrExists$outboundSchema.parse(orExists));
+}
+
+/** @internal */
+export type DeploymentInvokeOrNin$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentInvokeOrNin$outboundSchema: z.ZodType<
+  DeploymentInvokeOrNin$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeOrNin
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+export function deploymentInvokeOrNinToJSON(
+  deploymentInvokeOrNin: DeploymentInvokeOrNin,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeOrNin$outboundSchema.parse(deploymentInvokeOrNin),
+  );
+}
+
+/** @internal */
+export type OrNin$Outbound = {
+  nin: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const OrNin$outboundSchema: z.ZodType<
+  OrNin$Outbound,
+  z.ZodTypeDef,
+  OrNin
+> = z.object({
+  nin: z.array(z.union([z.string(), z.number(), z.boolean()])),
+});
+
+export function orNinToJSON(orNin: OrNin): string {
+  return JSON.stringify(OrNin$outboundSchema.parse(orNin));
+}
+
+/** @internal */
+export type DeploymentInvokeOrIn$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentInvokeOrIn$outboundSchema: z.ZodType<
+  DeploymentInvokeOrIn$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeOrIn
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+export function deploymentInvokeOrInToJSON(
+  deploymentInvokeOrIn: DeploymentInvokeOrIn,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeOrIn$outboundSchema.parse(deploymentInvokeOrIn),
+  );
+}
+
+/** @internal */
+export type OrIn$Outbound = {
+  in: Array<string | number | boolean>;
+};
+
+/** @internal */
+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 orInToJSON(orIn: OrIn): string {
+  return JSON.stringify(OrIn$outboundSchema.parse(orIn));
+}
+
+/** @internal */
+export type OrLte$Outbound = {
+  lte: number;
+};
+
+/** @internal */
+export const OrLte$outboundSchema: z.ZodType<
+  OrLte$Outbound,
+  z.ZodTypeDef,
+  OrLte
+> = z.object({
+  lte: z.number(),
+});
+
+export function orLteToJSON(orLte: OrLte): string {
+  return JSON.stringify(OrLte$outboundSchema.parse(orLte));
+}
+
+/** @internal */
+export type OrLt$Outbound = {
+  lt: number;
+};
+
+/** @internal */
+export const OrLt$outboundSchema: z.ZodType<OrLt$Outbound, z.ZodTypeDef, OrLt> =
+  z.object({
+    lt: z.number(),
+  });
+
+export function orLtToJSON(orLt: OrLt): string {
+  return JSON.stringify(OrLt$outboundSchema.parse(orLt));
+}
+
+/** @internal */
+export type OrGte$Outbound = {
+  gte: number;
+};
+
+/** @internal */
+export const OrGte$outboundSchema: z.ZodType<
+  OrGte$Outbound,
+  z.ZodTypeDef,
+  OrGte
+> = z.object({
+  gte: z.number(),
+});
+
+export function orGteToJSON(orGte: OrGte): string {
+  return JSON.stringify(OrGte$outboundSchema.parse(orGte));
+}
+
+/** @internal */
+export type OrGt$Outbound = {
+  gt: number;
+};
+
+/** @internal */
+export const OrGt$outboundSchema: z.ZodType<OrGt$Outbound, z.ZodTypeDef, OrGt> =
+  z.object({
+    gt: z.number(),
+  });
+
+export function orGtToJSON(orGt: OrGt): string {
+  return JSON.stringify(OrGt$outboundSchema.parse(orGt));
+}
+
+/** @internal */
+export type DeploymentInvokeOrNe$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentInvokeOrNe$outboundSchema: z.ZodType<
+  DeploymentInvokeOrNe$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeOrNe
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+export function deploymentInvokeOrNeToJSON(
+  deploymentInvokeOrNe: DeploymentInvokeOrNe,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeOrNe$outboundSchema.parse(deploymentInvokeOrNe),
+  );
+}
+
+/** @internal */
+export type OrNe$Outbound = {
+  ne: string | number | boolean;
+};
+
+/** @internal */
+export const OrNe$outboundSchema: z.ZodType<OrNe$Outbound, z.ZodTypeDef, OrNe> =
+  z.object({
+    ne: z.union([z.string(), z.number(), z.boolean()]),
+  });
+
+export function orNeToJSON(orNe: OrNe): string {
+  return JSON.stringify(OrNe$outboundSchema.parse(orNe));
+}
+
+/** @internal */
+export type DeploymentInvokeOrEq$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentInvokeOrEq$outboundSchema: z.ZodType<
+  DeploymentInvokeOrEq$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeOrEq
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+export function deploymentInvokeOrEqToJSON(
+  deploymentInvokeOrEq: DeploymentInvokeOrEq,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeOrEq$outboundSchema.parse(deploymentInvokeOrEq),
+  );
+}
+
+/** @internal */
+export type OrEq$Outbound = {
+  eq: string | number | boolean;
+};
+
+/** @internal */
+export const OrEq$outboundSchema: z.ZodType<OrEq$Outbound, z.ZodTypeDef, OrEq> =
+  z.object({
+    eq: z.union([z.string(), z.number(), z.boolean()]),
+  });
+
+export function orEqToJSON(orEq: OrEq): string {
+  return JSON.stringify(OrEq$outboundSchema.parse(orEq));
+}
+
+/** @internal */
+export type KnowledgeFilterOr$Outbound =
+  | OrEq$Outbound
+  | OrNe$Outbound
+  | OrGt$Outbound
+  | OrGte$Outbound
+  | OrLt$Outbound
+  | OrLte$Outbound
+  | OrIn$Outbound
+  | OrNin$Outbound
+  | OrExists$Outbound;
+
+/** @internal */
+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 knowledgeFilterOrToJSON(
+  knowledgeFilterOr: KnowledgeFilterOr,
+): string {
+  return JSON.stringify(
+    KnowledgeFilterOr$outboundSchema.parse(knowledgeFilterOr),
+  );
+}
+
+/** @internal */
+export type Or$Outbound = {
+  or: Array<
+    {
+      [k: string]:
+        | OrEq$Outbound
+        | OrNe$Outbound
+        | OrGt$Outbound
+        | OrGte$Outbound
+        | OrLt$Outbound
+        | OrLte$Outbound
+        | OrIn$Outbound
+        | OrNin$Outbound
+        | OrExists$Outbound;
+    }
+  >;
+};
+
+/** @internal */
+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 orToJSON(or: Or): string {
+  return JSON.stringify(Or$outboundSchema.parse(or));
+}
+
+/** @internal */
+export type AndExists$Outbound = {
+  exists: boolean;
+};
+
+/** @internal */
+export const AndExists$outboundSchema: z.ZodType<
+  AndExists$Outbound,
+  z.ZodTypeDef,
+  AndExists
+> = z.object({
+  exists: z.boolean(),
+});
+
+export function andExistsToJSON(andExists: AndExists): string {
+  return JSON.stringify(AndExists$outboundSchema.parse(andExists));
+}
+
+/** @internal */
+export type DeploymentInvokeAndNin$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentInvokeAndNin$outboundSchema: z.ZodType<
+  DeploymentInvokeAndNin$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeAndNin
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+export function deploymentInvokeAndNinToJSON(
+  deploymentInvokeAndNin: DeploymentInvokeAndNin,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeAndNin$outboundSchema.parse(deploymentInvokeAndNin),
+  );
+}
+
+/** @internal */
+export type AndNin$Outbound = {
+  nin: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const AndNin$outboundSchema: z.ZodType<
+  AndNin$Outbound,
+  z.ZodTypeDef,
+  AndNin
+> = z.object({
+  nin: z.array(z.union([z.string(), z.number(), z.boolean()])),
+});
+
+export function andNinToJSON(andNin: AndNin): string {
+  return JSON.stringify(AndNin$outboundSchema.parse(andNin));
+}
+
+/** @internal */
+export type DeploymentInvokeAndIn$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentInvokeAndIn$outboundSchema: z.ZodType<
+  DeploymentInvokeAndIn$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeAndIn
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+export function deploymentInvokeAndInToJSON(
+  deploymentInvokeAndIn: DeploymentInvokeAndIn,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeAndIn$outboundSchema.parse(deploymentInvokeAndIn),
+  );
+}
+
+/** @internal */
+export type AndIn$Outbound = {
+  in: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const AndIn$outboundSchema: z.ZodType<
+  AndIn$Outbound,
+  z.ZodTypeDef,
+  AndIn
+> = z.object({
+  in: z.array(z.union([z.string(), z.number(), z.boolean()])),
+});
+
+export function andInToJSON(andIn: AndIn): string {
+  return JSON.stringify(AndIn$outboundSchema.parse(andIn));
+}
+
+/** @internal */
+export type AndLte$Outbound = {
+  lte: number;
+};
+
+/** @internal */
+export const AndLte$outboundSchema: z.ZodType<
+  AndLte$Outbound,
+  z.ZodTypeDef,
+  AndLte
+> = z.object({
+  lte: z.number(),
+});
+
+export function andLteToJSON(andLte: AndLte): string {
+  return JSON.stringify(AndLte$outboundSchema.parse(andLte));
+}
+
+/** @internal */
+export type AndLt$Outbound = {
+  lt: number;
+};
+
+/** @internal */
+export const AndLt$outboundSchema: z.ZodType<
+  AndLt$Outbound,
+  z.ZodTypeDef,
+  AndLt
+> = z.object({
+  lt: z.number(),
+});
+
+export function andLtToJSON(andLt: AndLt): string {
+  return JSON.stringify(AndLt$outboundSchema.parse(andLt));
+}
+
+/** @internal */
+export type AndGte$Outbound = {
+  gte: number;
+};
+
+/** @internal */
+export const AndGte$outboundSchema: z.ZodType<
+  AndGte$Outbound,
+  z.ZodTypeDef,
+  AndGte
+> = z.object({
+  gte: z.number(),
+});
+
+export function andGteToJSON(andGte: AndGte): string {
+  return JSON.stringify(AndGte$outboundSchema.parse(andGte));
+}
+
+/** @internal */
+export type AndGt$Outbound = {
+  gt: number;
+};
+
+/** @internal */
+export const AndGt$outboundSchema: z.ZodType<
+  AndGt$Outbound,
+  z.ZodTypeDef,
+  AndGt
+> = z.object({
+  gt: z.number(),
+});
+
+export function andGtToJSON(andGt: AndGt): string {
+  return JSON.stringify(AndGt$outboundSchema.parse(andGt));
+}
+
+/** @internal */
+export type DeploymentInvokeAndNe$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentInvokeAndNe$outboundSchema: z.ZodType<
+  DeploymentInvokeAndNe$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeAndNe
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+export function deploymentInvokeAndNeToJSON(
+  deploymentInvokeAndNe: DeploymentInvokeAndNe,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeAndNe$outboundSchema.parse(deploymentInvokeAndNe),
+  );
+}
+
+/** @internal */
+export type AndNe$Outbound = {
+  ne: string | number | boolean;
+};
+
+/** @internal */
+export const AndNe$outboundSchema: z.ZodType<
+  AndNe$Outbound,
+  z.ZodTypeDef,
+  AndNe
+> = z.object({
+  ne: z.union([z.string(), z.number(), z.boolean()]),
+});
+
+export function andNeToJSON(andNe: AndNe): string {
+  return JSON.stringify(AndNe$outboundSchema.parse(andNe));
+}
+
+/** @internal */
+export type DeploymentInvokeAndEq$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentInvokeAndEq$outboundSchema: z.ZodType<
+  DeploymentInvokeAndEq$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeAndEq
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+export function deploymentInvokeAndEqToJSON(
+  deploymentInvokeAndEq: DeploymentInvokeAndEq,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeAndEq$outboundSchema.parse(deploymentInvokeAndEq),
+  );
+}
+
+/** @internal */
+export type AndEq$Outbound = {
+  eq: string | number | boolean;
+};
+
+/** @internal */
+export const AndEq$outboundSchema: z.ZodType<
+  AndEq$Outbound,
+  z.ZodTypeDef,
+  AndEq
+> = z.object({
+  eq: z.union([z.string(), z.number(), z.boolean()]),
+});
+
+export function andEqToJSON(andEq: AndEq): string {
+  return JSON.stringify(AndEq$outboundSchema.parse(andEq));
+}
+
+/** @internal */
+export type KnowledgeFilterAnd$Outbound =
+  | AndEq$Outbound
+  | AndNe$Outbound
+  | AndGt$Outbound
+  | AndGte$Outbound
+  | AndLt$Outbound
+  | AndLte$Outbound
+  | AndIn$Outbound
+  | AndNin$Outbound
+  | AndExists$Outbound;
+
+/** @internal */
+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 knowledgeFilterAndToJSON(
+  knowledgeFilterAnd: KnowledgeFilterAnd,
+): string {
+  return JSON.stringify(
+    KnowledgeFilterAnd$outboundSchema.parse(knowledgeFilterAnd),
+  );
+}
+
+/** @internal */
+export type And$Outbound = {
+  and: Array<
+    {
+      [k: string]:
+        | AndEq$Outbound
+        | AndNe$Outbound
+        | AndGt$Outbound
+        | AndGte$Outbound
+        | AndLt$Outbound
+        | AndLte$Outbound
+        | AndIn$Outbound
+        | AndNin$Outbound
+        | AndExists$Outbound;
+    }
+  >;
+};
+
+/** @internal */
+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 andToJSON(and: And): string {
+  return JSON.stringify(And$outboundSchema.parse(and));
+}
+
+/** @internal */
+export type Exists$Outbound = {
+  exists: boolean;
+};
+
+/** @internal */
+export const Exists$outboundSchema: z.ZodType<
+  Exists$Outbound,
+  z.ZodTypeDef,
+  Exists
+> = z.object({
+  exists: z.boolean(),
+});
+
+export function existsToJSON(exists: Exists): string {
+  return JSON.stringify(Exists$outboundSchema.parse(exists));
+}
+
+/** @internal */
+export type OneNin$Outbound = string | number | boolean;
+
+/** @internal */
+export const OneNin$outboundSchema: z.ZodType<
+  OneNin$Outbound,
+  z.ZodTypeDef,
+  OneNin
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+export function oneNinToJSON(oneNin: OneNin): string {
+  return JSON.stringify(OneNin$outboundSchema.parse(oneNin));
+}
+
+/** @internal */
+export type Nin$Outbound = {
+  nin: Array<string | number | boolean>;
+};
+
+/** @internal */
+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 ninToJSON(nin: Nin): string {
+  return JSON.stringify(Nin$outboundSchema.parse(nin));
+}
+
+/** @internal */
+export type OneIn$Outbound = string | number | boolean;
+
+/** @internal */
+export const OneIn$outboundSchema: z.ZodType<
+  OneIn$Outbound,
+  z.ZodTypeDef,
+  OneIn
+> = 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;
+};
+
+/** @internal */
+export const Lte$outboundSchema: z.ZodType<Lte$Outbound, z.ZodTypeDef, Lte> = z
+  .object({
+    lte: z.number(),
+  });
+
+export function lteToJSON(lte: Lte): string {
+  return JSON.stringify(Lte$outboundSchema.parse(lte));
+}
+
+/** @internal */
+export type Lt$Outbound = {
+  lt: number;
+};
+
+/** @internal */
+export const Lt$outboundSchema: z.ZodType<Lt$Outbound, z.ZodTypeDef, Lt> = z
+  .object({
+    lt: z.number(),
+  });
+
+export function ltToJSON(lt: Lt): string {
+  return JSON.stringify(Lt$outboundSchema.parse(lt));
+}
+
+/** @internal */
+export type Gte$Outbound = {
+  gte: number;
+};
+
+/** @internal */
+export const Gte$outboundSchema: z.ZodType<Gte$Outbound, z.ZodTypeDef, Gte> = z
+  .object({
+    gte: z.number(),
+  });
+
+export function gteToJSON(gte: Gte): string {
+  return JSON.stringify(Gte$outboundSchema.parse(gte));
+}
+
+/** @internal */
+export type Gt$Outbound = {
+  gt: number;
+};
+
+/** @internal */
+export const Gt$outboundSchema: z.ZodType<Gt$Outbound, z.ZodTypeDef, Gt> = z
+  .object({
+    gt: z.number(),
+  });
+
+export function gtToJSON(gt: Gt): string {
+  return JSON.stringify(Gt$outboundSchema.parse(gt));
+}
+
+/** @internal */
+export type OneNe$Outbound = string | number | boolean;
+
+/** @internal */
+export const OneNe$outboundSchema: z.ZodType<
+  OneNe$Outbound,
+  z.ZodTypeDef,
+  OneNe
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+export function oneNeToJSON(oneNe: OneNe): string {
+  return JSON.stringify(OneNe$outboundSchema.parse(oneNe));
+}
 
-export type CompletionTokensDetails = {
-  reasoningTokens?: number | null | undefined;
+/** @internal */
+export type Ne$Outbound = {
+  ne: string | number | boolean;
 };
 
-/**
- * Usage metrics for the response
- */
-export type DeploymentInvokeUsage = {
-  totalTokens?: number | undefined;
-  promptTokens?: number | undefined;
-  completionTokens?: number | undefined;
-  promptTokensDetails?: PromptTokensDetails | undefined;
-  completionTokensDetails?: CompletionTokensDetails | null | undefined;
-};
+/** @internal */
+export const Ne$outboundSchema: z.ZodType<Ne$Outbound, z.ZodTypeDef, Ne> = z
+  .object({
+    ne: z.union([z.string(), z.number(), z.boolean()]),
+  });
 
-/**
- * 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 function neToJSON(ne: Ne): string {
+  return JSON.stringify(Ne$outboundSchema.parse(ne));
+}
 
-export type Message3 = {
-  type: "image";
-  /**
-   * The role of the prompt message
-   */
-  role: DeploymentInvokeMessageDeploymentsRole;
-  url: string;
-};
+/** @internal */
+export type OneEq$Outbound = string | number | boolean;
 
-/**
- * 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
->;
+/** @internal */
+export const OneEq$outboundSchema: z.ZodType<
+  OneEq$Outbound,
+  z.ZodTypeDef,
+  OneEq
+> = z.union([z.string(), z.number(), z.boolean()]);
 
-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;
+export function oneEqToJSON(oneEq: OneEq): string {
+  return JSON.stringify(OneEq$outboundSchema.parse(oneEq));
+}
+
+/** @internal */
+export type Eq$Outbound = {
+  eq: string | number | boolean;
 };
 
-/**
- * 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>;
+/** @internal */
+export const Eq$outboundSchema: z.ZodType<Eq$Outbound, z.ZodTypeDef, Eq> = z
+  .object({
+    eq: z.union([z.string(), z.number(), z.boolean()]),
+  });
 
-export const DeploymentInvokeMessageDeploymentsResponseType = {
-  Function: "function",
-} as const;
-export type DeploymentInvokeMessageDeploymentsResponseType = ClosedEnum<
-  typeof DeploymentInvokeMessageDeploymentsResponseType
->;
+export function eqToJSON(eq: Eq): string {
+  return JSON.stringify(Eq$outboundSchema.parse(eq));
+}
 
-export type MessageFunction = {
-  name: string;
-  /**
-   * JSON string arguments for the functions
-   */
-  arguments: string;
-};
+/** @internal */
+export type KnowledgeFilter1$Outbound =
+  | Eq$Outbound
+  | Ne$Outbound
+  | Gt$Outbound
+  | Gte$Outbound
+  | Lt$Outbound
+  | Lte$Outbound
+  | In$Outbound
+  | Nin$Outbound
+  | Exists$Outbound;
 
-export type MessageToolCalls = {
-  id?: string | undefined;
-  index?: number | undefined;
-  type: DeploymentInvokeMessageDeploymentsResponseType;
-  function: MessageFunction;
-};
+/** @internal */
+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 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 function knowledgeFilter1ToJSON(
+  knowledgeFilter1: KnowledgeFilter1,
+): string {
+  return JSON.stringify(
+    KnowledgeFilter1$outboundSchema.parse(knowledgeFilter1),
+  );
+}
+
+/** @internal */
+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;
 };
 
-export type Message = Message1 | Message2 | Message3;
+/** @internal */
+export const KnowledgeFilter$outboundSchema: z.ZodType<
+  KnowledgeFilter$Outbound,
+  z.ZodTypeDef,
+  KnowledgeFilter
+> = z.union([
+  z.lazy(() => And$outboundSchema),
+  z.lazy(() => Or$outboundSchema),
+  z.record(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 type DeploymentInvokeChoices = {
-  index: number;
-  message: Message1 | Message2 | Message3;
-  finishReason?: string | null | undefined;
-};
+export function knowledgeFilterToJSON(
+  knowledgeFilter: KnowledgeFilter,
+): string {
+  return JSON.stringify(KnowledgeFilter$outboundSchema.parse(knowledgeFilter));
+}
 
-/**
- * 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?: DeploymentInvokeUsage | null | undefined;
-  /**
-   * A list of choices generated by the model
-   */
-  choices: Array<DeploymentInvokeChoices>;
+/** @internal */
+export type DeploymentInvokeRequestBody$Outbound = {
+  key: string;
+  stream: boolean;
+  inputs?: { [k: string]: any } | undefined;
+  context?: { [k: string]: any } | undefined;
+  prefix_messages?:
+    | Array<
+      | SystemMessage$Outbound
+      | DeveloperMessage$Outbound
+      | UserMessage$Outbound
+      | AssistantMessage$Outbound
+      | ToolMessage$Outbound
+    >
+    | undefined;
+  messages?:
+    | Array<
+      | MessagesSystemMessage$Outbound
+      | MessagesDeveloperMessage$Outbound
+      | MessagesUserMessage$Outbound
+      | MessagesAssistantMessage$Outbound
+      | MessagesToolMessage$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?: 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 DeploymentInvokeRequestBody$outboundSchema: z.ZodType<
+  DeploymentInvokeRequestBody$Outbound,
+  z.ZodTypeDef,
+  DeploymentInvokeRequestBody
+> = z.object({
+  key: z.string(),
+  stream: z.boolean().default(false),
+  inputs: z.record(z.any()).optional(),
+  context: z.record(z.any()).optional(),
+  prefixMessages: z.array(
+    z.union([
+      z.lazy(() => SystemMessage$outboundSchema),
+      z.lazy(() => DeveloperMessage$outboundSchema),
+      z.lazy(() => UserMessage$outboundSchema),
+      z.lazy(() => AssistantMessage$outboundSchema),
+      z.lazy(() => ToolMessage$outboundSchema),
+    ]),
+  ).optional(),
+  messages: z.array(
+    z.union([
+      z.lazy(() => MessagesSystemMessage$outboundSchema),
+      z.lazy(() => MessagesDeveloperMessage$outboundSchema),
+      z.lazy(() => MessagesUserMessage$outboundSchema),
+      z.lazy(() => MessagesAssistantMessage$outboundSchema),
+      z.lazy(() => MessagesToolMessage$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(),
+  documents: z.array(z.lazy(() => Documents$outboundSchema)).optional(),
+  invokeOptions: z.lazy(() => InvokeOptions$outboundSchema).optional(),
+  thread: z.lazy(() => Thread$outboundSchema).optional(),
+  knowledgeFilter: z.union([
+    z.lazy(() => And$outboundSchema),
+    z.lazy(() => Or$outboundSchema),
+    z.record(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),
+    ])),
+  ]).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    prefixMessages: "prefix_messages",
+    fileIds: "file_ids",
+    extraParams: "extra_params",
+    invokeOptions: "invoke_options",
+    knowledgeFilter: "knowledge_filter",
+  });
+});
+
+export function deploymentInvokeRequestBodyToJSON(
+  deploymentInvokeRequestBody: DeploymentInvokeRequestBody,
+): string {
+  return JSON.stringify(
+    DeploymentInvokeRequestBody$outboundSchema.parse(
+      deploymentInvokeRequestBody,
+    ),
+  );
+}
+
 /** @internal */
 export const DeploymentInvokeObject$inboundSchema: z.ZodNativeEnum<
   typeof DeploymentInvokeObject
@@ -467,36 +3920,33 @@ export function completionTokensDetailsFromJSON(
 }
 
 /** @internal */
-export const DeploymentInvokeUsage$inboundSchema: z.ZodType<
-  DeploymentInvokeUsage,
-  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 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 deploymentInvokeUsageFromJSON(
+export function usageFromJSON(
   jsonString: string,
-): SafeParseResult<DeploymentInvokeUsage, SDKValidationError> {
+): SafeParseResult<Usage, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => DeploymentInvokeUsage$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'DeploymentInvokeUsage' from JSON`,
+    (x) => Usage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Usage' from JSON`,
   );
 }
 
@@ -662,31 +4112,28 @@ export function messageFromJSON(
 }
 
 /** @internal */
-export const DeploymentInvokeChoices$inboundSchema: z.ZodType<
-  DeploymentInvokeChoices,
-  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 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 deploymentInvokeChoicesFromJSON(
+export function choicesFromJSON(
   jsonString: string,
-): SafeParseResult<DeploymentInvokeChoices, SDKValidationError> {
+): SafeParseResult<Choices, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => DeploymentInvokeChoices$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'DeploymentInvokeChoices' from JSON`,
+    (x) => Choices$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Choices' from JSON`,
   );
 }
 
@@ -709,9 +4156,8 @@ export const DeploymentInvokeResponseBody$inboundSchema: z.ZodType<
   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(() => DeploymentInvokeUsage$inboundSchema))
-    .optional(),
-  choices: z.array(z.lazy(() => DeploymentInvokeChoices$inboundSchema)),
+  usage: z.nullable(z.lazy(() => Usage$inboundSchema)).optional(),
+  choices: z.array(z.lazy(() => Choices$inboundSchema)),
 }).transform((v) => {
   return remap$(v, {
     "is_final": "isFinal",