@orq-ai/node 4.2.0-rc.44 → 4.2.0-rc.45

package/src/models/operations/getpromptversion.ts

@@ -7,6 +7,7 @@ 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 GetPromptVersionRequest = {
@@ -86,36 +87,41 @@ export type GetPromptVersionResponseFormat4 = ClosedEnum<
   typeof GetPromptVersionResponseFormat4
 >;
 
-export const GetPromptVersionResponseFormatPromptsResponseType = {
-  Text: "text",
-} as const;
-export type GetPromptVersionResponseFormatPromptsResponseType = ClosedEnum<
-  typeof GetPromptVersionResponseFormatPromptsResponseType
->;
+export const GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONResponseBodyType =
+  {
+    Text: "text",
+  } as const;
+export type GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONResponseBodyType =
+  ClosedEnum<
+    typeof GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONResponseBodyType
+  >;
 
 export type GetPromptVersionResponseFormat3 = {
-  type: GetPromptVersionResponseFormatPromptsResponseType;
+  type:
+    GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONResponseBodyType;
 };
 
-export const GetPromptVersionResponseFormatPromptsType = {
-  JsonObject: "json_object",
-} as const;
-export type GetPromptVersionResponseFormatPromptsType = ClosedEnum<
-  typeof GetPromptVersionResponseFormatPromptsType
->;
+export const GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONType =
+  {
+    JsonObject: "json_object",
+  } as const;
+export type GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONType =
+  ClosedEnum<
+    typeof GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONType
+  >;
 
 export type GetPromptVersionResponseFormat2 = {
-  type: GetPromptVersionResponseFormatPromptsType;
+  type: GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONType;
 };
 
-export const GetPromptVersionResponseFormatType = {
+export const GetPromptVersionResponseFormatPromptsResponse200Type = {
   JsonSchema: "json_schema",
 } as const;
-export type GetPromptVersionResponseFormatType = ClosedEnum<
-  typeof GetPromptVersionResponseFormatType
+export type GetPromptVersionResponseFormatPromptsResponse200Type = ClosedEnum<
+  typeof GetPromptVersionResponseFormatPromptsResponse200Type
 >;
 
-export type GetPromptVersionResponseFormatJsonSchema = {
+export type GetPromptVersionResponseFormatPromptsResponseJsonSchema = {
   name: string;
   description?: string | undefined;
   strict?: boolean | undefined;
@@ -123,9 +129,9 @@ export type GetPromptVersionResponseFormatJsonSchema = {
 };
 
 export type GetPromptVersionResponseFormat1 = {
-  type: GetPromptVersionResponseFormatType;
+  type: GetPromptVersionResponseFormatPromptsResponse200Type;
   displayName?: string | undefined;
-  jsonSchema: GetPromptVersionResponseFormatJsonSchema;
+  jsonSchema: GetPromptVersionResponseFormatPromptsResponseJsonSchema;
 };
 
 /**
@@ -139,7 +145,7 @@ export type GetPromptVersionResponseFormat1 = {
  *
  * Important: when using JSON mode, you must also instruct the model to produce JSON yourself via a system or user message. Without this, the model may generate an unending stream of whitespace until the generation reaches the token limit, resulting in a long-running and seemingly "stuck" request. Also note that the message content may be partially cut off if finish_reason="length", which indicates the generation exceeded max_tokens or the conversation exceeded the max context length.
  */
-export type GetPromptVersionResponseFormat =
+export type GetPromptVersionPromptsResponseFormat =
   | GetPromptVersionResponseFormat1
   | GetPromptVersionResponseFormat2
   | GetPromptVersionResponseFormat3
@@ -178,7 +184,7 @@ export type GetPromptVersionEncodingFormat = ClosedEnum<
 /**
  * Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
  */
-export const GetPromptVersionReasoningEffort = {
+export const GetPromptVersionPromptsReasoningEffort = {
   None: "none",
   Disable: "disable",
   Minimal: "minimal",
@@ -189,8 +195,8 @@ export const GetPromptVersionReasoningEffort = {
 /**
  * Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
  */
-export type GetPromptVersionReasoningEffort = ClosedEnum<
-  typeof GetPromptVersionReasoningEffort
+export type GetPromptVersionPromptsReasoningEffort = ClosedEnum<
+  typeof GetPromptVersionPromptsReasoningEffort
 >;
 
 /**
@@ -305,7 +311,7 @@ export type GetPromptVersionModelParameters = {
   /**
    * Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
    */
-  reasoningEffort?: GetPromptVersionReasoningEffort | undefined;
+  reasoningEffort?: GetPromptVersionPromptsReasoningEffort | undefined;
   /**
    * Gives the model enhanced reasoning capabilities for complex tasks. A value of 0 disables thinking. The minimum budget tokens for thinking are 1024. The Budget Tokens should never exceed the Max Tokens parameter. Only supported by `Anthropic`
    */
@@ -477,11 +483,13 @@ export type GetPromptVersionMessages = {
 };
 
 /**
- * A list of messages compatible with the openAI schema
+ * [DEPRECATED] Use the `prompt` property instead. A list of messages compatible with the openAI schema.
+ *
+ * @deprecated class: This will be removed in a future release, please migrate away from it as soon as possible.
  */
 export type GetPromptVersionPromptConfig = {
   stream?: boolean | undefined;
-  model?: string | undefined;
+  model?: string | null | undefined;
   /**
    * The id of the resource
    */
@@ -494,7 +502,7 @@ export type GetPromptVersionPromptConfig = {
    * Model Parameters: Not all parameters apply to every model
    */
   modelParameters?: GetPromptVersionModelParameters | undefined;
-  provider?: GetPromptVersionProvider | undefined;
+  provider?: GetPromptVersionProvider | null | undefined;
   /**
    * The ID of the integration to use
    */
@@ -503,1250 +511,3981 @@ export type GetPromptVersionPromptConfig = {
   messages: Array<GetPromptVersionMessages>;
 };
 
-export const GetPromptVersionUseCases = {
-  AgentsSimulations: "Agents simulations",
-  Agents: "Agents",
-  APIInteraction: "API interaction",
-  AutonomousAgents: "Autonomous Agents",
-  Chatbots: "Chatbots",
-  Classification: "Classification",
-  CodeUnderstanding: "Code understanding",
-  CodeWriting: "Code writing",
-  Conversation: "Conversation",
-  DocumentsQA: "Documents QA",
-  Evaluation: "Evaluation",
-  Extraction: "Extraction",
-  MultiModal: "Multi-modal",
-  SelfChecking: "Self-checking",
-  SentimentAnalysis: "Sentiment analysis",
-  Sql: "SQL",
-  Summarization: "Summarization",
-  Tagging: "Tagging",
-  TranslationDocument: "Translation (document)",
-  TranslationSentences: "Translation (sentences)",
+/**
+ * The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer.
+ */
+export const GetPromptVersionVoice = {
+  Alloy: "alloy",
+  Echo: "echo",
+  Fable: "fable",
+  Onyx: "onyx",
+  Nova: "nova",
+  Shimmer: "shimmer",
 } as const;
-export type GetPromptVersionUseCases = ClosedEnum<
-  typeof GetPromptVersionUseCases
->;
+/**
+ * The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer.
+ */
+export type GetPromptVersionVoice = ClosedEnum<typeof GetPromptVersionVoice>;
 
 /**
- * The language that the prompt is written in. Use this field to categorize the prompt for your own purpose
+ * Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16.
  */
-export const GetPromptVersionLanguage = {
-  Chinese: "Chinese",
-  Dutch: "Dutch",
-  English: "English",
-  French: "French",
-  German: "German",
-  Russian: "Russian",
-  Spanish: "Spanish",
+export const GetPromptVersionPromptsFormat = {
+  Wav: "wav",
+  Mp3: "mp3",
+  Flac: "flac",
+  Opus: "opus",
+  Pcm16: "pcm16",
 } as const;
 /**
- * The language that the prompt is written in. Use this field to categorize the prompt for your own purpose
+ * Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16.
  */
-export type GetPromptVersionLanguage = ClosedEnum<
-  typeof GetPromptVersionLanguage
+export type GetPromptVersionPromptsFormat = ClosedEnum<
+  typeof GetPromptVersionPromptsFormat
 >;
 
-export type GetPromptVersionMetadata = {
+/**
+ * Parameters for audio output. Required when audio output is requested with modalities: ["audio"]. Learn more.
+ */
+export type GetPromptVersionAudio = {
   /**
-   * A list of use cases that the prompt is meant to be used for. Use this field to categorize the prompt for your own purpose
+   * The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer.
    */
-  useCases?: Array<GetPromptVersionUseCases> | undefined;
+  voice: GetPromptVersionVoice;
   /**
-   * The language that the prompt is written in. Use this field to categorize the prompt for your own purpose
+   * Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16.
    */
-  language?: GetPromptVersionLanguage | null | undefined;
+  format: GetPromptVersionPromptsFormat;
 };
 
-/**
- * Prompt version retrieved successfully.
- */
-export type GetPromptVersionResponseBody = {
-  id: string;
-  createdById?: string | null | undefined;
-  updatedById?: string | null | undefined;
+export type GetPromptVersionResponseFormatJsonSchema = {
   /**
-   * The prompt’s description, meant to be displayable in the UI. Use this field to optionally store a long form explanation of the prompt for your own purpose
+   * A description of what the response format is for, used by the model to determine how to respond in the format.
    */
-  description?: string | null | undefined;
+  description?: string | undefined;
   /**
-   * A list of messages compatible with the openAI schema
+   * The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.
    */
-  promptConfig: GetPromptVersionPromptConfig;
-  metadata?: GetPromptVersionMetadata | undefined;
-  timestamp: string;
+  name: string;
+  /**
+   * The schema for the response format, described as a JSON Schema object.
+   */
+  schema?: any | undefined;
+  /**
+   * Whether to enable strict schema adherence when generating the output. If set to true, the model will always follow the exact schema defined in the schema field. Only a subset of JSON Schema is supported when strict is true.
+   */
+  strict?: boolean | undefined;
 };
 
-/** @internal */
-export const GetPromptVersionRequest$inboundSchema: z.ZodType<
-  GetPromptVersionRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  prompt_id: z.string(),
-  version_id: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "prompt_id": "promptId",
-    "version_id": "versionId",
-  });
-});
-/** @internal */
-export type GetPromptVersionRequest$Outbound = {
-  prompt_id: string;
-  version_id: string;
+/**
+ * @remarks
+ *
+ * JSON Schema response format. Used to generate structured JSON responses
+ */
+export type GetPromptVersionResponseFormatPromptsJSONSchema = {
+  type: "json_schema";
+  jsonSchema: GetPromptVersionResponseFormatJsonSchema;
 };
 
-/** @internal */
-export const GetPromptVersionRequest$outboundSchema: z.ZodType<
-  GetPromptVersionRequest$Outbound,
-  z.ZodTypeDef,
-  GetPromptVersionRequest
-> = z.object({
-  promptId: z.string(),
-  versionId: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    promptId: "prompt_id",
-    versionId: "version_id",
-  });
-});
+/**
+ * @remarks
+ *
+ * JSON object response format. An older method of generating JSON responses. Using `json_schema` is recommended for models that support it. Note that the model will not generate JSON without a system or user message instructing it to do so.
+ */
+export type GetPromptVersionResponseFormatJSONObject = {
+  type: "json_object";
+};
 
-export function getPromptVersionRequestToJSON(
-  getPromptVersionRequest: GetPromptVersionRequest,
-): string {
-  return JSON.stringify(
-    GetPromptVersionRequest$outboundSchema.parse(getPromptVersionRequest),
-  );
-}
-export function getPromptVersionRequestFromJSON(
-  jsonString: string,
-): SafeParseResult<GetPromptVersionRequest, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => GetPromptVersionRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersionRequest' from JSON`,
-  );
-}
+/**
+ * @remarks
+ *
+ * Default response format. Used to generate text responses
+ */
+export type GetPromptVersionResponseFormatText = {
+  type: "text";
+};
 
-/** @internal */
-export const GetPromptVersionModelType$inboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionModelType
-> = z.nativeEnum(GetPromptVersionModelType);
-/** @internal */
-export const GetPromptVersionModelType$outboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionModelType
-> = GetPromptVersionModelType$inboundSchema;
+/**
+ * An object specifying the format that the model must output
+ */
+export type GetPromptVersionResponseFormat =
+  | GetPromptVersionResponseFormatText
+  | GetPromptVersionResponseFormatJSONObject
+  | GetPromptVersionResponseFormatPromptsJSONSchema;
 
-/** @internal */
-export const GetPromptVersionFormat$inboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionFormat
-> = z.nativeEnum(GetPromptVersionFormat);
-/** @internal */
-export const GetPromptVersionFormat$outboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionFormat
-> = GetPromptVersionFormat$inboundSchema;
+/**
+ * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+ *
+ * @remarks
+ *
+ * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
+ * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
+ * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+ * - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
+ *
+ * Any of "none", "minimal", "low", "medium", "high", "xhigh".
+ */
+export const GetPromptVersionReasoningEffort = {
+  None: "none",
+  Minimal: "minimal",
+  Low: "low",
+  Medium: "medium",
+  High: "high",
+  Xhigh: "xhigh",
+} as const;
+/**
+ * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+ *
+ * @remarks
+ *
+ * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
+ * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
+ * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+ * - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
+ *
+ * Any of "none", "minimal", "low", "medium", "high", "xhigh".
+ */
+export type GetPromptVersionReasoningEffort = ClosedEnum<
+  typeof GetPromptVersionReasoningEffort
+>;
 
-/** @internal */
-export const GetPromptVersionResponseFormat6$inboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionResponseFormat6
-> = z.nativeEnum(GetPromptVersionResponseFormat6);
-/** @internal */
-export const GetPromptVersionResponseFormat6$outboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionResponseFormat6
-> = GetPromptVersionResponseFormat6$inboundSchema;
+/**
+ * Up to 4 sequences where the API will stop generating further tokens.
+ */
+export type GetPromptVersionStop = string | Array<string>;
 
-/** @internal */
-export const GetPromptVersionResponseFormat5$inboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionResponseFormat5
-> = z.nativeEnum(GetPromptVersionResponseFormat5);
-/** @internal */
-export const GetPromptVersionResponseFormat5$outboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionResponseFormat5
-> = GetPromptVersionResponseFormat5$inboundSchema;
+/**
+ * Options for streaming response. Only set this when you set stream: true.
+ */
+export type GetPromptVersionStreamOptions = {
+  /**
+   * If set, an additional chunk will be streamed before the data: [DONE] message. The usage field on this chunk shows the token usage statistics for the entire request, and the choices field will always be an empty array. All other chunks will also include a usage field, but with a null value.
+   */
+  includeUsage?: boolean | undefined;
+};
 
-/** @internal */
-export const GetPromptVersionResponseFormat4$inboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionResponseFormat4
-> = z.nativeEnum(GetPromptVersionResponseFormat4);
-/** @internal */
-export const GetPromptVersionResponseFormat4$outboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionResponseFormat4
-> = GetPromptVersionResponseFormat4$inboundSchema;
+export type GetPromptVersionThinking =
+  | components.ThinkingConfigDisabledSchema
+  | components.ThinkingConfigEnabledSchema;
 
-/** @internal */
-export const GetPromptVersionResponseFormatPromptsResponseType$inboundSchema:
-  z.ZodNativeEnum<typeof GetPromptVersionResponseFormatPromptsResponseType> = z
-    .nativeEnum(GetPromptVersionResponseFormatPromptsResponseType);
-/** @internal */
-export const GetPromptVersionResponseFormatPromptsResponseType$outboundSchema:
-  z.ZodNativeEnum<typeof GetPromptVersionResponseFormatPromptsResponseType> =
-    GetPromptVersionResponseFormatPromptsResponseType$inboundSchema;
+/**
+ * The type of the tool. Currently, only function is supported.
+ */
+export const GetPromptVersionToolChoiceType = {
+  Function: "function",
+} as const;
+/**
+ * The type of the tool. Currently, only function is supported.
+ */
+export type GetPromptVersionToolChoiceType = ClosedEnum<
+  typeof GetPromptVersionToolChoiceType
+>;
 
-/** @internal */
-export const GetPromptVersionResponseFormat3$inboundSchema: z.ZodType<
-  GetPromptVersionResponseFormat3,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  type: GetPromptVersionResponseFormatPromptsResponseType$inboundSchema,
-});
-/** @internal */
-export type GetPromptVersionResponseFormat3$Outbound = {
-  type: string;
+export type GetPromptVersionToolChoiceFunction = {
+  /**
+   * The name of the function to call.
+   */
+  name: string;
 };
 
-/** @internal */
-export const GetPromptVersionResponseFormat3$outboundSchema: z.ZodType<
-  GetPromptVersionResponseFormat3$Outbound,
-  z.ZodTypeDef,
-  GetPromptVersionResponseFormat3
-> = z.object({
-  type: GetPromptVersionResponseFormatPromptsResponseType$outboundSchema,
-});
+export type GetPromptVersionToolChoice2 = {
+  /**
+   * The type of the tool. Currently, only function is supported.
+   */
+  type?: GetPromptVersionToolChoiceType | undefined;
+  function: GetPromptVersionToolChoiceFunction;
+};
 
-export function getPromptVersionResponseFormat3ToJSON(
-  getPromptVersionResponseFormat3: GetPromptVersionResponseFormat3,
+export const GetPromptVersionToolChoice1 = {
+  None: "none",
+  Auto: "auto",
+  Required: "required",
+} as const;
+export type GetPromptVersionToolChoice1 = ClosedEnum<
+  typeof GetPromptVersionToolChoice1
+>;
+
+/**
+ * Controls which (if any) tool is called by the model.
+ */
+export type GetPromptVersionToolChoice =
+  | GetPromptVersionToolChoice2
+  | GetPromptVersionToolChoice1;
+
+export const GetPromptVersionModalities = {
+  Text: "text",
+  Audio: "audio",
+} as const;
+export type GetPromptVersionModalities = ClosedEnum<
+  typeof GetPromptVersionModalities
+>;
+
+/**
+ * The key of the guardrail.
+ */
+export const GetPromptVersionId1 = {
+  OrqPiiDetection: "orq_pii_detection",
+  OrqSexualModeration: "orq_sexual_moderation",
+  OrqHarmfulModeration: "orq_harmful_moderation",
+} as const;
+/**
+ * The key of the guardrail.
+ */
+export type GetPromptVersionId1 = ClosedEnum<typeof GetPromptVersionId1>;
+
+export type GetPromptVersionId = GetPromptVersionId1 | string;
+
+/**
+ * Determines whether the guardrail runs on the input (user message) or output (model response).
+ */
+export const GetPromptVersionExecuteOn = {
+  Input: "input",
+  Output: "output",
+} as const;
+/**
+ * Determines whether the guardrail runs on the input (user message) or output (model response).
+ */
+export type GetPromptVersionExecuteOn = ClosedEnum<
+  typeof GetPromptVersionExecuteOn
+>;
+
+export type GetPromptVersionGuardrails = {
+  id: GetPromptVersionId1 | string;
+  /**
+   * Determines whether the guardrail runs on the input (user message) or output (model response).
+   */
+  executeOn: GetPromptVersionExecuteOn;
+};
+
+export type GetPromptVersionContentPromptsResponse2002 =
+  components.TextContentPartSchema;
+
+/**
+ * The contents of the tool message.
+ */
+export type GetPromptVersionMessagesPromptsResponse200Content =
+  | string
+  | Array<components.TextContentPartSchema>;
+
+/**
+ * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+ */
+export const GetPromptVersionMessagesPromptsType = {
+  Ephemeral: "ephemeral",
+} as const;
+/**
+ * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+ */
+export type GetPromptVersionMessagesPromptsType = ClosedEnum<
+  typeof GetPromptVersionMessagesPromptsType
+>;
+
+/**
+ * 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 GetPromptVersionMessagesTtl = {
+  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 GetPromptVersionMessagesTtl = ClosedEnum<
+  typeof GetPromptVersionMessagesTtl
+>;
+
+export type GetPromptVersionMessagesCacheControl = {
+  /**
+   * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+   */
+  type: GetPromptVersionMessagesPromptsType;
+  /**
+   * 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?: GetPromptVersionMessagesTtl | undefined;
+};
+
+export type GetPromptVersionMessagesToolMessage = {
+  /**
+   * 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?: GetPromptVersionMessagesCacheControl | undefined;
+};
+
+export type GetPromptVersionContentPromptsResponse2 =
+  | (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 GetPromptVersionMessagesPromptsResponseContent =
+  | string
+  | Array<
+    | (components.TextContentPartSchema & { type: "text" })
+    | components.RefusalPartSchema
+    | components.ReasoningPartSchema
+    | components.RedactedReasoningPartSchema
+  >;
+
+/**
+ * Data about a previous audio response from the model.
+ */
+export type GetPromptVersionMessagesAudio = {
+  /**
+   * Unique identifier for a previous audio response from the model.
+   */
+  id: string;
+};
+
+/**
+ * The type of the tool. Currently, only `function` is supported.
+ */
+export const GetPromptVersionMessagesType = {
+  Function: "function",
+} as const;
+/**
+ * The type of the tool. Currently, only `function` is supported.
+ */
+export type GetPromptVersionMessagesType = ClosedEnum<
+  typeof GetPromptVersionMessagesType
+>;
+
+export type GetPromptVersionMessagesFunction = {
+  /**
+   * 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 GetPromptVersionMessagesToolCalls = {
+  /**
+   * The ID of the tool call.
+   */
+  id: string;
+  /**
+   * The type of the tool. Currently, only `function` is supported.
+   */
+  type: GetPromptVersionMessagesType;
+  function: GetPromptVersionMessagesFunction;
+  /**
+   * 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 GetPromptVersionMessagesAssistantMessage = {
+  /**
+   * 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?: GetPromptVersionMessagesAudio | null | undefined;
+  /**
+   * The tool calls generated by the model, such as function calls.
+   */
+  toolCalls?: Array<GetPromptVersionMessagesToolCalls> | undefined;
+};
+
+/**
+ * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+ */
+export const GetPromptVersion2PromptsResponse200ApplicationJSONType = {
+  Ephemeral: "ephemeral",
+} as const;
+/**
+ * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+ */
+export type GetPromptVersion2PromptsResponse200ApplicationJSONType = ClosedEnum<
+  typeof GetPromptVersion2PromptsResponse200ApplicationJSONType
+>;
+
+/**
+ * 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 GetPromptVersion2Ttl = {
+  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 GetPromptVersion2Ttl = ClosedEnum<typeof GetPromptVersion2Ttl>;
+
+export type GetPromptVersion2CacheControl = {
+  /**
+   * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
+   */
+  type: GetPromptVersion2PromptsResponse200ApplicationJSONType;
+  /**
+   * 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?: GetPromptVersion2Ttl | undefined;
+};
+
+export type GetPromptVersion24 = {
+  /**
+   * The type of the content part. Always `file`.
+   */
+  type: "file";
+  cacheControl?: GetPromptVersion2CacheControl | undefined;
+  /**
+   * File data for the content part. Must contain either file_data or uri, but not both.
+   */
+  file: components.FileContentPartSchema;
+};
+
+export type GetPromptVersionContentPrompts2 =
+  | (components.TextContentPartSchema & { type: "text" })
+  | components.ImageContentPartSchema
+  | components.AudioContentPartSchema
+  | GetPromptVersion24;
+
+/**
+ * The contents of the user message.
+ */
+export type GetPromptVersionMessagesPromptsContent =
+  | string
+  | Array<
+    | (components.TextContentPartSchema & { type: "text" })
+    | components.ImageContentPartSchema
+    | components.AudioContentPartSchema
+    | GetPromptVersion24
+  >;
+
+export type GetPromptVersionMessagesUserMessage = {
+  /**
+   * 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
+      | GetPromptVersion24
+    >;
+};
+
+/**
+ * The contents of the system message.
+ */
+export type GetPromptVersionMessagesContent =
+  | string
+  | Array<components.TextContentPartSchema>;
+
+/**
+ * Developer-provided instructions that the model should follow, regardless of messages sent by the user.
+ */
+export type GetPromptVersionMessagesSystemMessage = {
+  /**
+   * 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 GetPromptVersionPromptsMessages =
+  | GetPromptVersionMessagesSystemMessage
+  | GetPromptVersionMessagesUserMessage
+  | GetPromptVersionMessagesAssistantMessage
+  | GetPromptVersionMessagesToolMessage;
+
+/**
+ * Prompt configuration with model and messages. Use this instead of prompt_config.
+ */
+export type GetPromptVersionPromptField = {
+  /**
+   * Parameters for audio output. Required when audio output is requested with modalities: ["audio"]. Learn more.
+   */
+  audio?: GetPromptVersionAudio | null | undefined;
+  /**
+   * Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.
+   */
+  frequencyPenalty?: number | null | undefined;
+  /**
+   * `[Deprecated]`. The maximum number of tokens that can be generated in the chat completion. This value can be used to control costs for text generated via API.
+   *
+   * @remarks
+   *
+   *  This value is now `deprecated` in favor of `max_completion_tokens`, and is not compatible with o1 series models.
+   */
+  maxTokens?: number | null | undefined;
+  /**
+   * An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and reasoning tokens
+   */
+  maxCompletionTokens?: number | null | undefined;
+  /**
+   * Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned in the content of message.
+   */
+  logprobs?: boolean | null | undefined;
+  /**
+   * An integer between 0 and 20 specifying the number of most likely tokens to return at each token position, each with an associated log probability. logprobs must be set to true if this parameter is used.
+   */
+  topLogprobs?: number | null | undefined;
+  /**
+   * How many chat completion choices to generate for each input message. Note that you will be charged based on the number of generated tokens across all of the choices. Keep n as 1 to minimize costs.
+   */
+  n?: number | null | undefined;
+  /**
+   * Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.
+   */
+  presencePenalty?: number | null | undefined;
+  /**
+   * An object specifying the format that the model must output
+   */
+  responseFormat?:
+    | GetPromptVersionResponseFormatText
+    | GetPromptVersionResponseFormatJSONObject
+    | GetPromptVersionResponseFormatPromptsJSONSchema
+    | undefined;
+  /**
+   * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+   *
+   * @remarks
+   *
+   * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
+   * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
+   * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+   * - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
+   *
+   * Any of "none", "minimal", "low", "medium", "high", "xhigh".
+   */
+  reasoningEffort?: GetPromptVersionReasoningEffort | undefined;
+  /**
+   * Adjusts response verbosity. Lower levels yield shorter answers.
+   */
+  verbosity?: string | undefined;
+  /**
+   * If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same seed and parameters should return the same result.
+   */
+  seed?: number | null | undefined;
+  /**
+   * Up to 4 sequences where the API will stop generating further tokens.
+   */
+  stop?: string | Array<string> | null | undefined;
+  /**
+   * Options for streaming response. Only set this when you set stream: true.
+   */
+  streamOptions?: GetPromptVersionStreamOptions | null | undefined;
+  thinking?:
+    | components.ThinkingConfigDisabledSchema
+    | components.ThinkingConfigEnabledSchema
+    | undefined;
+  /**
+   * What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
+   */
+  temperature?: number | null | undefined;
+  /**
+   * An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass.
+   */
+  topP?: number | null | undefined;
+  /**
+   * Limits the model to consider only the top k most likely tokens at each step.
+   */
+  topK?: number | null | undefined;
+  /**
+   * Controls which (if any) tool is called by the model.
+   */
+  toolChoice?:
+    | GetPromptVersionToolChoice2
+    | GetPromptVersionToolChoice1
+    | undefined;
+  /**
+   * Whether to enable parallel function calling during tool use.
+   */
+  parallelToolCalls?: boolean | undefined;
+  /**
+   * Output types that you would like the model to generate. Most models are capable of generating text, which is the default: ["text"]. The gpt-4o-audio-preview model can also be used to generate audio. To request that this model generate both text and audio responses, you can use: ["text", "audio"].
+   */
+  modalities?: Array<GetPromptVersionModalities> | null | undefined;
+  /**
+   * A list of guardrails to apply to the request.
+   */
+  guardrails?: Array<GetPromptVersionGuardrails> | undefined;
+  /**
+   * Array of messages that make up the conversation. Each message has a role (system, user, assistant, or tool) and content.
+   */
+  messages?:
+    | Array<
+      | GetPromptVersionMessagesSystemMessage
+      | GetPromptVersionMessagesUserMessage
+      | GetPromptVersionMessagesAssistantMessage
+      | GetPromptVersionMessagesToolMessage
+    >
+    | undefined;
+  /**
+   * Model ID used to generate the response, like `openai/gpt-4o` or `anthropic/claude-3-5-sonnet-20241022`. For private models, use format: `{workspaceKey}@{provider}/{model}`.
+   */
+  model?: string | null | undefined;
+  version?: string | undefined;
+};
+
+export const GetPromptVersionUseCases = {
+  AgentsSimulations: "Agents simulations",
+  Agents: "Agents",
+  APIInteraction: "API interaction",
+  AutonomousAgents: "Autonomous Agents",
+  Chatbots: "Chatbots",
+  Classification: "Classification",
+  CodeUnderstanding: "Code understanding",
+  CodeWriting: "Code writing",
+  Conversation: "Conversation",
+  DocumentsQA: "Documents QA",
+  Evaluation: "Evaluation",
+  Extraction: "Extraction",
+  MultiModal: "Multi-modal",
+  SelfChecking: "Self-checking",
+  SentimentAnalysis: "Sentiment analysis",
+  Sql: "SQL",
+  Summarization: "Summarization",
+  Tagging: "Tagging",
+  TranslationDocument: "Translation (document)",
+  TranslationSentences: "Translation (sentences)",
+} as const;
+export type GetPromptVersionUseCases = ClosedEnum<
+  typeof GetPromptVersionUseCases
+>;
+
+/**
+ * The language that the prompt is written in. Use this field to categorize the prompt for your own purpose
+ */
+export const GetPromptVersionLanguage = {
+  Chinese: "Chinese",
+  Dutch: "Dutch",
+  English: "English",
+  French: "French",
+  German: "German",
+  Russian: "Russian",
+  Spanish: "Spanish",
+} as const;
+/**
+ * The language that the prompt is written in. Use this field to categorize the prompt for your own purpose
+ */
+export type GetPromptVersionLanguage = ClosedEnum<
+  typeof GetPromptVersionLanguage
+>;
+
+export type GetPromptVersionMetadata = {
+  /**
+   * A list of use cases that the prompt is meant to be used for. Use this field to categorize the prompt for your own purpose
+   */
+  useCases?: Array<GetPromptVersionUseCases> | undefined;
+  /**
+   * The language that the prompt is written in. Use this field to categorize the prompt for your own purpose
+   */
+  language?: GetPromptVersionLanguage | null | undefined;
+};
+
+/**
+ * Prompt version retrieved successfully.
+ */
+export type GetPromptVersionResponseBody = {
+  id: string;
+  createdById?: string | null | undefined;
+  updatedById?: string | null | undefined;
+  /**
+   * The prompt’s description, meant to be displayable in the UI. Use this field to optionally store a long form explanation of the prompt for your own purpose
+   */
+  description?: string | null | undefined;
+  /**
+   * [DEPRECATED] Use the `prompt` property instead. A list of messages compatible with the openAI schema.
+   *
+   * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
+   */
+  promptConfig?: GetPromptVersionPromptConfig | undefined;
+  /**
+   * Prompt configuration with model and messages. Use this instead of prompt_config.
+   */
+  prompt: GetPromptVersionPromptField;
+  metadata?: GetPromptVersionMetadata | undefined;
+  timestamp: string;
+};
+
+/** @internal */
+export const GetPromptVersionRequest$inboundSchema: z.ZodType<
+  GetPromptVersionRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  prompt_id: z.string(),
+  version_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "prompt_id": "promptId",
+    "version_id": "versionId",
+  });
+});
+/** @internal */
+export type GetPromptVersionRequest$Outbound = {
+  prompt_id: string;
+  version_id: string;
+};
+
+/** @internal */
+export const GetPromptVersionRequest$outboundSchema: z.ZodType<
+  GetPromptVersionRequest$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionRequest
+> = z.object({
+  promptId: z.string(),
+  versionId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    promptId: "prompt_id",
+    versionId: "version_id",
+  });
+});
+
+export function getPromptVersionRequestToJSON(
+  getPromptVersionRequest: GetPromptVersionRequest,
+): string {
+  return JSON.stringify(
+    GetPromptVersionRequest$outboundSchema.parse(getPromptVersionRequest),
+  );
+}
+export function getPromptVersionRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionModelType$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionModelType
+> = z.nativeEnum(GetPromptVersionModelType);
+/** @internal */
+export const GetPromptVersionModelType$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionModelType
+> = GetPromptVersionModelType$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionFormat$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionFormat
+> = z.nativeEnum(GetPromptVersionFormat);
+/** @internal */
+export const GetPromptVersionFormat$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionFormat
+> = GetPromptVersionFormat$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionResponseFormat6$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionResponseFormat6
+> = z.nativeEnum(GetPromptVersionResponseFormat6);
+/** @internal */
+export const GetPromptVersionResponseFormat6$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionResponseFormat6
+> = GetPromptVersionResponseFormat6$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionResponseFormat5$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionResponseFormat5
+> = z.nativeEnum(GetPromptVersionResponseFormat5);
+/** @internal */
+export const GetPromptVersionResponseFormat5$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionResponseFormat5
+> = GetPromptVersionResponseFormat5$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionResponseFormat4$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionResponseFormat4
+> = z.nativeEnum(GetPromptVersionResponseFormat4);
+/** @internal */
+export const GetPromptVersionResponseFormat4$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionResponseFormat4
+> = GetPromptVersionResponseFormat4$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONResponseBodyType$inboundSchema:
+  z.ZodNativeEnum<
+    typeof GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONResponseBodyType
+  > = z.nativeEnum(
+    GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONResponseBodyType,
+  );
+/** @internal */
+export const GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONResponseBodyType$outboundSchema:
+  z.ZodNativeEnum<
+    typeof GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONResponseBodyType
+  > =
+    GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONResponseBodyType$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionResponseFormat3$inboundSchema: z.ZodType<
+  GetPromptVersionResponseFormat3,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type:
+    GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONResponseBodyType$inboundSchema,
+});
+/** @internal */
+export type GetPromptVersionResponseFormat3$Outbound = {
+  type: string;
+};
+
+/** @internal */
+export const GetPromptVersionResponseFormat3$outboundSchema: z.ZodType<
+  GetPromptVersionResponseFormat3$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionResponseFormat3
+> = z.object({
+  type:
+    GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONResponseBodyType$outboundSchema,
+});
+
+export function getPromptVersionResponseFormat3ToJSON(
+  getPromptVersionResponseFormat3: GetPromptVersionResponseFormat3,
+): string {
+  return JSON.stringify(
+    GetPromptVersionResponseFormat3$outboundSchema.parse(
+      getPromptVersionResponseFormat3,
+    ),
+  );
+}
+export function getPromptVersionResponseFormat3FromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionResponseFormat3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionResponseFormat3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionResponseFormat3' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONType$inboundSchema:
+  z.ZodNativeEnum<
+    typeof GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONType
+  > = z.nativeEnum(
+    GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONType,
+  );
+/** @internal */
+export const GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONType$outboundSchema:
+  z.ZodNativeEnum<
+    typeof GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONType
+  > =
+    GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONType$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionResponseFormat2$inboundSchema: z.ZodType<
+  GetPromptVersionResponseFormat2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type:
+    GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONType$inboundSchema,
+});
+/** @internal */
+export type GetPromptVersionResponseFormat2$Outbound = {
+  type: string;
+};
+
+/** @internal */
+export const GetPromptVersionResponseFormat2$outboundSchema: z.ZodType<
+  GetPromptVersionResponseFormat2$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionResponseFormat2
+> = z.object({
+  type:
+    GetPromptVersionResponseFormatPromptsResponse200ApplicationJSONType$outboundSchema,
+});
+
+export function getPromptVersionResponseFormat2ToJSON(
+  getPromptVersionResponseFormat2: GetPromptVersionResponseFormat2,
+): string {
+  return JSON.stringify(
+    GetPromptVersionResponseFormat2$outboundSchema.parse(
+      getPromptVersionResponseFormat2,
+    ),
+  );
+}
+export function getPromptVersionResponseFormat2FromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionResponseFormat2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionResponseFormat2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionResponseFormat2' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionResponseFormatPromptsResponse200Type$inboundSchema:
+  z.ZodNativeEnum<typeof GetPromptVersionResponseFormatPromptsResponse200Type> =
+    z.nativeEnum(GetPromptVersionResponseFormatPromptsResponse200Type);
+/** @internal */
+export const GetPromptVersionResponseFormatPromptsResponse200Type$outboundSchema:
+  z.ZodNativeEnum<typeof GetPromptVersionResponseFormatPromptsResponse200Type> =
+    GetPromptVersionResponseFormatPromptsResponse200Type$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionResponseFormatPromptsResponseJsonSchema$inboundSchema:
+  z.ZodType<
+    GetPromptVersionResponseFormatPromptsResponseJsonSchema,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    strict: z.boolean().optional(),
+    schema: z.record(z.any()),
+  });
+/** @internal */
+export type GetPromptVersionResponseFormatPromptsResponseJsonSchema$Outbound = {
+  name: string;
+  description?: string | undefined;
+  strict?: boolean | undefined;
+  schema: { [k: string]: any };
+};
+
+/** @internal */
+export const GetPromptVersionResponseFormatPromptsResponseJsonSchema$outboundSchema:
+  z.ZodType<
+    GetPromptVersionResponseFormatPromptsResponseJsonSchema$Outbound,
+    z.ZodTypeDef,
+    GetPromptVersionResponseFormatPromptsResponseJsonSchema
+  > = z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    strict: z.boolean().optional(),
+    schema: z.record(z.any()),
+  });
+
+export function getPromptVersionResponseFormatPromptsResponseJsonSchemaToJSON(
+  getPromptVersionResponseFormatPromptsResponseJsonSchema:
+    GetPromptVersionResponseFormatPromptsResponseJsonSchema,
+): string {
+  return JSON.stringify(
+    GetPromptVersionResponseFormatPromptsResponseJsonSchema$outboundSchema
+      .parse(getPromptVersionResponseFormatPromptsResponseJsonSchema),
+  );
+}
+export function getPromptVersionResponseFormatPromptsResponseJsonSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetPromptVersionResponseFormatPromptsResponseJsonSchema,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetPromptVersionResponseFormatPromptsResponseJsonSchema$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionResponseFormatPromptsResponseJsonSchema' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionResponseFormat1$inboundSchema: z.ZodType<
+  GetPromptVersionResponseFormat1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: GetPromptVersionResponseFormatPromptsResponse200Type$inboundSchema,
+  display_name: z.string().optional(),
+  json_schema: z.lazy(() =>
+    GetPromptVersionResponseFormatPromptsResponseJsonSchema$inboundSchema
+  ),
+}).transform((v) => {
+  return remap$(v, {
+    "display_name": "displayName",
+    "json_schema": "jsonSchema",
+  });
+});
+/** @internal */
+export type GetPromptVersionResponseFormat1$Outbound = {
+  type: string;
+  display_name?: string | undefined;
+  json_schema: GetPromptVersionResponseFormatPromptsResponseJsonSchema$Outbound;
+};
+
+/** @internal */
+export const GetPromptVersionResponseFormat1$outboundSchema: z.ZodType<
+  GetPromptVersionResponseFormat1$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionResponseFormat1
+> = z.object({
+  type: GetPromptVersionResponseFormatPromptsResponse200Type$outboundSchema,
+  displayName: z.string().optional(),
+  jsonSchema: z.lazy(() =>
+    GetPromptVersionResponseFormatPromptsResponseJsonSchema$outboundSchema
+  ),
+}).transform((v) => {
+  return remap$(v, {
+    displayName: "display_name",
+    jsonSchema: "json_schema",
+  });
+});
+
+export function getPromptVersionResponseFormat1ToJSON(
+  getPromptVersionResponseFormat1: GetPromptVersionResponseFormat1,
+): string {
+  return JSON.stringify(
+    GetPromptVersionResponseFormat1$outboundSchema.parse(
+      getPromptVersionResponseFormat1,
+    ),
+  );
+}
+export function getPromptVersionResponseFormat1FromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionResponseFormat1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionResponseFormat1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionResponseFormat1' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionPromptsResponseFormat$inboundSchema: z.ZodType<
+  GetPromptVersionPromptsResponseFormat,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => GetPromptVersionResponseFormat1$inboundSchema),
+  z.lazy(() => GetPromptVersionResponseFormat2$inboundSchema),
+  z.lazy(() => GetPromptVersionResponseFormat3$inboundSchema),
+  GetPromptVersionResponseFormat4$inboundSchema,
+  GetPromptVersionResponseFormat5$inboundSchema,
+  GetPromptVersionResponseFormat6$inboundSchema,
+]);
+/** @internal */
+export type GetPromptVersionPromptsResponseFormat$Outbound =
+  | GetPromptVersionResponseFormat1$Outbound
+  | GetPromptVersionResponseFormat2$Outbound
+  | GetPromptVersionResponseFormat3$Outbound
+  | string
+  | string
+  | string;
+
+/** @internal */
+export const GetPromptVersionPromptsResponseFormat$outboundSchema: z.ZodType<
+  GetPromptVersionPromptsResponseFormat$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionPromptsResponseFormat
+> = z.union([
+  z.lazy(() => GetPromptVersionResponseFormat1$outboundSchema),
+  z.lazy(() => GetPromptVersionResponseFormat2$outboundSchema),
+  z.lazy(() => GetPromptVersionResponseFormat3$outboundSchema),
+  GetPromptVersionResponseFormat4$outboundSchema,
+  GetPromptVersionResponseFormat5$outboundSchema,
+  GetPromptVersionResponseFormat6$outboundSchema,
+]);
+
+export function getPromptVersionPromptsResponseFormatToJSON(
+  getPromptVersionPromptsResponseFormat: GetPromptVersionPromptsResponseFormat,
+): string {
+  return JSON.stringify(
+    GetPromptVersionPromptsResponseFormat$outboundSchema.parse(
+      getPromptVersionPromptsResponseFormat,
+    ),
+  );
+}
+export function getPromptVersionPromptsResponseFormatFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionPromptsResponseFormat, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetPromptVersionPromptsResponseFormat$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionPromptsResponseFormat' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionPhotoRealVersion$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionPhotoRealVersion
+> = z.nativeEnum(GetPromptVersionPhotoRealVersion);
+/** @internal */
+export const GetPromptVersionPhotoRealVersion$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionPhotoRealVersion
+> = GetPromptVersionPhotoRealVersion$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionEncodingFormat$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionEncodingFormat
+> = z.nativeEnum(GetPromptVersionEncodingFormat);
+/** @internal */
+export const GetPromptVersionEncodingFormat$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionEncodingFormat
+> = GetPromptVersionEncodingFormat$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionPromptsReasoningEffort$inboundSchema:
+  z.ZodNativeEnum<typeof GetPromptVersionPromptsReasoningEffort> = z.nativeEnum(
+    GetPromptVersionPromptsReasoningEffort,
+  );
+/** @internal */
+export const GetPromptVersionPromptsReasoningEffort$outboundSchema:
+  z.ZodNativeEnum<typeof GetPromptVersionPromptsReasoningEffort> =
+    GetPromptVersionPromptsReasoningEffort$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionVerbosity$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionVerbosity
+> = z.nativeEnum(GetPromptVersionVerbosity);
+/** @internal */
+export const GetPromptVersionVerbosity$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionVerbosity
+> = GetPromptVersionVerbosity$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionThinkingLevel$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionThinkingLevel
+> = z.nativeEnum(GetPromptVersionThinkingLevel);
+/** @internal */
+export const GetPromptVersionThinkingLevel$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionThinkingLevel
+> = GetPromptVersionThinkingLevel$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionModelParameters$inboundSchema: z.ZodType<
+  GetPromptVersionModelParameters,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  temperature: z.number().optional(),
+  maxTokens: z.number().optional(),
+  topK: z.number().optional(),
+  topP: z.number().optional(),
+  frequencyPenalty: z.number().optional(),
+  presencePenalty: z.number().optional(),
+  numImages: z.number().optional(),
+  seed: z.number().optional(),
+  format: GetPromptVersionFormat$inboundSchema.optional(),
+  dimensions: z.string().optional(),
+  quality: z.string().optional(),
+  style: z.string().optional(),
+  responseFormat: z.nullable(
+    z.union([
+      z.lazy(() => GetPromptVersionResponseFormat1$inboundSchema),
+      z.lazy(() => GetPromptVersionResponseFormat2$inboundSchema),
+      z.lazy(() => GetPromptVersionResponseFormat3$inboundSchema),
+      GetPromptVersionResponseFormat4$inboundSchema,
+      GetPromptVersionResponseFormat5$inboundSchema,
+      GetPromptVersionResponseFormat6$inboundSchema,
+    ]),
+  ).optional(),
+  photoRealVersion: GetPromptVersionPhotoRealVersion$inboundSchema.optional(),
+  encoding_format: GetPromptVersionEncodingFormat$inboundSchema.optional(),
+  reasoningEffort: GetPromptVersionPromptsReasoningEffort$inboundSchema
+    .optional(),
+  budgetTokens: z.number().optional(),
+  verbosity: GetPromptVersionVerbosity$inboundSchema.optional(),
+  thinkingLevel: GetPromptVersionThinkingLevel$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "encoding_format": "encodingFormat",
+  });
+});
+/** @internal */
+export type GetPromptVersionModelParameters$Outbound = {
+  temperature?: number | undefined;
+  maxTokens?: number | undefined;
+  topK?: number | undefined;
+  topP?: number | undefined;
+  frequencyPenalty?: number | undefined;
+  presencePenalty?: number | undefined;
+  numImages?: number | undefined;
+  seed?: number | undefined;
+  format?: string | undefined;
+  dimensions?: string | undefined;
+  quality?: string | undefined;
+  style?: string | undefined;
+  responseFormat?:
+    | GetPromptVersionResponseFormat1$Outbound
+    | GetPromptVersionResponseFormat2$Outbound
+    | GetPromptVersionResponseFormat3$Outbound
+    | string
+    | string
+    | string
+    | null
+    | undefined;
+  photoRealVersion?: string | undefined;
+  encoding_format?: string | undefined;
+  reasoningEffort?: string | undefined;
+  budgetTokens?: number | undefined;
+  verbosity?: string | undefined;
+  thinkingLevel?: string | undefined;
+};
+
+/** @internal */
+export const GetPromptVersionModelParameters$outboundSchema: z.ZodType<
+  GetPromptVersionModelParameters$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionModelParameters
+> = z.object({
+  temperature: z.number().optional(),
+  maxTokens: z.number().optional(),
+  topK: z.number().optional(),
+  topP: z.number().optional(),
+  frequencyPenalty: z.number().optional(),
+  presencePenalty: z.number().optional(),
+  numImages: z.number().optional(),
+  seed: z.number().optional(),
+  format: GetPromptVersionFormat$outboundSchema.optional(),
+  dimensions: z.string().optional(),
+  quality: z.string().optional(),
+  style: z.string().optional(),
+  responseFormat: z.nullable(
+    z.union([
+      z.lazy(() => GetPromptVersionResponseFormat1$outboundSchema),
+      z.lazy(() => GetPromptVersionResponseFormat2$outboundSchema),
+      z.lazy(() => GetPromptVersionResponseFormat3$outboundSchema),
+      GetPromptVersionResponseFormat4$outboundSchema,
+      GetPromptVersionResponseFormat5$outboundSchema,
+      GetPromptVersionResponseFormat6$outboundSchema,
+    ]),
+  ).optional(),
+  photoRealVersion: GetPromptVersionPhotoRealVersion$outboundSchema.optional(),
+  encodingFormat: GetPromptVersionEncodingFormat$outboundSchema.optional(),
+  reasoningEffort: GetPromptVersionPromptsReasoningEffort$outboundSchema
+    .optional(),
+  budgetTokens: z.number().optional(),
+  verbosity: GetPromptVersionVerbosity$outboundSchema.optional(),
+  thinkingLevel: GetPromptVersionThinkingLevel$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    encodingFormat: "encoding_format",
+  });
+});
+
+export function getPromptVersionModelParametersToJSON(
+  getPromptVersionModelParameters: GetPromptVersionModelParameters,
+): string {
+  return JSON.stringify(
+    GetPromptVersionModelParameters$outboundSchema.parse(
+      getPromptVersionModelParameters,
+    ),
+  );
+}
+export function getPromptVersionModelParametersFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionModelParameters, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionModelParameters$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionModelParameters' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionProvider$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionProvider
+> = z.nativeEnum(GetPromptVersionProvider);
+/** @internal */
+export const GetPromptVersionProvider$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionProvider
+> = GetPromptVersionProvider$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionRole$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionRole
+> = z.nativeEnum(GetPromptVersionRole);
+/** @internal */
+export const GetPromptVersionRole$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionRole
+> = GetPromptVersionRole$inboundSchema;
+
+/** @internal */
+export const GetPromptVersion2File$inboundSchema: z.ZodType<
+  GetPromptVersion2File,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  file_data: z.string().optional(),
+  uri: z.string().optional(),
+  mimeType: z.string().optional(),
+  filename: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "file_data": "fileData",
+  });
+});
+/** @internal */
+export type GetPromptVersion2File$Outbound = {
+  file_data?: string | undefined;
+  uri?: string | undefined;
+  mimeType?: string | undefined;
+  filename?: string | undefined;
+};
+
+/** @internal */
+export const GetPromptVersion2File$outboundSchema: z.ZodType<
+  GetPromptVersion2File$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersion2File
+> = z.object({
+  fileData: z.string().optional(),
+  uri: z.string().optional(),
+  mimeType: z.string().optional(),
+  filename: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    fileData: "file_data",
+  });
+});
+
+export function getPromptVersion2FileToJSON(
+  getPromptVersion2File: GetPromptVersion2File,
+): string {
+  return JSON.stringify(
+    GetPromptVersion2File$outboundSchema.parse(getPromptVersion2File),
+  );
+}
+export function getPromptVersion2FileFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersion2File, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersion2File$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersion2File' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersion23$inboundSchema: z.ZodType<
+  GetPromptVersion23,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("file"),
+  file: z.lazy(() => GetPromptVersion2File$inboundSchema),
+});
+/** @internal */
+export type GetPromptVersion23$Outbound = {
+  type: "file";
+  file: GetPromptVersion2File$Outbound;
+};
+
+/** @internal */
+export const GetPromptVersion23$outboundSchema: z.ZodType<
+  GetPromptVersion23$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersion23
+> = z.object({
+  type: z.literal("file"),
+  file: z.lazy(() => GetPromptVersion2File$outboundSchema),
+});
+
+export function getPromptVersion23ToJSON(
+  getPromptVersion23: GetPromptVersion23,
+): string {
+  return JSON.stringify(
+    GetPromptVersion23$outboundSchema.parse(getPromptVersion23),
+  );
+}
+export function getPromptVersion23FromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersion23, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersion23$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersion23' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersion2ImageUrl$inboundSchema: z.ZodType<
+  GetPromptVersion2ImageUrl,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  url: z.string(),
+  detail: z.string().optional(),
+});
+/** @internal */
+export type GetPromptVersion2ImageUrl$Outbound = {
+  id?: string | undefined;
+  url: string;
+  detail?: string | undefined;
+};
+
+/** @internal */
+export const GetPromptVersion2ImageUrl$outboundSchema: z.ZodType<
+  GetPromptVersion2ImageUrl$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersion2ImageUrl
+> = z.object({
+  id: z.string().optional(),
+  url: z.string(),
+  detail: z.string().optional(),
+});
+
+export function getPromptVersion2ImageUrlToJSON(
+  getPromptVersion2ImageUrl: GetPromptVersion2ImageUrl,
+): string {
+  return JSON.stringify(
+    GetPromptVersion2ImageUrl$outboundSchema.parse(getPromptVersion2ImageUrl),
+  );
+}
+export function getPromptVersion2ImageUrlFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersion2ImageUrl, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersion2ImageUrl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersion2ImageUrl' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersion22$inboundSchema: z.ZodType<
+  GetPromptVersion22,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("image_url"),
+  image_url: z.lazy(() => GetPromptVersion2ImageUrl$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "image_url": "imageUrl",
+  });
+});
+/** @internal */
+export type GetPromptVersion22$Outbound = {
+  type: "image_url";
+  image_url: GetPromptVersion2ImageUrl$Outbound;
+};
+
+/** @internal */
+export const GetPromptVersion22$outboundSchema: z.ZodType<
+  GetPromptVersion22$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersion22
+> = z.object({
+  type: z.literal("image_url"),
+  imageUrl: z.lazy(() => GetPromptVersion2ImageUrl$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    imageUrl: "image_url",
+  });
+});
+
+export function getPromptVersion22ToJSON(
+  getPromptVersion22: GetPromptVersion22,
+): string {
+  return JSON.stringify(
+    GetPromptVersion22$outboundSchema.parse(getPromptVersion22),
+  );
+}
+export function getPromptVersion22FromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersion22, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersion22$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersion22' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersion21$inboundSchema: z.ZodType<
+  GetPromptVersion21,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("text"),
+  text: z.string(),
+});
+/** @internal */
+export type GetPromptVersion21$Outbound = {
+  type: "text";
+  text: string;
+};
+
+/** @internal */
+export const GetPromptVersion21$outboundSchema: z.ZodType<
+  GetPromptVersion21$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersion21
+> = z.object({
+  type: z.literal("text"),
+  text: z.string(),
+});
+
+export function getPromptVersion21ToJSON(
+  getPromptVersion21: GetPromptVersion21,
+): string {
+  return JSON.stringify(
+    GetPromptVersion21$outboundSchema.parse(getPromptVersion21),
+  );
+}
+export function getPromptVersion21FromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersion21, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersion21$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersion21' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionContent2$inboundSchema: z.ZodType<
+  GetPromptVersionContent2,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => GetPromptVersion21$inboundSchema),
+  z.lazy(() => GetPromptVersion22$inboundSchema),
+  z.lazy(() => GetPromptVersion23$inboundSchema),
+]);
+/** @internal */
+export type GetPromptVersionContent2$Outbound =
+  | GetPromptVersion21$Outbound
+  | GetPromptVersion22$Outbound
+  | GetPromptVersion23$Outbound;
+
+/** @internal */
+export const GetPromptVersionContent2$outboundSchema: z.ZodType<
+  GetPromptVersionContent2$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionContent2
+> = z.union([
+  z.lazy(() => GetPromptVersion21$outboundSchema),
+  z.lazy(() => GetPromptVersion22$outboundSchema),
+  z.lazy(() => GetPromptVersion23$outboundSchema),
+]);
+
+export function getPromptVersionContent2ToJSON(
+  getPromptVersionContent2: GetPromptVersionContent2,
+): string {
+  return JSON.stringify(
+    GetPromptVersionContent2$outboundSchema.parse(getPromptVersionContent2),
+  );
+}
+export function getPromptVersionContent2FromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionContent2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionContent2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionContent2' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionContent$inboundSchema: z.ZodType<
+  GetPromptVersionContent,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.string(),
+  z.array(z.union([
+    z.lazy(() => GetPromptVersion21$inboundSchema),
+    z.lazy(() => GetPromptVersion22$inboundSchema),
+    z.lazy(() => GetPromptVersion23$inboundSchema),
+  ])),
+]);
+/** @internal */
+export type GetPromptVersionContent$Outbound =
+  | string
+  | Array<
+    | GetPromptVersion21$Outbound
+    | GetPromptVersion22$Outbound
+    | GetPromptVersion23$Outbound
+  >;
+
+/** @internal */
+export const GetPromptVersionContent$outboundSchema: z.ZodType<
+  GetPromptVersionContent$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionContent
+> = z.union([
+  z.string(),
+  z.array(z.union([
+    z.lazy(() => GetPromptVersion21$outboundSchema),
+    z.lazy(() => GetPromptVersion22$outboundSchema),
+    z.lazy(() => GetPromptVersion23$outboundSchema),
+  ])),
+]);
+
+export function getPromptVersionContentToJSON(
+  getPromptVersionContent: GetPromptVersionContent,
+): string {
+  return JSON.stringify(
+    GetPromptVersionContent$outboundSchema.parse(getPromptVersionContent),
+  );
+}
+export function getPromptVersionContentFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionContent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionContent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionContent' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionType$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionType
+> = z.nativeEnum(GetPromptVersionType);
+/** @internal */
+export const GetPromptVersionType$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionType
+> = GetPromptVersionType$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionFunction$inboundSchema: z.ZodType<
+  GetPromptVersionFunction,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string(),
+  arguments: z.string(),
+});
+/** @internal */
+export type GetPromptVersionFunction$Outbound = {
+  name: string;
+  arguments: string;
+};
+
+/** @internal */
+export const GetPromptVersionFunction$outboundSchema: z.ZodType<
+  GetPromptVersionFunction$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionFunction
+> = z.object({
+  name: z.string(),
+  arguments: z.string(),
+});
+
+export function getPromptVersionFunctionToJSON(
+  getPromptVersionFunction: GetPromptVersionFunction,
+): string {
+  return JSON.stringify(
+    GetPromptVersionFunction$outboundSchema.parse(getPromptVersionFunction),
+  );
+}
+export function getPromptVersionFunctionFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionFunction, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionFunction$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionFunction' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionToolCalls$inboundSchema: z.ZodType<
+  GetPromptVersionToolCalls,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  index: z.number().optional(),
+  type: GetPromptVersionType$inboundSchema,
+  function: z.lazy(() => GetPromptVersionFunction$inboundSchema),
+});
+/** @internal */
+export type GetPromptVersionToolCalls$Outbound = {
+  id?: string | undefined;
+  index?: number | undefined;
+  type: string;
+  function: GetPromptVersionFunction$Outbound;
+};
+
+/** @internal */
+export const GetPromptVersionToolCalls$outboundSchema: z.ZodType<
+  GetPromptVersionToolCalls$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionToolCalls
+> = z.object({
+  id: z.string().optional(),
+  index: z.number().optional(),
+  type: GetPromptVersionType$outboundSchema,
+  function: z.lazy(() => GetPromptVersionFunction$outboundSchema),
+});
+
+export function getPromptVersionToolCallsToJSON(
+  getPromptVersionToolCalls: GetPromptVersionToolCalls,
+): string {
+  return JSON.stringify(
+    GetPromptVersionToolCalls$outboundSchema.parse(getPromptVersionToolCalls),
+  );
+}
+export function getPromptVersionToolCallsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionToolCalls, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionToolCalls$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionToolCalls' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionMessages$inboundSchema: z.ZodType<
+  GetPromptVersionMessages,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  role: GetPromptVersionRole$inboundSchema,
+  content: z.nullable(
+    z.union([
+      z.string(),
+      z.array(
+        z.union([
+          z.lazy(() => GetPromptVersion21$inboundSchema),
+          z.lazy(() => GetPromptVersion22$inboundSchema),
+          z.lazy(() => GetPromptVersion23$inboundSchema),
+        ]),
+      ),
+    ]),
+  ),
+  tool_calls: z.array(z.lazy(() => GetPromptVersionToolCalls$inboundSchema))
+    .optional(),
+  tool_call_id: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "tool_calls": "toolCalls",
+    "tool_call_id": "toolCallId",
+  });
+});
+/** @internal */
+export type GetPromptVersionMessages$Outbound = {
+  role: string;
+  content:
+    | string
+    | Array<
+      | GetPromptVersion21$Outbound
+      | GetPromptVersion22$Outbound
+      | GetPromptVersion23$Outbound
+    >
+    | null;
+  tool_calls?: Array<GetPromptVersionToolCalls$Outbound> | undefined;
+  tool_call_id?: string | null | undefined;
+};
+
+/** @internal */
+export const GetPromptVersionMessages$outboundSchema: z.ZodType<
+  GetPromptVersionMessages$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionMessages
+> = z.object({
+  role: GetPromptVersionRole$outboundSchema,
+  content: z.nullable(
+    z.union([
+      z.string(),
+      z.array(
+        z.union([
+          z.lazy(() => GetPromptVersion21$outboundSchema),
+          z.lazy(() => GetPromptVersion22$outboundSchema),
+          z.lazy(() => GetPromptVersion23$outboundSchema),
+        ]),
+      ),
+    ]),
+  ),
+  toolCalls: z.array(z.lazy(() => GetPromptVersionToolCalls$outboundSchema))
+    .optional(),
+  toolCallId: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    toolCalls: "tool_calls",
+    toolCallId: "tool_call_id",
+  });
+});
+
+export function getPromptVersionMessagesToJSON(
+  getPromptVersionMessages: GetPromptVersionMessages,
+): string {
+  return JSON.stringify(
+    GetPromptVersionMessages$outboundSchema.parse(getPromptVersionMessages),
+  );
+}
+export function getPromptVersionMessagesFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionMessages, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionMessages$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionMessages' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionPromptConfig$inboundSchema: z.ZodType<
+  GetPromptVersionPromptConfig,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  stream: z.boolean().optional(),
+  model: z.nullable(z.string()).optional(),
+  model_db_id: z.nullable(z.string()).optional(),
+  model_type: z.nullable(GetPromptVersionModelType$inboundSchema).optional(),
+  model_parameters: z.lazy(() => GetPromptVersionModelParameters$inboundSchema)
+    .optional(),
+  provider: z.nullable(GetPromptVersionProvider$inboundSchema).optional(),
+  integration_id: z.nullable(z.string()).optional(),
+  version: z.string().optional(),
+  messages: z.array(z.lazy(() => GetPromptVersionMessages$inboundSchema)),
+}).transform((v) => {
+  return remap$(v, {
+    "model_db_id": "modelDbId",
+    "model_type": "modelType",
+    "model_parameters": "modelParameters",
+    "integration_id": "integrationId",
+  });
+});
+/** @internal */
+export type GetPromptVersionPromptConfig$Outbound = {
+  stream?: boolean | undefined;
+  model?: string | null | undefined;
+  model_db_id?: string | null | undefined;
+  model_type?: string | null | undefined;
+  model_parameters?: GetPromptVersionModelParameters$Outbound | undefined;
+  provider?: string | null | undefined;
+  integration_id?: string | null | undefined;
+  version?: string | undefined;
+  messages: Array<GetPromptVersionMessages$Outbound>;
+};
+
+/** @internal */
+export const GetPromptVersionPromptConfig$outboundSchema: z.ZodType<
+  GetPromptVersionPromptConfig$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionPromptConfig
+> = z.object({
+  stream: z.boolean().optional(),
+  model: z.nullable(z.string()).optional(),
+  modelDbId: z.nullable(z.string()).optional(),
+  modelType: z.nullable(GetPromptVersionModelType$outboundSchema).optional(),
+  modelParameters: z.lazy(() => GetPromptVersionModelParameters$outboundSchema)
+    .optional(),
+  provider: z.nullable(GetPromptVersionProvider$outboundSchema).optional(),
+  integrationId: z.nullable(z.string()).optional(),
+  version: z.string().optional(),
+  messages: z.array(z.lazy(() => GetPromptVersionMessages$outboundSchema)),
+}).transform((v) => {
+  return remap$(v, {
+    modelDbId: "model_db_id",
+    modelType: "model_type",
+    modelParameters: "model_parameters",
+    integrationId: "integration_id",
+  });
+});
+
+export function getPromptVersionPromptConfigToJSON(
+  getPromptVersionPromptConfig: GetPromptVersionPromptConfig,
+): string {
+  return JSON.stringify(
+    GetPromptVersionPromptConfig$outboundSchema.parse(
+      getPromptVersionPromptConfig,
+    ),
+  );
+}
+export function getPromptVersionPromptConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionPromptConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionPromptConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionPromptConfig' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionVoice$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionVoice
+> = z.nativeEnum(GetPromptVersionVoice);
+/** @internal */
+export const GetPromptVersionVoice$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionVoice
+> = GetPromptVersionVoice$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionPromptsFormat$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionPromptsFormat
+> = z.nativeEnum(GetPromptVersionPromptsFormat);
+/** @internal */
+export const GetPromptVersionPromptsFormat$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionPromptsFormat
+> = GetPromptVersionPromptsFormat$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionAudio$inboundSchema: z.ZodType<
+  GetPromptVersionAudio,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  voice: GetPromptVersionVoice$inboundSchema,
+  format: GetPromptVersionPromptsFormat$inboundSchema,
+});
+/** @internal */
+export type GetPromptVersionAudio$Outbound = {
+  voice: string;
+  format: string;
+};
+
+/** @internal */
+export const GetPromptVersionAudio$outboundSchema: z.ZodType<
+  GetPromptVersionAudio$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionAudio
+> = z.object({
+  voice: GetPromptVersionVoice$outboundSchema,
+  format: GetPromptVersionPromptsFormat$outboundSchema,
+});
+
+export function getPromptVersionAudioToJSON(
+  getPromptVersionAudio: GetPromptVersionAudio,
+): string {
+  return JSON.stringify(
+    GetPromptVersionAudio$outboundSchema.parse(getPromptVersionAudio),
+  );
+}
+export function getPromptVersionAudioFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionAudio, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionAudio$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionAudio' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionResponseFormatJsonSchema$inboundSchema: z.ZodType<
+  GetPromptVersionResponseFormatJsonSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  description: z.string().optional(),
+  name: z.string(),
+  schema: z.any().optional(),
+  strict: z.boolean().default(false),
+});
+/** @internal */
+export type GetPromptVersionResponseFormatJsonSchema$Outbound = {
+  description?: string | undefined;
+  name: string;
+  schema?: any | undefined;
+  strict: boolean;
+};
+
+/** @internal */
+export const GetPromptVersionResponseFormatJsonSchema$outboundSchema: z.ZodType<
+  GetPromptVersionResponseFormatJsonSchema$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionResponseFormatJsonSchema
+> = z.object({
+  description: z.string().optional(),
+  name: z.string(),
+  schema: z.any().optional(),
+  strict: z.boolean().default(false),
+});
+
+export function getPromptVersionResponseFormatJsonSchemaToJSON(
+  getPromptVersionResponseFormatJsonSchema:
+    GetPromptVersionResponseFormatJsonSchema,
+): string {
+  return JSON.stringify(
+    GetPromptVersionResponseFormatJsonSchema$outboundSchema.parse(
+      getPromptVersionResponseFormatJsonSchema,
+    ),
+  );
+}
+export function getPromptVersionResponseFormatJsonSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetPromptVersionResponseFormatJsonSchema,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetPromptVersionResponseFormatJsonSchema$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetPromptVersionResponseFormatJsonSchema' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionResponseFormatPromptsJSONSchema$inboundSchema:
+  z.ZodType<
+    GetPromptVersionResponseFormatPromptsJSONSchema,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    type: z.literal("json_schema"),
+    json_schema: z.lazy(() =>
+      GetPromptVersionResponseFormatJsonSchema$inboundSchema
+    ),
+  }).transform((v) => {
+    return remap$(v, {
+      "json_schema": "jsonSchema",
+    });
+  });
+/** @internal */
+export type GetPromptVersionResponseFormatPromptsJSONSchema$Outbound = {
+  type: "json_schema";
+  json_schema: GetPromptVersionResponseFormatJsonSchema$Outbound;
+};
+
+/** @internal */
+export const GetPromptVersionResponseFormatPromptsJSONSchema$outboundSchema:
+  z.ZodType<
+    GetPromptVersionResponseFormatPromptsJSONSchema$Outbound,
+    z.ZodTypeDef,
+    GetPromptVersionResponseFormatPromptsJSONSchema
+  > = z.object({
+    type: z.literal("json_schema"),
+    jsonSchema: z.lazy(() =>
+      GetPromptVersionResponseFormatJsonSchema$outboundSchema
+    ),
+  }).transform((v) => {
+    return remap$(v, {
+      jsonSchema: "json_schema",
+    });
+  });
+
+export function getPromptVersionResponseFormatPromptsJSONSchemaToJSON(
+  getPromptVersionResponseFormatPromptsJSONSchema:
+    GetPromptVersionResponseFormatPromptsJSONSchema,
+): string {
+  return JSON.stringify(
+    GetPromptVersionResponseFormatPromptsJSONSchema$outboundSchema.parse(
+      getPromptVersionResponseFormatPromptsJSONSchema,
+    ),
+  );
+}
+export function getPromptVersionResponseFormatPromptsJSONSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetPromptVersionResponseFormatPromptsJSONSchema,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetPromptVersionResponseFormatPromptsJSONSchema$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetPromptVersionResponseFormatPromptsJSONSchema' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionResponseFormatJSONObject$inboundSchema: z.ZodType<
+  GetPromptVersionResponseFormatJSONObject,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("json_object"),
+});
+/** @internal */
+export type GetPromptVersionResponseFormatJSONObject$Outbound = {
+  type: "json_object";
+};
+
+/** @internal */
+export const GetPromptVersionResponseFormatJSONObject$outboundSchema: z.ZodType<
+  GetPromptVersionResponseFormatJSONObject$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionResponseFormatJSONObject
+> = z.object({
+  type: z.literal("json_object"),
+});
+
+export function getPromptVersionResponseFormatJSONObjectToJSON(
+  getPromptVersionResponseFormatJSONObject:
+    GetPromptVersionResponseFormatJSONObject,
+): string {
+  return JSON.stringify(
+    GetPromptVersionResponseFormatJSONObject$outboundSchema.parse(
+      getPromptVersionResponseFormatJSONObject,
+    ),
+  );
+}
+export function getPromptVersionResponseFormatJSONObjectFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetPromptVersionResponseFormatJSONObject,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetPromptVersionResponseFormatJSONObject$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetPromptVersionResponseFormatJSONObject' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionResponseFormatText$inboundSchema: z.ZodType<
+  GetPromptVersionResponseFormatText,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("text"),
+});
+/** @internal */
+export type GetPromptVersionResponseFormatText$Outbound = {
+  type: "text";
+};
+
+/** @internal */
+export const GetPromptVersionResponseFormatText$outboundSchema: z.ZodType<
+  GetPromptVersionResponseFormatText$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionResponseFormatText
+> = z.object({
+  type: z.literal("text"),
+});
+
+export function getPromptVersionResponseFormatTextToJSON(
+  getPromptVersionResponseFormatText: GetPromptVersionResponseFormatText,
+): string {
+  return JSON.stringify(
+    GetPromptVersionResponseFormatText$outboundSchema.parse(
+      getPromptVersionResponseFormatText,
+    ),
+  );
+}
+export function getPromptVersionResponseFormatTextFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionResponseFormatText, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetPromptVersionResponseFormatText$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionResponseFormatText' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionResponseFormat$inboundSchema: z.ZodType<
+  GetPromptVersionResponseFormat,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => GetPromptVersionResponseFormatText$inboundSchema),
+  z.lazy(() => GetPromptVersionResponseFormatJSONObject$inboundSchema),
+  z.lazy(() => GetPromptVersionResponseFormatPromptsJSONSchema$inboundSchema),
+]);
+/** @internal */
+export type GetPromptVersionResponseFormat$Outbound =
+  | GetPromptVersionResponseFormatText$Outbound
+  | GetPromptVersionResponseFormatJSONObject$Outbound
+  | GetPromptVersionResponseFormatPromptsJSONSchema$Outbound;
+
+/** @internal */
+export const GetPromptVersionResponseFormat$outboundSchema: z.ZodType<
+  GetPromptVersionResponseFormat$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionResponseFormat
+> = z.union([
+  z.lazy(() => GetPromptVersionResponseFormatText$outboundSchema),
+  z.lazy(() => GetPromptVersionResponseFormatJSONObject$outboundSchema),
+  z.lazy(() => GetPromptVersionResponseFormatPromptsJSONSchema$outboundSchema),
+]);
+
+export function getPromptVersionResponseFormatToJSON(
+  getPromptVersionResponseFormat: GetPromptVersionResponseFormat,
+): string {
+  return JSON.stringify(
+    GetPromptVersionResponseFormat$outboundSchema.parse(
+      getPromptVersionResponseFormat,
+    ),
+  );
+}
+export function getPromptVersionResponseFormatFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionResponseFormat, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionResponseFormat$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionResponseFormat' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionReasoningEffort$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionReasoningEffort
+> = z.nativeEnum(GetPromptVersionReasoningEffort);
+/** @internal */
+export const GetPromptVersionReasoningEffort$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionReasoningEffort
+> = GetPromptVersionReasoningEffort$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionStop$inboundSchema: z.ZodType<
+  GetPromptVersionStop,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.string(), z.array(z.string())]);
+/** @internal */
+export type GetPromptVersionStop$Outbound = string | Array<string>;
+
+/** @internal */
+export const GetPromptVersionStop$outboundSchema: z.ZodType<
+  GetPromptVersionStop$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionStop
+> = z.union([z.string(), z.array(z.string())]);
+
+export function getPromptVersionStopToJSON(
+  getPromptVersionStop: GetPromptVersionStop,
 ): string {
   return JSON.stringify(
-    GetPromptVersionResponseFormat3$outboundSchema.parse(
-      getPromptVersionResponseFormat3,
+    GetPromptVersionStop$outboundSchema.parse(getPromptVersionStop),
+  );
+}
+export function getPromptVersionStopFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionStop, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionStop$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionStop' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionStreamOptions$inboundSchema: z.ZodType<
+  GetPromptVersionStreamOptions,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  include_usage: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "include_usage": "includeUsage",
+  });
+});
+/** @internal */
+export type GetPromptVersionStreamOptions$Outbound = {
+  include_usage?: boolean | undefined;
+};
+
+/** @internal */
+export const GetPromptVersionStreamOptions$outboundSchema: z.ZodType<
+  GetPromptVersionStreamOptions$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionStreamOptions
+> = z.object({
+  includeUsage: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    includeUsage: "include_usage",
+  });
+});
+
+export function getPromptVersionStreamOptionsToJSON(
+  getPromptVersionStreamOptions: GetPromptVersionStreamOptions,
+): string {
+  return JSON.stringify(
+    GetPromptVersionStreamOptions$outboundSchema.parse(
+      getPromptVersionStreamOptions,
     ),
   );
 }
-export function getPromptVersionResponseFormat3FromJSON(
+export function getPromptVersionStreamOptionsFromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersionResponseFormat3, SDKValidationError> {
+): SafeParseResult<GetPromptVersionStreamOptions, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersionResponseFormat3$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersionResponseFormat3' from JSON`,
+    (x) => GetPromptVersionStreamOptions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionStreamOptions' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersionResponseFormatPromptsType$inboundSchema:
-  z.ZodNativeEnum<typeof GetPromptVersionResponseFormatPromptsType> = z
-    .nativeEnum(GetPromptVersionResponseFormatPromptsType);
+export const GetPromptVersionThinking$inboundSchema: z.ZodType<
+  GetPromptVersionThinking,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  components.ThinkingConfigDisabledSchema$inboundSchema,
+  components.ThinkingConfigEnabledSchema$inboundSchema,
+]);
 /** @internal */
-export const GetPromptVersionResponseFormatPromptsType$outboundSchema:
-  z.ZodNativeEnum<typeof GetPromptVersionResponseFormatPromptsType> =
-    GetPromptVersionResponseFormatPromptsType$inboundSchema;
+export type GetPromptVersionThinking$Outbound =
+  | components.ThinkingConfigDisabledSchema$Outbound
+  | components.ThinkingConfigEnabledSchema$Outbound;
 
 /** @internal */
-export const GetPromptVersionResponseFormat2$inboundSchema: z.ZodType<
-  GetPromptVersionResponseFormat2,
+export const GetPromptVersionThinking$outboundSchema: z.ZodType<
+  GetPromptVersionThinking$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionThinking
+> = z.union([
+  components.ThinkingConfigDisabledSchema$outboundSchema,
+  components.ThinkingConfigEnabledSchema$outboundSchema,
+]);
+
+export function getPromptVersionThinkingToJSON(
+  getPromptVersionThinking: GetPromptVersionThinking,
+): string {
+  return JSON.stringify(
+    GetPromptVersionThinking$outboundSchema.parse(getPromptVersionThinking),
+  );
+}
+export function getPromptVersionThinkingFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionThinking, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionThinking$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionThinking' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionToolChoiceType$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionToolChoiceType
+> = z.nativeEnum(GetPromptVersionToolChoiceType);
+/** @internal */
+export const GetPromptVersionToolChoiceType$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionToolChoiceType
+> = GetPromptVersionToolChoiceType$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionToolChoiceFunction$inboundSchema: z.ZodType<
+  GetPromptVersionToolChoiceFunction,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: GetPromptVersionResponseFormatPromptsType$inboundSchema,
+  name: z.string(),
 });
 /** @internal */
-export type GetPromptVersionResponseFormat2$Outbound = {
-  type: string;
+export type GetPromptVersionToolChoiceFunction$Outbound = {
+  name: string;
 };
 
 /** @internal */
-export const GetPromptVersionResponseFormat2$outboundSchema: z.ZodType<
-  GetPromptVersionResponseFormat2$Outbound,
+export const GetPromptVersionToolChoiceFunction$outboundSchema: z.ZodType<
+  GetPromptVersionToolChoiceFunction$Outbound,
   z.ZodTypeDef,
-  GetPromptVersionResponseFormat2
+  GetPromptVersionToolChoiceFunction
 > = z.object({
-  type: GetPromptVersionResponseFormatPromptsType$outboundSchema,
+  name: z.string(),
 });
 
-export function getPromptVersionResponseFormat2ToJSON(
-  getPromptVersionResponseFormat2: GetPromptVersionResponseFormat2,
+export function getPromptVersionToolChoiceFunctionToJSON(
+  getPromptVersionToolChoiceFunction: GetPromptVersionToolChoiceFunction,
 ): string {
   return JSON.stringify(
-    GetPromptVersionResponseFormat2$outboundSchema.parse(
-      getPromptVersionResponseFormat2,
+    GetPromptVersionToolChoiceFunction$outboundSchema.parse(
+      getPromptVersionToolChoiceFunction,
     ),
   );
 }
-export function getPromptVersionResponseFormat2FromJSON(
+export function getPromptVersionToolChoiceFunctionFromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersionResponseFormat2, SDKValidationError> {
+): SafeParseResult<GetPromptVersionToolChoiceFunction, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersionResponseFormat2$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersionResponseFormat2' from JSON`,
+    (x) =>
+      GetPromptVersionToolChoiceFunction$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionToolChoiceFunction' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionToolChoice2$inboundSchema: z.ZodType<
+  GetPromptVersionToolChoice2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: GetPromptVersionToolChoiceType$inboundSchema.optional(),
+  function: z.lazy(() => GetPromptVersionToolChoiceFunction$inboundSchema),
+});
+/** @internal */
+export type GetPromptVersionToolChoice2$Outbound = {
+  type?: string | undefined;
+  function: GetPromptVersionToolChoiceFunction$Outbound;
+};
+
+/** @internal */
+export const GetPromptVersionToolChoice2$outboundSchema: z.ZodType<
+  GetPromptVersionToolChoice2$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionToolChoice2
+> = z.object({
+  type: GetPromptVersionToolChoiceType$outboundSchema.optional(),
+  function: z.lazy(() => GetPromptVersionToolChoiceFunction$outboundSchema),
+});
+
+export function getPromptVersionToolChoice2ToJSON(
+  getPromptVersionToolChoice2: GetPromptVersionToolChoice2,
+): string {
+  return JSON.stringify(
+    GetPromptVersionToolChoice2$outboundSchema.parse(
+      getPromptVersionToolChoice2,
+    ),
+  );
+}
+export function getPromptVersionToolChoice2FromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionToolChoice2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionToolChoice2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionToolChoice2' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersionResponseFormatType$inboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionResponseFormatType
-> = z.nativeEnum(GetPromptVersionResponseFormatType);
+export const GetPromptVersionToolChoice1$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionToolChoice1
+> = z.nativeEnum(GetPromptVersionToolChoice1);
 /** @internal */
-export const GetPromptVersionResponseFormatType$outboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionResponseFormatType
-> = GetPromptVersionResponseFormatType$inboundSchema;
+export const GetPromptVersionToolChoice1$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionToolChoice1
+> = GetPromptVersionToolChoice1$inboundSchema;
 
 /** @internal */
-export const GetPromptVersionResponseFormatJsonSchema$inboundSchema: z.ZodType<
-  GetPromptVersionResponseFormatJsonSchema,
+export const GetPromptVersionToolChoice$inboundSchema: z.ZodType<
+  GetPromptVersionToolChoice,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => GetPromptVersionToolChoice2$inboundSchema),
+  GetPromptVersionToolChoice1$inboundSchema,
+]);
+/** @internal */
+export type GetPromptVersionToolChoice$Outbound =
+  | GetPromptVersionToolChoice2$Outbound
+  | string;
+
+/** @internal */
+export const GetPromptVersionToolChoice$outboundSchema: z.ZodType<
+  GetPromptVersionToolChoice$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionToolChoice
+> = z.union([
+  z.lazy(() => GetPromptVersionToolChoice2$outboundSchema),
+  GetPromptVersionToolChoice1$outboundSchema,
+]);
+
+export function getPromptVersionToolChoiceToJSON(
+  getPromptVersionToolChoice: GetPromptVersionToolChoice,
+): string {
+  return JSON.stringify(
+    GetPromptVersionToolChoice$outboundSchema.parse(getPromptVersionToolChoice),
+  );
+}
+export function getPromptVersionToolChoiceFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionToolChoice, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionToolChoice$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionToolChoice' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionModalities$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionModalities
+> = z.nativeEnum(GetPromptVersionModalities);
+/** @internal */
+export const GetPromptVersionModalities$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionModalities
+> = GetPromptVersionModalities$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionId1$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionId1
+> = z.nativeEnum(GetPromptVersionId1);
+/** @internal */
+export const GetPromptVersionId1$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionId1
+> = GetPromptVersionId1$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionId$inboundSchema: z.ZodType<
+  GetPromptVersionId,
+  z.ZodTypeDef,
+  unknown
+> = z.union([GetPromptVersionId1$inboundSchema, z.string()]);
+/** @internal */
+export type GetPromptVersionId$Outbound = string | string;
+
+/** @internal */
+export const GetPromptVersionId$outboundSchema: z.ZodType<
+  GetPromptVersionId$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionId
+> = z.union([GetPromptVersionId1$outboundSchema, z.string()]);
+
+export function getPromptVersionIdToJSON(
+  getPromptVersionId: GetPromptVersionId,
+): string {
+  return JSON.stringify(
+    GetPromptVersionId$outboundSchema.parse(getPromptVersionId),
+  );
+}
+export function getPromptVersionIdFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionId' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionExecuteOn$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionExecuteOn
+> = z.nativeEnum(GetPromptVersionExecuteOn);
+/** @internal */
+export const GetPromptVersionExecuteOn$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionExecuteOn
+> = GetPromptVersionExecuteOn$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionGuardrails$inboundSchema: z.ZodType<
+  GetPromptVersionGuardrails,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  strict: z.boolean().optional(),
-  schema: z.record(z.any()),
+  id: z.union([GetPromptVersionId1$inboundSchema, z.string()]),
+  execute_on: GetPromptVersionExecuteOn$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "execute_on": "executeOn",
+  });
 });
 /** @internal */
-export type GetPromptVersionResponseFormatJsonSchema$Outbound = {
-  name: string;
-  description?: string | undefined;
-  strict?: boolean | undefined;
-  schema: { [k: string]: any };
+export type GetPromptVersionGuardrails$Outbound = {
+  id: string | string;
+  execute_on: string;
+};
+
+/** @internal */
+export const GetPromptVersionGuardrails$outboundSchema: z.ZodType<
+  GetPromptVersionGuardrails$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionGuardrails
+> = z.object({
+  id: z.union([GetPromptVersionId1$outboundSchema, z.string()]),
+  executeOn: GetPromptVersionExecuteOn$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    executeOn: "execute_on",
+  });
+});
+
+export function getPromptVersionGuardrailsToJSON(
+  getPromptVersionGuardrails: GetPromptVersionGuardrails,
+): string {
+  return JSON.stringify(
+    GetPromptVersionGuardrails$outboundSchema.parse(getPromptVersionGuardrails),
+  );
+}
+export function getPromptVersionGuardrailsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionGuardrails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionGuardrails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionGuardrails' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionContentPromptsResponse2002$inboundSchema:
+  z.ZodType<GetPromptVersionContentPromptsResponse2002, z.ZodTypeDef, unknown> =
+    components.TextContentPartSchema$inboundSchema;
+/** @internal */
+export type GetPromptVersionContentPromptsResponse2002$Outbound =
+  components.TextContentPartSchema$Outbound;
+
+/** @internal */
+export const GetPromptVersionContentPromptsResponse2002$outboundSchema:
+  z.ZodType<
+    GetPromptVersionContentPromptsResponse2002$Outbound,
+    z.ZodTypeDef,
+    GetPromptVersionContentPromptsResponse2002
+  > = components.TextContentPartSchema$outboundSchema;
+
+export function getPromptVersionContentPromptsResponse2002ToJSON(
+  getPromptVersionContentPromptsResponse2002:
+    GetPromptVersionContentPromptsResponse2002,
+): string {
+  return JSON.stringify(
+    GetPromptVersionContentPromptsResponse2002$outboundSchema.parse(
+      getPromptVersionContentPromptsResponse2002,
+    ),
+  );
+}
+export function getPromptVersionContentPromptsResponse2002FromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetPromptVersionContentPromptsResponse2002,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetPromptVersionContentPromptsResponse2002$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetPromptVersionContentPromptsResponse2002' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionMessagesPromptsResponse200Content$inboundSchema:
+  z.ZodType<
+    GetPromptVersionMessagesPromptsResponse200Content,
+    z.ZodTypeDef,
+    unknown
+  > = z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$inboundSchema),
+  ]);
+/** @internal */
+export type GetPromptVersionMessagesPromptsResponse200Content$Outbound =
+  | string
+  | Array<components.TextContentPartSchema$Outbound>;
+
+/** @internal */
+export const GetPromptVersionMessagesPromptsResponse200Content$outboundSchema:
+  z.ZodType<
+    GetPromptVersionMessagesPromptsResponse200Content$Outbound,
+    z.ZodTypeDef,
+    GetPromptVersionMessagesPromptsResponse200Content
+  > = z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]);
+
+export function getPromptVersionMessagesPromptsResponse200ContentToJSON(
+  getPromptVersionMessagesPromptsResponse200Content:
+    GetPromptVersionMessagesPromptsResponse200Content,
+): string {
+  return JSON.stringify(
+    GetPromptVersionMessagesPromptsResponse200Content$outboundSchema.parse(
+      getPromptVersionMessagesPromptsResponse200Content,
+    ),
+  );
+}
+export function getPromptVersionMessagesPromptsResponse200ContentFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetPromptVersionMessagesPromptsResponse200Content,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetPromptVersionMessagesPromptsResponse200Content$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetPromptVersionMessagesPromptsResponse200Content' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionMessagesPromptsType$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionMessagesPromptsType
+> = z.nativeEnum(GetPromptVersionMessagesPromptsType);
+/** @internal */
+export const GetPromptVersionMessagesPromptsType$outboundSchema:
+  z.ZodNativeEnum<typeof GetPromptVersionMessagesPromptsType> =
+    GetPromptVersionMessagesPromptsType$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionMessagesTtl$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionMessagesTtl
+> = z.nativeEnum(GetPromptVersionMessagesTtl);
+/** @internal */
+export const GetPromptVersionMessagesTtl$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionMessagesTtl
+> = GetPromptVersionMessagesTtl$inboundSchema;
+
+/** @internal */
+export const GetPromptVersionMessagesCacheControl$inboundSchema: z.ZodType<
+  GetPromptVersionMessagesCacheControl,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: GetPromptVersionMessagesPromptsType$inboundSchema,
+  ttl: GetPromptVersionMessagesTtl$inboundSchema.default("5m"),
+});
+/** @internal */
+export type GetPromptVersionMessagesCacheControl$Outbound = {
+  type: string;
+  ttl: string;
 };
 
 /** @internal */
-export const GetPromptVersionResponseFormatJsonSchema$outboundSchema: z.ZodType<
-  GetPromptVersionResponseFormatJsonSchema$Outbound,
+export const GetPromptVersionMessagesCacheControl$outboundSchema: z.ZodType<
+  GetPromptVersionMessagesCacheControl$Outbound,
   z.ZodTypeDef,
-  GetPromptVersionResponseFormatJsonSchema
+  GetPromptVersionMessagesCacheControl
 > = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  strict: z.boolean().optional(),
-  schema: z.record(z.any()),
+  type: GetPromptVersionMessagesPromptsType$outboundSchema,
+  ttl: GetPromptVersionMessagesTtl$outboundSchema.default("5m"),
 });
 
-export function getPromptVersionResponseFormatJsonSchemaToJSON(
-  getPromptVersionResponseFormatJsonSchema:
-    GetPromptVersionResponseFormatJsonSchema,
+export function getPromptVersionMessagesCacheControlToJSON(
+  getPromptVersionMessagesCacheControl: GetPromptVersionMessagesCacheControl,
 ): string {
   return JSON.stringify(
-    GetPromptVersionResponseFormatJsonSchema$outboundSchema.parse(
-      getPromptVersionResponseFormatJsonSchema,
+    GetPromptVersionMessagesCacheControl$outboundSchema.parse(
+      getPromptVersionMessagesCacheControl,
     ),
   );
 }
-export function getPromptVersionResponseFormatJsonSchemaFromJSON(
+export function getPromptVersionMessagesCacheControlFromJSON(
   jsonString: string,
-): SafeParseResult<
-  GetPromptVersionResponseFormatJsonSchema,
-  SDKValidationError
-> {
+): SafeParseResult<GetPromptVersionMessagesCacheControl, SDKValidationError> {
   return safeParse(
     jsonString,
     (x) =>
-      GetPromptVersionResponseFormatJsonSchema$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'GetPromptVersionResponseFormatJsonSchema' from JSON`,
+      GetPromptVersionMessagesCacheControl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionMessagesCacheControl' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersionResponseFormat1$inboundSchema: z.ZodType<
-  GetPromptVersionResponseFormat1,
+export const GetPromptVersionMessagesToolMessage$inboundSchema: z.ZodType<
+  GetPromptVersionMessagesToolMessage,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: GetPromptVersionResponseFormatType$inboundSchema,
-  display_name: z.string().optional(),
-  json_schema: z.lazy(() =>
-    GetPromptVersionResponseFormatJsonSchema$inboundSchema
-  ),
+  role: z.literal("tool"),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$inboundSchema),
+  ]),
+  tool_call_id: z.nullable(z.string()),
+  cache_control: z.lazy(() =>
+    GetPromptVersionMessagesCacheControl$inboundSchema
+  ).optional(),
 }).transform((v) => {
   return remap$(v, {
-    "display_name": "displayName",
-    "json_schema": "jsonSchema",
+    "tool_call_id": "toolCallId",
+    "cache_control": "cacheControl",
   });
 });
 /** @internal */
-export type GetPromptVersionResponseFormat1$Outbound = {
-  type: string;
-  display_name?: string | undefined;
-  json_schema: GetPromptVersionResponseFormatJsonSchema$Outbound;
+export type GetPromptVersionMessagesToolMessage$Outbound = {
+  role: "tool";
+  content: string | Array<components.TextContentPartSchema$Outbound>;
+  tool_call_id: string | null;
+  cache_control?: GetPromptVersionMessagesCacheControl$Outbound | undefined;
 };
 
 /** @internal */
-export const GetPromptVersionResponseFormat1$outboundSchema: z.ZodType<
-  GetPromptVersionResponseFormat1$Outbound,
+export const GetPromptVersionMessagesToolMessage$outboundSchema: z.ZodType<
+  GetPromptVersionMessagesToolMessage$Outbound,
   z.ZodTypeDef,
-  GetPromptVersionResponseFormat1
+  GetPromptVersionMessagesToolMessage
 > = z.object({
-  type: GetPromptVersionResponseFormatType$outboundSchema,
-  displayName: z.string().optional(),
-  jsonSchema: z.lazy(() =>
-    GetPromptVersionResponseFormatJsonSchema$outboundSchema
-  ),
+  role: z.literal("tool"),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]),
+  toolCallId: z.nullable(z.string()),
+  cacheControl: z.lazy(() =>
+    GetPromptVersionMessagesCacheControl$outboundSchema
+  ).optional(),
 }).transform((v) => {
   return remap$(v, {
-    displayName: "display_name",
-    jsonSchema: "json_schema",
+    toolCallId: "tool_call_id",
+    cacheControl: "cache_control",
   });
 });
 
-export function getPromptVersionResponseFormat1ToJSON(
-  getPromptVersionResponseFormat1: GetPromptVersionResponseFormat1,
+export function getPromptVersionMessagesToolMessageToJSON(
+  getPromptVersionMessagesToolMessage: GetPromptVersionMessagesToolMessage,
 ): string {
   return JSON.stringify(
-    GetPromptVersionResponseFormat1$outboundSchema.parse(
-      getPromptVersionResponseFormat1,
+    GetPromptVersionMessagesToolMessage$outboundSchema.parse(
+      getPromptVersionMessagesToolMessage,
     ),
   );
 }
-export function getPromptVersionResponseFormat1FromJSON(
+export function getPromptVersionMessagesToolMessageFromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersionResponseFormat1, SDKValidationError> {
+): SafeParseResult<GetPromptVersionMessagesToolMessage, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersionResponseFormat1$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersionResponseFormat1' from JSON`,
+    (x) =>
+      GetPromptVersionMessagesToolMessage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionMessagesToolMessage' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersionResponseFormat$inboundSchema: z.ZodType<
-  GetPromptVersionResponseFormat,
+export const GetPromptVersionContentPromptsResponse2$inboundSchema: z.ZodType<
+  GetPromptVersionContentPromptsResponse2,
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => GetPromptVersionResponseFormat1$inboundSchema),
-  z.lazy(() => GetPromptVersionResponseFormat2$inboundSchema),
-  z.lazy(() => GetPromptVersionResponseFormat3$inboundSchema),
-  GetPromptVersionResponseFormat4$inboundSchema,
-  GetPromptVersionResponseFormat5$inboundSchema,
-  GetPromptVersionResponseFormat6$inboundSchema,
+  components.TextContentPartSchema$inboundSchema.and(
+    z.object({ type: z.literal("text") }),
+  ),
+  components.RefusalPartSchema$inboundSchema,
+  components.ReasoningPartSchema$inboundSchema,
+  components.RedactedReasoningPartSchema$inboundSchema,
 ]);
 /** @internal */
-export type GetPromptVersionResponseFormat$Outbound =
-  | GetPromptVersionResponseFormat1$Outbound
-  | GetPromptVersionResponseFormat2$Outbound
-  | GetPromptVersionResponseFormat3$Outbound
-  | string
-  | string
-  | string;
+export type GetPromptVersionContentPromptsResponse2$Outbound =
+  | (components.TextContentPartSchema$Outbound & { type: "text" })
+  | components.RefusalPartSchema$Outbound
+  | components.ReasoningPartSchema$Outbound
+  | components.RedactedReasoningPartSchema$Outbound;
 
 /** @internal */
-export const GetPromptVersionResponseFormat$outboundSchema: z.ZodType<
-  GetPromptVersionResponseFormat$Outbound,
+export const GetPromptVersionContentPromptsResponse2$outboundSchema: z.ZodType<
+  GetPromptVersionContentPromptsResponse2$Outbound,
   z.ZodTypeDef,
-  GetPromptVersionResponseFormat
+  GetPromptVersionContentPromptsResponse2
 > = z.union([
-  z.lazy(() => GetPromptVersionResponseFormat1$outboundSchema),
-  z.lazy(() => GetPromptVersionResponseFormat2$outboundSchema),
-  z.lazy(() => GetPromptVersionResponseFormat3$outboundSchema),
-  GetPromptVersionResponseFormat4$outboundSchema,
-  GetPromptVersionResponseFormat5$outboundSchema,
-  GetPromptVersionResponseFormat6$outboundSchema,
+  components.TextContentPartSchema$outboundSchema.and(
+    z.object({ type: z.literal("text") }),
+  ),
+  components.RefusalPartSchema$outboundSchema,
+  components.ReasoningPartSchema$outboundSchema,
+  components.RedactedReasoningPartSchema$outboundSchema,
 ]);
 
-export function getPromptVersionResponseFormatToJSON(
-  getPromptVersionResponseFormat: GetPromptVersionResponseFormat,
+export function getPromptVersionContentPromptsResponse2ToJSON(
+  getPromptVersionContentPromptsResponse2:
+    GetPromptVersionContentPromptsResponse2,
 ): string {
   return JSON.stringify(
-    GetPromptVersionResponseFormat$outboundSchema.parse(
-      getPromptVersionResponseFormat,
+    GetPromptVersionContentPromptsResponse2$outboundSchema.parse(
+      getPromptVersionContentPromptsResponse2,
     ),
   );
 }
-export function getPromptVersionResponseFormatFromJSON(
+export function getPromptVersionContentPromptsResponse2FromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersionResponseFormat, SDKValidationError> {
+): SafeParseResult<
+  GetPromptVersionContentPromptsResponse2,
+  SDKValidationError
+> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersionResponseFormat$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersionResponseFormat' from JSON`,
+    (x) =>
+      GetPromptVersionContentPromptsResponse2$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetPromptVersionContentPromptsResponse2' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersionPhotoRealVersion$inboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionPhotoRealVersion
-> = z.nativeEnum(GetPromptVersionPhotoRealVersion);
-/** @internal */
-export const GetPromptVersionPhotoRealVersion$outboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionPhotoRealVersion
-> = GetPromptVersionPhotoRealVersion$inboundSchema;
-
-/** @internal */
-export const GetPromptVersionEncodingFormat$inboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionEncodingFormat
-> = z.nativeEnum(GetPromptVersionEncodingFormat);
-/** @internal */
-export const GetPromptVersionEncodingFormat$outboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionEncodingFormat
-> = GetPromptVersionEncodingFormat$inboundSchema;
-
-/** @internal */
-export const GetPromptVersionReasoningEffort$inboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionReasoningEffort
-> = z.nativeEnum(GetPromptVersionReasoningEffort);
+export const GetPromptVersionMessagesPromptsResponseContent$inboundSchema:
+  z.ZodType<
+    GetPromptVersionMessagesPromptsResponseContent,
+    z.ZodTypeDef,
+    unknown
+  > = z.union([
+    z.string(),
+    z.array(
+      z.union([
+        components.TextContentPartSchema$inboundSchema.and(
+          z.object({ type: z.literal("text") }),
+        ),
+        components.RefusalPartSchema$inboundSchema,
+        components.ReasoningPartSchema$inboundSchema,
+        components.RedactedReasoningPartSchema$inboundSchema,
+      ]),
+    ),
+  ]);
 /** @internal */
-export const GetPromptVersionReasoningEffort$outboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionReasoningEffort
-> = GetPromptVersionReasoningEffort$inboundSchema;
+export type GetPromptVersionMessagesPromptsResponseContent$Outbound =
+  | string
+  | Array<
+    | (components.TextContentPartSchema$Outbound & { type: "text" })
+    | components.RefusalPartSchema$Outbound
+    | components.ReasoningPartSchema$Outbound
+    | components.RedactedReasoningPartSchema$Outbound
+  >;
 
 /** @internal */
-export const GetPromptVersionVerbosity$inboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionVerbosity
-> = z.nativeEnum(GetPromptVersionVerbosity);
-/** @internal */
-export const GetPromptVersionVerbosity$outboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionVerbosity
-> = GetPromptVersionVerbosity$inboundSchema;
+export const GetPromptVersionMessagesPromptsResponseContent$outboundSchema:
+  z.ZodType<
+    GetPromptVersionMessagesPromptsResponseContent$Outbound,
+    z.ZodTypeDef,
+    GetPromptVersionMessagesPromptsResponseContent
+  > = 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,
+      ]),
+    ),
+  ]);
 
-/** @internal */
-export const GetPromptVersionThinkingLevel$inboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionThinkingLevel
-> = z.nativeEnum(GetPromptVersionThinkingLevel);
-/** @internal */
-export const GetPromptVersionThinkingLevel$outboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionThinkingLevel
-> = GetPromptVersionThinkingLevel$inboundSchema;
+export function getPromptVersionMessagesPromptsResponseContentToJSON(
+  getPromptVersionMessagesPromptsResponseContent:
+    GetPromptVersionMessagesPromptsResponseContent,
+): string {
+  return JSON.stringify(
+    GetPromptVersionMessagesPromptsResponseContent$outboundSchema.parse(
+      getPromptVersionMessagesPromptsResponseContent,
+    ),
+  );
+}
+export function getPromptVersionMessagesPromptsResponseContentFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetPromptVersionMessagesPromptsResponseContent,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetPromptVersionMessagesPromptsResponseContent$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetPromptVersionMessagesPromptsResponseContent' from JSON`,
+  );
+}
 
 /** @internal */
-export const GetPromptVersionModelParameters$inboundSchema: z.ZodType<
-  GetPromptVersionModelParameters,
+export const GetPromptVersionMessagesAudio$inboundSchema: z.ZodType<
+  GetPromptVersionMessagesAudio,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  temperature: z.number().optional(),
-  maxTokens: z.number().optional(),
-  topK: z.number().optional(),
-  topP: z.number().optional(),
-  frequencyPenalty: z.number().optional(),
-  presencePenalty: z.number().optional(),
-  numImages: z.number().optional(),
-  seed: z.number().optional(),
-  format: GetPromptVersionFormat$inboundSchema.optional(),
-  dimensions: z.string().optional(),
-  quality: z.string().optional(),
-  style: z.string().optional(),
-  responseFormat: z.nullable(
-    z.union([
-      z.lazy(() => GetPromptVersionResponseFormat1$inboundSchema),
-      z.lazy(() => GetPromptVersionResponseFormat2$inboundSchema),
-      z.lazy(() => GetPromptVersionResponseFormat3$inboundSchema),
-      GetPromptVersionResponseFormat4$inboundSchema,
-      GetPromptVersionResponseFormat5$inboundSchema,
-      GetPromptVersionResponseFormat6$inboundSchema,
-    ]),
-  ).optional(),
-  photoRealVersion: GetPromptVersionPhotoRealVersion$inboundSchema.optional(),
-  encoding_format: GetPromptVersionEncodingFormat$inboundSchema.optional(),
-  reasoningEffort: GetPromptVersionReasoningEffort$inboundSchema.optional(),
-  budgetTokens: z.number().optional(),
-  verbosity: GetPromptVersionVerbosity$inboundSchema.optional(),
-  thinkingLevel: GetPromptVersionThinkingLevel$inboundSchema.optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "encoding_format": "encodingFormat",
-  });
+  id: z.string(),
 });
 /** @internal */
-export type GetPromptVersionModelParameters$Outbound = {
-  temperature?: number | undefined;
-  maxTokens?: number | undefined;
-  topK?: number | undefined;
-  topP?: number | undefined;
-  frequencyPenalty?: number | undefined;
-  presencePenalty?: number | undefined;
-  numImages?: number | undefined;
-  seed?: number | undefined;
-  format?: string | undefined;
-  dimensions?: string | undefined;
-  quality?: string | undefined;
-  style?: string | undefined;
-  responseFormat?:
-    | GetPromptVersionResponseFormat1$Outbound
-    | GetPromptVersionResponseFormat2$Outbound
-    | GetPromptVersionResponseFormat3$Outbound
-    | string
-    | string
-    | string
-    | null
-    | undefined;
-  photoRealVersion?: string | undefined;
-  encoding_format?: string | undefined;
-  reasoningEffort?: string | undefined;
-  budgetTokens?: number | undefined;
-  verbosity?: string | undefined;
-  thinkingLevel?: string | undefined;
-};
-
-/** @internal */
-export const GetPromptVersionModelParameters$outboundSchema: z.ZodType<
-  GetPromptVersionModelParameters$Outbound,
-  z.ZodTypeDef,
-  GetPromptVersionModelParameters
-> = z.object({
-  temperature: z.number().optional(),
-  maxTokens: z.number().optional(),
-  topK: z.number().optional(),
-  topP: z.number().optional(),
-  frequencyPenalty: z.number().optional(),
-  presencePenalty: z.number().optional(),
-  numImages: z.number().optional(),
-  seed: z.number().optional(),
-  format: GetPromptVersionFormat$outboundSchema.optional(),
-  dimensions: z.string().optional(),
-  quality: z.string().optional(),
-  style: z.string().optional(),
-  responseFormat: z.nullable(
-    z.union([
-      z.lazy(() => GetPromptVersionResponseFormat1$outboundSchema),
-      z.lazy(() => GetPromptVersionResponseFormat2$outboundSchema),
-      z.lazy(() => GetPromptVersionResponseFormat3$outboundSchema),
-      GetPromptVersionResponseFormat4$outboundSchema,
-      GetPromptVersionResponseFormat5$outboundSchema,
-      GetPromptVersionResponseFormat6$outboundSchema,
-    ]),
-  ).optional(),
-  photoRealVersion: GetPromptVersionPhotoRealVersion$outboundSchema.optional(),
-  encodingFormat: GetPromptVersionEncodingFormat$outboundSchema.optional(),
-  reasoningEffort: GetPromptVersionReasoningEffort$outboundSchema.optional(),
-  budgetTokens: z.number().optional(),
-  verbosity: GetPromptVersionVerbosity$outboundSchema.optional(),
-  thinkingLevel: GetPromptVersionThinkingLevel$outboundSchema.optional(),
-}).transform((v) => {
-  return remap$(v, {
-    encodingFormat: "encoding_format",
-  });
+export type GetPromptVersionMessagesAudio$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const GetPromptVersionMessagesAudio$outboundSchema: z.ZodType<
+  GetPromptVersionMessagesAudio$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionMessagesAudio
+> = z.object({
+  id: z.string(),
 });
 
-export function getPromptVersionModelParametersToJSON(
-  getPromptVersionModelParameters: GetPromptVersionModelParameters,
+export function getPromptVersionMessagesAudioToJSON(
+  getPromptVersionMessagesAudio: GetPromptVersionMessagesAudio,
 ): string {
   return JSON.stringify(
-    GetPromptVersionModelParameters$outboundSchema.parse(
-      getPromptVersionModelParameters,
+    GetPromptVersionMessagesAudio$outboundSchema.parse(
+      getPromptVersionMessagesAudio,
     ),
   );
 }
-export function getPromptVersionModelParametersFromJSON(
+export function getPromptVersionMessagesAudioFromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersionModelParameters, SDKValidationError> {
+): SafeParseResult<GetPromptVersionMessagesAudio, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersionModelParameters$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersionModelParameters' from JSON`,
+    (x) => GetPromptVersionMessagesAudio$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionMessagesAudio' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersionProvider$inboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionProvider
-> = z.nativeEnum(GetPromptVersionProvider);
-/** @internal */
-export const GetPromptVersionProvider$outboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionProvider
-> = GetPromptVersionProvider$inboundSchema;
-
-/** @internal */
-export const GetPromptVersionRole$inboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionRole
-> = z.nativeEnum(GetPromptVersionRole);
+export const GetPromptVersionMessagesType$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionMessagesType
+> = z.nativeEnum(GetPromptVersionMessagesType);
 /** @internal */
-export const GetPromptVersionRole$outboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionRole
-> = GetPromptVersionRole$inboundSchema;
+export const GetPromptVersionMessagesType$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersionMessagesType
+> = GetPromptVersionMessagesType$inboundSchema;
 
 /** @internal */
-export const GetPromptVersion2File$inboundSchema: z.ZodType<
-  GetPromptVersion2File,
+export const GetPromptVersionMessagesFunction$inboundSchema: z.ZodType<
+  GetPromptVersionMessagesFunction,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  file_data: z.string().optional(),
-  uri: z.string().optional(),
-  mimeType: z.string().optional(),
-  filename: z.string().optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "file_data": "fileData",
-  });
+  name: z.string().optional(),
+  arguments: z.string().optional(),
 });
 /** @internal */
-export type GetPromptVersion2File$Outbound = {
-  file_data?: string | undefined;
-  uri?: string | undefined;
-  mimeType?: string | undefined;
-  filename?: string | undefined;
+export type GetPromptVersionMessagesFunction$Outbound = {
+  name?: string | undefined;
+  arguments?: string | undefined;
 };
 
 /** @internal */
-export const GetPromptVersion2File$outboundSchema: z.ZodType<
-  GetPromptVersion2File$Outbound,
+export const GetPromptVersionMessagesFunction$outboundSchema: z.ZodType<
+  GetPromptVersionMessagesFunction$Outbound,
   z.ZodTypeDef,
-  GetPromptVersion2File
+  GetPromptVersionMessagesFunction
 > = z.object({
-  fileData: z.string().optional(),
-  uri: z.string().optional(),
-  mimeType: z.string().optional(),
-  filename: z.string().optional(),
-}).transform((v) => {
-  return remap$(v, {
-    fileData: "file_data",
-  });
+  name: z.string().optional(),
+  arguments: z.string().optional(),
 });
 
-export function getPromptVersion2FileToJSON(
-  getPromptVersion2File: GetPromptVersion2File,
+export function getPromptVersionMessagesFunctionToJSON(
+  getPromptVersionMessagesFunction: GetPromptVersionMessagesFunction,
 ): string {
   return JSON.stringify(
-    GetPromptVersion2File$outboundSchema.parse(getPromptVersion2File),
+    GetPromptVersionMessagesFunction$outboundSchema.parse(
+      getPromptVersionMessagesFunction,
+    ),
   );
 }
-export function getPromptVersion2FileFromJSON(
+export function getPromptVersionMessagesFunctionFromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersion2File, SDKValidationError> {
+): SafeParseResult<GetPromptVersionMessagesFunction, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersion2File$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersion2File' from JSON`,
+    (x) => GetPromptVersionMessagesFunction$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionMessagesFunction' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersion23$inboundSchema: z.ZodType<
-  GetPromptVersion23,
+export const GetPromptVersionMessagesToolCalls$inboundSchema: z.ZodType<
+  GetPromptVersionMessagesToolCalls,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: z.literal("file"),
-  file: z.lazy(() => GetPromptVersion2File$inboundSchema),
+  id: z.string(),
+  type: GetPromptVersionMessagesType$inboundSchema,
+  function: z.lazy(() => GetPromptVersionMessagesFunction$inboundSchema),
+  thought_signature: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "thought_signature": "thoughtSignature",
+  });
 });
 /** @internal */
-export type GetPromptVersion23$Outbound = {
-  type: "file";
-  file: GetPromptVersion2File$Outbound;
+export type GetPromptVersionMessagesToolCalls$Outbound = {
+  id: string;
+  type: string;
+  function: GetPromptVersionMessagesFunction$Outbound;
+  thought_signature?: string | undefined;
 };
 
 /** @internal */
-export const GetPromptVersion23$outboundSchema: z.ZodType<
-  GetPromptVersion23$Outbound,
+export const GetPromptVersionMessagesToolCalls$outboundSchema: z.ZodType<
+  GetPromptVersionMessagesToolCalls$Outbound,
   z.ZodTypeDef,
-  GetPromptVersion23
+  GetPromptVersionMessagesToolCalls
 > = z.object({
-  type: z.literal("file"),
-  file: z.lazy(() => GetPromptVersion2File$outboundSchema),
+  id: z.string(),
+  type: GetPromptVersionMessagesType$outboundSchema,
+  function: z.lazy(() => GetPromptVersionMessagesFunction$outboundSchema),
+  thoughtSignature: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    thoughtSignature: "thought_signature",
+  });
 });
 
-export function getPromptVersion23ToJSON(
-  getPromptVersion23: GetPromptVersion23,
+export function getPromptVersionMessagesToolCallsToJSON(
+  getPromptVersionMessagesToolCalls: GetPromptVersionMessagesToolCalls,
 ): string {
   return JSON.stringify(
-    GetPromptVersion23$outboundSchema.parse(getPromptVersion23),
+    GetPromptVersionMessagesToolCalls$outboundSchema.parse(
+      getPromptVersionMessagesToolCalls,
+    ),
   );
 }
-export function getPromptVersion23FromJSON(
+export function getPromptVersionMessagesToolCallsFromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersion23, SDKValidationError> {
+): SafeParseResult<GetPromptVersionMessagesToolCalls, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersion23$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersion23' from JSON`,
+    (x) => GetPromptVersionMessagesToolCalls$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionMessagesToolCalls' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersion2ImageUrl$inboundSchema: z.ZodType<
-  GetPromptVersion2ImageUrl,
+export const GetPromptVersionMessagesAssistantMessage$inboundSchema: z.ZodType<
+  GetPromptVersionMessagesAssistantMessage,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.string().optional(),
-  url: z.string(),
-  detail: z.string().optional(),
+  content: z.nullable(
+    z.union([
+      z.string(),
+      z.array(
+        z.union([
+          components.TextContentPartSchema$inboundSchema.and(
+            z.object({ type: z.literal("text") }),
+          ),
+          components.RefusalPartSchema$inboundSchema,
+          components.ReasoningPartSchema$inboundSchema,
+          components.RedactedReasoningPartSchema$inboundSchema,
+        ]),
+      ),
+    ]),
+  ).optional(),
+  refusal: z.nullable(z.string()).optional(),
+  role: z.literal("assistant"),
+  name: z.string().optional(),
+  audio: z.nullable(z.lazy(() => GetPromptVersionMessagesAudio$inboundSchema))
+    .optional(),
+  tool_calls: z.array(
+    z.lazy(() => GetPromptVersionMessagesToolCalls$inboundSchema),
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "tool_calls": "toolCalls",
+  });
 });
 /** @internal */
-export type GetPromptVersion2ImageUrl$Outbound = {
-  id?: string | undefined;
-  url: string;
-  detail?: string | undefined;
+export type GetPromptVersionMessagesAssistantMessage$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?: GetPromptVersionMessagesAudio$Outbound | null | undefined;
+  tool_calls?: Array<GetPromptVersionMessagesToolCalls$Outbound> | undefined;
 };
 
 /** @internal */
-export const GetPromptVersion2ImageUrl$outboundSchema: z.ZodType<
-  GetPromptVersion2ImageUrl$Outbound,
+export const GetPromptVersionMessagesAssistantMessage$outboundSchema: z.ZodType<
+  GetPromptVersionMessagesAssistantMessage$Outbound,
   z.ZodTypeDef,
-  GetPromptVersion2ImageUrl
+  GetPromptVersionMessagesAssistantMessage
 > = z.object({
-  id: z.string().optional(),
-  url: z.string(),
-  detail: z.string().optional(),
+  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(() => GetPromptVersionMessagesAudio$outboundSchema))
+    .optional(),
+  toolCalls: z.array(
+    z.lazy(() => GetPromptVersionMessagesToolCalls$outboundSchema),
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    toolCalls: "tool_calls",
+  });
 });
 
-export function getPromptVersion2ImageUrlToJSON(
-  getPromptVersion2ImageUrl: GetPromptVersion2ImageUrl,
+export function getPromptVersionMessagesAssistantMessageToJSON(
+  getPromptVersionMessagesAssistantMessage:
+    GetPromptVersionMessagesAssistantMessage,
 ): string {
   return JSON.stringify(
-    GetPromptVersion2ImageUrl$outboundSchema.parse(getPromptVersion2ImageUrl),
+    GetPromptVersionMessagesAssistantMessage$outboundSchema.parse(
+      getPromptVersionMessagesAssistantMessage,
+    ),
   );
 }
-export function getPromptVersion2ImageUrlFromJSON(
+export function getPromptVersionMessagesAssistantMessageFromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersion2ImageUrl, SDKValidationError> {
+): SafeParseResult<
+  GetPromptVersionMessagesAssistantMessage,
+  SDKValidationError
+> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersion2ImageUrl$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersion2ImageUrl' from JSON`,
+    (x) =>
+      GetPromptVersionMessagesAssistantMessage$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetPromptVersionMessagesAssistantMessage' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersion22$inboundSchema: z.ZodType<
-  GetPromptVersion22,
+export const GetPromptVersion2PromptsResponse200ApplicationJSONType$inboundSchema:
+  z.ZodNativeEnum<
+    typeof GetPromptVersion2PromptsResponse200ApplicationJSONType
+  > = z.nativeEnum(GetPromptVersion2PromptsResponse200ApplicationJSONType);
+/** @internal */
+export const GetPromptVersion2PromptsResponse200ApplicationJSONType$outboundSchema:
+  z.ZodNativeEnum<
+    typeof GetPromptVersion2PromptsResponse200ApplicationJSONType
+  > = GetPromptVersion2PromptsResponse200ApplicationJSONType$inboundSchema;
+
+/** @internal */
+export const GetPromptVersion2Ttl$inboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersion2Ttl
+> = z.nativeEnum(GetPromptVersion2Ttl);
+/** @internal */
+export const GetPromptVersion2Ttl$outboundSchema: z.ZodNativeEnum<
+  typeof GetPromptVersion2Ttl
+> = GetPromptVersion2Ttl$inboundSchema;
+
+/** @internal */
+export const GetPromptVersion2CacheControl$inboundSchema: z.ZodType<
+  GetPromptVersion2CacheControl,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: z.literal("image_url"),
-  image_url: z.lazy(() => GetPromptVersion2ImageUrl$inboundSchema),
-}).transform((v) => {
-  return remap$(v, {
-    "image_url": "imageUrl",
-  });
+  type: GetPromptVersion2PromptsResponse200ApplicationJSONType$inboundSchema,
+  ttl: GetPromptVersion2Ttl$inboundSchema.default("5m"),
 });
 /** @internal */
-export type GetPromptVersion22$Outbound = {
-  type: "image_url";
-  image_url: GetPromptVersion2ImageUrl$Outbound;
+export type GetPromptVersion2CacheControl$Outbound = {
+  type: string;
+  ttl: string;
 };
 
 /** @internal */
-export const GetPromptVersion22$outboundSchema: z.ZodType<
-  GetPromptVersion22$Outbound,
+export const GetPromptVersion2CacheControl$outboundSchema: z.ZodType<
+  GetPromptVersion2CacheControl$Outbound,
   z.ZodTypeDef,
-  GetPromptVersion22
+  GetPromptVersion2CacheControl
 > = z.object({
-  type: z.literal("image_url"),
-  imageUrl: z.lazy(() => GetPromptVersion2ImageUrl$outboundSchema),
-}).transform((v) => {
-  return remap$(v, {
-    imageUrl: "image_url",
-  });
+  type: GetPromptVersion2PromptsResponse200ApplicationJSONType$outboundSchema,
+  ttl: GetPromptVersion2Ttl$outboundSchema.default("5m"),
 });
 
-export function getPromptVersion22ToJSON(
-  getPromptVersion22: GetPromptVersion22,
+export function getPromptVersion2CacheControlToJSON(
+  getPromptVersion2CacheControl: GetPromptVersion2CacheControl,
 ): string {
   return JSON.stringify(
-    GetPromptVersion22$outboundSchema.parse(getPromptVersion22),
+    GetPromptVersion2CacheControl$outboundSchema.parse(
+      getPromptVersion2CacheControl,
+    ),
   );
 }
-export function getPromptVersion22FromJSON(
+export function getPromptVersion2CacheControlFromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersion22, SDKValidationError> {
+): SafeParseResult<GetPromptVersion2CacheControl, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersion22$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersion22' from JSON`,
+    (x) => GetPromptVersion2CacheControl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersion2CacheControl' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersion21$inboundSchema: z.ZodType<
-  GetPromptVersion21,
+export const GetPromptVersion24$inboundSchema: z.ZodType<
+  GetPromptVersion24,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: z.literal("text"),
-  text: z.string(),
+  type: z.literal("file"),
+  cache_control: z.lazy(() => GetPromptVersion2CacheControl$inboundSchema)
+    .optional(),
+  file: components.FileContentPartSchema$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "cache_control": "cacheControl",
+  });
 });
 /** @internal */
-export type GetPromptVersion21$Outbound = {
-  type: "text";
-  text: string;
+export type GetPromptVersion24$Outbound = {
+  type: "file";
+  cache_control?: GetPromptVersion2CacheControl$Outbound | undefined;
+  file: components.FileContentPartSchema$Outbound;
 };
 
 /** @internal */
-export const GetPromptVersion21$outboundSchema: z.ZodType<
-  GetPromptVersion21$Outbound,
+export const GetPromptVersion24$outboundSchema: z.ZodType<
+  GetPromptVersion24$Outbound,
   z.ZodTypeDef,
-  GetPromptVersion21
+  GetPromptVersion24
 > = z.object({
-  type: z.literal("text"),
-  text: z.string(),
+  type: z.literal("file"),
+  cacheControl: z.lazy(() => GetPromptVersion2CacheControl$outboundSchema)
+    .optional(),
+  file: components.FileContentPartSchema$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    cacheControl: "cache_control",
+  });
 });
 
-export function getPromptVersion21ToJSON(
-  getPromptVersion21: GetPromptVersion21,
+export function getPromptVersion24ToJSON(
+  getPromptVersion24: GetPromptVersion24,
 ): string {
   return JSON.stringify(
-    GetPromptVersion21$outboundSchema.parse(getPromptVersion21),
+    GetPromptVersion24$outboundSchema.parse(getPromptVersion24),
   );
 }
-export function getPromptVersion21FromJSON(
+export function getPromptVersion24FromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersion21, SDKValidationError> {
+): SafeParseResult<GetPromptVersion24, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersion21$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersion21' from JSON`,
+    (x) => GetPromptVersion24$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersion24' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersionContent2$inboundSchema: z.ZodType<
-  GetPromptVersionContent2,
+export const GetPromptVersionContentPrompts2$inboundSchema: z.ZodType<
+  GetPromptVersionContentPrompts2,
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => GetPromptVersion21$inboundSchema),
-  z.lazy(() => GetPromptVersion22$inboundSchema),
-  z.lazy(() => GetPromptVersion23$inboundSchema),
+  components.TextContentPartSchema$inboundSchema.and(
+    z.object({ type: z.literal("text") }),
+  ),
+  components.ImageContentPartSchema$inboundSchema,
+  components.AudioContentPartSchema$inboundSchema,
+  z.lazy(() => GetPromptVersion24$inboundSchema),
 ]);
 /** @internal */
-export type GetPromptVersionContent2$Outbound =
-  | GetPromptVersion21$Outbound
-  | GetPromptVersion22$Outbound
-  | GetPromptVersion23$Outbound;
+export type GetPromptVersionContentPrompts2$Outbound =
+  | (components.TextContentPartSchema$Outbound & { type: "text" })
+  | components.ImageContentPartSchema$Outbound
+  | components.AudioContentPartSchema$Outbound
+  | GetPromptVersion24$Outbound;
 
 /** @internal */
-export const GetPromptVersionContent2$outboundSchema: z.ZodType<
-  GetPromptVersionContent2$Outbound,
+export const GetPromptVersionContentPrompts2$outboundSchema: z.ZodType<
+  GetPromptVersionContentPrompts2$Outbound,
   z.ZodTypeDef,
-  GetPromptVersionContent2
+  GetPromptVersionContentPrompts2
 > = z.union([
-  z.lazy(() => GetPromptVersion21$outboundSchema),
-  z.lazy(() => GetPromptVersion22$outboundSchema),
-  z.lazy(() => GetPromptVersion23$outboundSchema),
+  components.TextContentPartSchema$outboundSchema.and(
+    z.object({ type: z.literal("text") }),
+  ),
+  components.ImageContentPartSchema$outboundSchema,
+  components.AudioContentPartSchema$outboundSchema,
+  z.lazy(() => GetPromptVersion24$outboundSchema),
 ]);
 
-export function getPromptVersionContent2ToJSON(
-  getPromptVersionContent2: GetPromptVersionContent2,
+export function getPromptVersionContentPrompts2ToJSON(
+  getPromptVersionContentPrompts2: GetPromptVersionContentPrompts2,
 ): string {
   return JSON.stringify(
-    GetPromptVersionContent2$outboundSchema.parse(getPromptVersionContent2),
+    GetPromptVersionContentPrompts2$outboundSchema.parse(
+      getPromptVersionContentPrompts2,
+    ),
   );
 }
-export function getPromptVersionContent2FromJSON(
+export function getPromptVersionContentPrompts2FromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersionContent2, SDKValidationError> {
+): SafeParseResult<GetPromptVersionContentPrompts2, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersionContent2$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersionContent2' from JSON`,
+    (x) => GetPromptVersionContentPrompts2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionContentPrompts2' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersionContent$inboundSchema: z.ZodType<
-  GetPromptVersionContent,
+export const GetPromptVersionMessagesPromptsContent$inboundSchema: z.ZodType<
+  GetPromptVersionMessagesPromptsContent,
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.string(),
-  z.array(z.union([
-    z.lazy(() => GetPromptVersion21$inboundSchema),
-    z.lazy(() => GetPromptVersion22$inboundSchema),
-    z.lazy(() => GetPromptVersion23$inboundSchema),
-  ])),
+  z.string(),
+  z.array(
+    z.union([
+      components.TextContentPartSchema$inboundSchema.and(
+        z.object({ type: z.literal("text") }),
+      ),
+      components.ImageContentPartSchema$inboundSchema,
+      components.AudioContentPartSchema$inboundSchema,
+      z.lazy(() => GetPromptVersion24$inboundSchema),
+    ]),
+  ),
 ]);
 /** @internal */
-export type GetPromptVersionContent$Outbound =
+export type GetPromptVersionMessagesPromptsContent$Outbound =
   | string
   | Array<
-    | GetPromptVersion21$Outbound
-    | GetPromptVersion22$Outbound
-    | GetPromptVersion23$Outbound
+    | (components.TextContentPartSchema$Outbound & { type: "text" })
+    | components.ImageContentPartSchema$Outbound
+    | components.AudioContentPartSchema$Outbound
+    | GetPromptVersion24$Outbound
   >;
 
 /** @internal */
-export const GetPromptVersionContent$outboundSchema: z.ZodType<
-  GetPromptVersionContent$Outbound,
+export const GetPromptVersionMessagesPromptsContent$outboundSchema: z.ZodType<
+  GetPromptVersionMessagesPromptsContent$Outbound,
   z.ZodTypeDef,
-  GetPromptVersionContent
+  GetPromptVersionMessagesPromptsContent
 > = z.union([
   z.string(),
-  z.array(z.union([
-    z.lazy(() => GetPromptVersion21$outboundSchema),
-    z.lazy(() => GetPromptVersion22$outboundSchema),
-    z.lazy(() => GetPromptVersion23$outboundSchema),
-  ])),
+  z.array(
+    z.union([
+      components.TextContentPartSchema$outboundSchema.and(
+        z.object({ type: z.literal("text") }),
+      ),
+      components.ImageContentPartSchema$outboundSchema,
+      components.AudioContentPartSchema$outboundSchema,
+      z.lazy(() => GetPromptVersion24$outboundSchema),
+    ]),
+  ),
 ]);
 
-export function getPromptVersionContentToJSON(
-  getPromptVersionContent: GetPromptVersionContent,
+export function getPromptVersionMessagesPromptsContentToJSON(
+  getPromptVersionMessagesPromptsContent:
+    GetPromptVersionMessagesPromptsContent,
 ): string {
   return JSON.stringify(
-    GetPromptVersionContent$outboundSchema.parse(getPromptVersionContent),
+    GetPromptVersionMessagesPromptsContent$outboundSchema.parse(
+      getPromptVersionMessagesPromptsContent,
+    ),
   );
 }
-export function getPromptVersionContentFromJSON(
+export function getPromptVersionMessagesPromptsContentFromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersionContent, SDKValidationError> {
+): SafeParseResult<GetPromptVersionMessagesPromptsContent, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersionContent$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersionContent' from JSON`,
+    (x) =>
+      GetPromptVersionMessagesPromptsContent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionMessagesPromptsContent' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersionType$inboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionType
-> = z.nativeEnum(GetPromptVersionType);
-/** @internal */
-export const GetPromptVersionType$outboundSchema: z.ZodNativeEnum<
-  typeof GetPromptVersionType
-> = GetPromptVersionType$inboundSchema;
-
-/** @internal */
-export const GetPromptVersionFunction$inboundSchema: z.ZodType<
-  GetPromptVersionFunction,
+export const GetPromptVersionMessagesUserMessage$inboundSchema: z.ZodType<
+  GetPromptVersionMessagesUserMessage,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  name: z.string(),
-  arguments: z.string(),
+  role: z.literal("user"),
+  name: z.string().optional(),
+  content: z.union([
+    z.string(),
+    z.array(
+      z.union([
+        components.TextContentPartSchema$inboundSchema.and(
+          z.object({ type: z.literal("text") }),
+        ),
+        components.ImageContentPartSchema$inboundSchema,
+        components.AudioContentPartSchema$inboundSchema,
+        z.lazy(() => GetPromptVersion24$inboundSchema),
+      ]),
+    ),
+  ]),
 });
 /** @internal */
-export type GetPromptVersionFunction$Outbound = {
-  name: string;
-  arguments: string;
+export type GetPromptVersionMessagesUserMessage$Outbound = {
+  role: "user";
+  name?: string | undefined;
+  content:
+    | string
+    | Array<
+      | (components.TextContentPartSchema$Outbound & { type: "text" })
+      | components.ImageContentPartSchema$Outbound
+      | components.AudioContentPartSchema$Outbound
+      | GetPromptVersion24$Outbound
+    >;
 };
 
 /** @internal */
-export const GetPromptVersionFunction$outboundSchema: z.ZodType<
-  GetPromptVersionFunction$Outbound,
+export const GetPromptVersionMessagesUserMessage$outboundSchema: z.ZodType<
+  GetPromptVersionMessagesUserMessage$Outbound,
   z.ZodTypeDef,
-  GetPromptVersionFunction
+  GetPromptVersionMessagesUserMessage
 > = z.object({
-  name: z.string(),
-  arguments: z.string(),
+  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(() => GetPromptVersion24$outboundSchema),
+      ]),
+    ),
+  ]),
 });
 
-export function getPromptVersionFunctionToJSON(
-  getPromptVersionFunction: GetPromptVersionFunction,
+export function getPromptVersionMessagesUserMessageToJSON(
+  getPromptVersionMessagesUserMessage: GetPromptVersionMessagesUserMessage,
 ): string {
   return JSON.stringify(
-    GetPromptVersionFunction$outboundSchema.parse(getPromptVersionFunction),
+    GetPromptVersionMessagesUserMessage$outboundSchema.parse(
+      getPromptVersionMessagesUserMessage,
+    ),
   );
 }
-export function getPromptVersionFunctionFromJSON(
+export function getPromptVersionMessagesUserMessageFromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersionFunction, SDKValidationError> {
+): SafeParseResult<GetPromptVersionMessagesUserMessage, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersionFunction$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersionFunction' from JSON`,
+    (x) =>
+      GetPromptVersionMessagesUserMessage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionMessagesUserMessage' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersionToolCalls$inboundSchema: z.ZodType<
-  GetPromptVersionToolCalls,
+export const GetPromptVersionMessagesContent$inboundSchema: z.ZodType<
+  GetPromptVersionMessagesContent,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  id: z.string().optional(),
-  index: z.number().optional(),
-  type: GetPromptVersionType$inboundSchema,
-  function: z.lazy(() => GetPromptVersionFunction$inboundSchema),
-});
+> = z.union([
+  z.string(),
+  z.array(components.TextContentPartSchema$inboundSchema),
+]);
 /** @internal */
-export type GetPromptVersionToolCalls$Outbound = {
-  id?: string | undefined;
-  index?: number | undefined;
-  type: string;
-  function: GetPromptVersionFunction$Outbound;
-};
+export type GetPromptVersionMessagesContent$Outbound =
+  | string
+  | Array<components.TextContentPartSchema$Outbound>;
 
 /** @internal */
-export const GetPromptVersionToolCalls$outboundSchema: z.ZodType<
-  GetPromptVersionToolCalls$Outbound,
+export const GetPromptVersionMessagesContent$outboundSchema: z.ZodType<
+  GetPromptVersionMessagesContent$Outbound,
   z.ZodTypeDef,
-  GetPromptVersionToolCalls
-> = z.object({
-  id: z.string().optional(),
-  index: z.number().optional(),
-  type: GetPromptVersionType$outboundSchema,
-  function: z.lazy(() => GetPromptVersionFunction$outboundSchema),
-});
+  GetPromptVersionMessagesContent
+> = z.union([
+  z.string(),
+  z.array(components.TextContentPartSchema$outboundSchema),
+]);
 
-export function getPromptVersionToolCallsToJSON(
-  getPromptVersionToolCalls: GetPromptVersionToolCalls,
+export function getPromptVersionMessagesContentToJSON(
+  getPromptVersionMessagesContent: GetPromptVersionMessagesContent,
 ): string {
   return JSON.stringify(
-    GetPromptVersionToolCalls$outboundSchema.parse(getPromptVersionToolCalls),
+    GetPromptVersionMessagesContent$outboundSchema.parse(
+      getPromptVersionMessagesContent,
+    ),
   );
 }
-export function getPromptVersionToolCallsFromJSON(
+export function getPromptVersionMessagesContentFromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersionToolCalls, SDKValidationError> {
+): SafeParseResult<GetPromptVersionMessagesContent, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersionToolCalls$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersionToolCalls' from JSON`,
+    (x) => GetPromptVersionMessagesContent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionMessagesContent' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersionMessages$inboundSchema: z.ZodType<
-  GetPromptVersionMessages,
+export const GetPromptVersionMessagesSystemMessage$inboundSchema: z.ZodType<
+  GetPromptVersionMessagesSystemMessage,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  role: GetPromptVersionRole$inboundSchema,
-  content: z.nullable(
-    z.union([
-      z.string(),
-      z.array(
-        z.union([
-          z.lazy(() => GetPromptVersion21$inboundSchema),
-          z.lazy(() => GetPromptVersion22$inboundSchema),
-          z.lazy(() => GetPromptVersion23$inboundSchema),
-        ]),
-      ),
-    ]),
-  ),
-  tool_calls: z.array(z.lazy(() => GetPromptVersionToolCalls$inboundSchema))
-    .optional(),
-  tool_call_id: z.nullable(z.string()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "tool_calls": "toolCalls",
-    "tool_call_id": "toolCallId",
-  });
+  role: z.literal("system"),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$inboundSchema),
+  ]),
+  name: z.string().optional(),
 });
 /** @internal */
-export type GetPromptVersionMessages$Outbound = {
-  role: string;
-  content:
-    | string
-    | Array<
-      | GetPromptVersion21$Outbound
-      | GetPromptVersion22$Outbound
-      | GetPromptVersion23$Outbound
-    >
-    | null;
-  tool_calls?: Array<GetPromptVersionToolCalls$Outbound> | undefined;
-  tool_call_id?: string | null | undefined;
+export type GetPromptVersionMessagesSystemMessage$Outbound = {
+  role: "system";
+  content: string | Array<components.TextContentPartSchema$Outbound>;
+  name?: string | undefined;
 };
 
 /** @internal */
-export const GetPromptVersionMessages$outboundSchema: z.ZodType<
-  GetPromptVersionMessages$Outbound,
+export const GetPromptVersionMessagesSystemMessage$outboundSchema: z.ZodType<
+  GetPromptVersionMessagesSystemMessage$Outbound,
   z.ZodTypeDef,
-  GetPromptVersionMessages
+  GetPromptVersionMessagesSystemMessage
 > = z.object({
-  role: GetPromptVersionRole$outboundSchema,
-  content: z.nullable(
-    z.union([
-      z.string(),
-      z.array(
-        z.union([
-          z.lazy(() => GetPromptVersion21$outboundSchema),
-          z.lazy(() => GetPromptVersion22$outboundSchema),
-          z.lazy(() => GetPromptVersion23$outboundSchema),
-        ]),
-      ),
-    ]),
-  ),
-  toolCalls: z.array(z.lazy(() => GetPromptVersionToolCalls$outboundSchema))
-    .optional(),
-  toolCallId: z.nullable(z.string()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    toolCalls: "tool_calls",
-    toolCallId: "tool_call_id",
-  });
+  role: z.literal("system"),
+  content: z.union([
+    z.string(),
+    z.array(components.TextContentPartSchema$outboundSchema),
+  ]),
+  name: z.string().optional(),
 });
 
-export function getPromptVersionMessagesToJSON(
-  getPromptVersionMessages: GetPromptVersionMessages,
+export function getPromptVersionMessagesSystemMessageToJSON(
+  getPromptVersionMessagesSystemMessage: GetPromptVersionMessagesSystemMessage,
 ): string {
   return JSON.stringify(
-    GetPromptVersionMessages$outboundSchema.parse(getPromptVersionMessages),
+    GetPromptVersionMessagesSystemMessage$outboundSchema.parse(
+      getPromptVersionMessagesSystemMessage,
+    ),
   );
 }
-export function getPromptVersionMessagesFromJSON(
+export function getPromptVersionMessagesSystemMessageFromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersionMessages, SDKValidationError> {
+): SafeParseResult<GetPromptVersionMessagesSystemMessage, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersionMessages$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersionMessages' from JSON`,
+    (x) =>
+      GetPromptVersionMessagesSystemMessage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionMessagesSystemMessage' from JSON`,
   );
 }
 
 /** @internal */
-export const GetPromptVersionPromptConfig$inboundSchema: z.ZodType<
-  GetPromptVersionPromptConfig,
+export const GetPromptVersionPromptsMessages$inboundSchema: z.ZodType<
+  GetPromptVersionPromptsMessages,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => GetPromptVersionMessagesSystemMessage$inboundSchema),
+  z.lazy(() => GetPromptVersionMessagesUserMessage$inboundSchema),
+  z.lazy(() => GetPromptVersionMessagesAssistantMessage$inboundSchema),
+  z.lazy(() => GetPromptVersionMessagesToolMessage$inboundSchema),
+]);
+/** @internal */
+export type GetPromptVersionPromptsMessages$Outbound =
+  | GetPromptVersionMessagesSystemMessage$Outbound
+  | GetPromptVersionMessagesUserMessage$Outbound
+  | GetPromptVersionMessagesAssistantMessage$Outbound
+  | GetPromptVersionMessagesToolMessage$Outbound;
+
+/** @internal */
+export const GetPromptVersionPromptsMessages$outboundSchema: z.ZodType<
+  GetPromptVersionPromptsMessages$Outbound,
+  z.ZodTypeDef,
+  GetPromptVersionPromptsMessages
+> = z.union([
+  z.lazy(() => GetPromptVersionMessagesSystemMessage$outboundSchema),
+  z.lazy(() => GetPromptVersionMessagesUserMessage$outboundSchema),
+  z.lazy(() => GetPromptVersionMessagesAssistantMessage$outboundSchema),
+  z.lazy(() => GetPromptVersionMessagesToolMessage$outboundSchema),
+]);
+
+export function getPromptVersionPromptsMessagesToJSON(
+  getPromptVersionPromptsMessages: GetPromptVersionPromptsMessages,
+): string {
+  return JSON.stringify(
+    GetPromptVersionPromptsMessages$outboundSchema.parse(
+      getPromptVersionPromptsMessages,
+    ),
+  );
+}
+export function getPromptVersionPromptsMessagesFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPromptVersionPromptsMessages, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPromptVersionPromptsMessages$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionPromptsMessages' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetPromptVersionPromptField$inboundSchema: z.ZodType<
+  GetPromptVersionPromptField,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  stream: z.boolean().optional(),
-  model: z.string().optional(),
-  model_db_id: z.nullable(z.string()).optional(),
-  model_type: z.nullable(GetPromptVersionModelType$inboundSchema).optional(),
-  model_parameters: z.lazy(() => GetPromptVersionModelParameters$inboundSchema)
+  audio: z.nullable(z.lazy(() => GetPromptVersionAudio$inboundSchema))
     .optional(),
-  provider: GetPromptVersionProvider$inboundSchema.optional(),
-  integration_id: z.nullable(z.string()).optional(),
+  frequency_penalty: z.nullable(z.number()).optional(),
+  max_tokens: z.nullable(z.number().int()).optional(),
+  max_completion_tokens: z.nullable(z.number().int()).optional(),
+  logprobs: z.nullable(z.boolean()).optional(),
+  top_logprobs: z.nullable(z.number().int()).optional(),
+  n: z.nullable(z.number().int()).optional(),
+  presence_penalty: z.nullable(z.number()).optional(),
+  response_format: z.union([
+    z.lazy(() => GetPromptVersionResponseFormatText$inboundSchema),
+    z.lazy(() => GetPromptVersionResponseFormatJSONObject$inboundSchema),
+    z.lazy(() => GetPromptVersionResponseFormatPromptsJSONSchema$inboundSchema),
+  ]).optional(),
+  reasoning_effort: GetPromptVersionReasoningEffort$inboundSchema.optional(),
+  verbosity: z.string().optional(),
+  seed: z.nullable(z.number()).optional(),
+  stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
+  stream_options: z.nullable(
+    z.lazy(() => GetPromptVersionStreamOptions$inboundSchema),
+  ).optional(),
+  thinking: z.union([
+    components.ThinkingConfigDisabledSchema$inboundSchema,
+    components.ThinkingConfigEnabledSchema$inboundSchema,
+  ]).optional(),
+  temperature: z.nullable(z.number()).optional(),
+  top_p: z.nullable(z.number()).optional(),
+  top_k: z.nullable(z.number()).optional(),
+  tool_choice: z.union([
+    z.lazy(() => GetPromptVersionToolChoice2$inboundSchema),
+    GetPromptVersionToolChoice1$inboundSchema,
+  ]).optional(),
+  parallel_tool_calls: z.boolean().optional(),
+  modalities: z.nullable(z.array(GetPromptVersionModalities$inboundSchema))
+    .optional(),
+  guardrails: z.array(z.lazy(() => GetPromptVersionGuardrails$inboundSchema))
+    .optional(),
+  messages: z.array(
+    z.union([
+      z.lazy(() => GetPromptVersionMessagesSystemMessage$inboundSchema),
+      z.lazy(() => GetPromptVersionMessagesUserMessage$inboundSchema),
+      z.lazy(() => GetPromptVersionMessagesAssistantMessage$inboundSchema),
+      z.lazy(() => GetPromptVersionMessagesToolMessage$inboundSchema),
+    ]),
+  ).optional(),
+  model: z.nullable(z.string()).optional(),
   version: z.string().optional(),
-  messages: z.array(z.lazy(() => GetPromptVersionMessages$inboundSchema)),
 }).transform((v) => {
   return remap$(v, {
-    "model_db_id": "modelDbId",
-    "model_type": "modelType",
-    "model_parameters": "modelParameters",
-    "integration_id": "integrationId",
+    "frequency_penalty": "frequencyPenalty",
+    "max_tokens": "maxTokens",
+    "max_completion_tokens": "maxCompletionTokens",
+    "top_logprobs": "topLogprobs",
+    "presence_penalty": "presencePenalty",
+    "response_format": "responseFormat",
+    "reasoning_effort": "reasoningEffort",
+    "stream_options": "streamOptions",
+    "top_p": "topP",
+    "top_k": "topK",
+    "tool_choice": "toolChoice",
+    "parallel_tool_calls": "parallelToolCalls",
   });
 });
 /** @internal */
-export type GetPromptVersionPromptConfig$Outbound = {
-  stream?: boolean | undefined;
-  model?: string | undefined;
-  model_db_id?: string | null | undefined;
-  model_type?: string | null | undefined;
-  model_parameters?: GetPromptVersionModelParameters$Outbound | undefined;
-  provider?: string | undefined;
-  integration_id?: string | null | undefined;
+export type GetPromptVersionPromptField$Outbound = {
+  audio?: GetPromptVersionAudio$Outbound | null | undefined;
+  frequency_penalty?: number | null | undefined;
+  max_tokens?: number | null | undefined;
+  max_completion_tokens?: number | null | undefined;
+  logprobs?: boolean | null | undefined;
+  top_logprobs?: number | null | undefined;
+  n?: number | null | undefined;
+  presence_penalty?: number | null | undefined;
+  response_format?:
+    | GetPromptVersionResponseFormatText$Outbound
+    | GetPromptVersionResponseFormatJSONObject$Outbound
+    | GetPromptVersionResponseFormatPromptsJSONSchema$Outbound
+    | undefined;
+  reasoning_effort?: string | undefined;
+  verbosity?: string | undefined;
+  seed?: number | null | undefined;
+  stop?: string | Array<string> | null | undefined;
+  stream_options?: GetPromptVersionStreamOptions$Outbound | null | undefined;
+  thinking?:
+    | components.ThinkingConfigDisabledSchema$Outbound
+    | components.ThinkingConfigEnabledSchema$Outbound
+    | undefined;
+  temperature?: number | null | undefined;
+  top_p?: number | null | undefined;
+  top_k?: number | null | undefined;
+  tool_choice?: GetPromptVersionToolChoice2$Outbound | string | undefined;
+  parallel_tool_calls?: boolean | undefined;
+  modalities?: Array<string> | null | undefined;
+  guardrails?: Array<GetPromptVersionGuardrails$Outbound> | undefined;
+  messages?:
+    | Array<
+      | GetPromptVersionMessagesSystemMessage$Outbound
+      | GetPromptVersionMessagesUserMessage$Outbound
+      | GetPromptVersionMessagesAssistantMessage$Outbound
+      | GetPromptVersionMessagesToolMessage$Outbound
+    >
+    | undefined;
+  model?: string | null | undefined;
   version?: string | undefined;
-  messages: Array<GetPromptVersionMessages$Outbound>;
 };
 
 /** @internal */
-export const GetPromptVersionPromptConfig$outboundSchema: z.ZodType<
-  GetPromptVersionPromptConfig$Outbound,
+export const GetPromptVersionPromptField$outboundSchema: z.ZodType<
+  GetPromptVersionPromptField$Outbound,
   z.ZodTypeDef,
-  GetPromptVersionPromptConfig
+  GetPromptVersionPromptField
 > = z.object({
-  stream: z.boolean().optional(),
-  model: z.string().optional(),
-  modelDbId: z.nullable(z.string()).optional(),
-  modelType: z.nullable(GetPromptVersionModelType$outboundSchema).optional(),
-  modelParameters: z.lazy(() => GetPromptVersionModelParameters$outboundSchema)
+  audio: z.nullable(z.lazy(() => GetPromptVersionAudio$outboundSchema))
     .optional(),
-  provider: GetPromptVersionProvider$outboundSchema.optional(),
-  integrationId: z.nullable(z.string()).optional(),
+  frequencyPenalty: z.nullable(z.number()).optional(),
+  maxTokens: z.nullable(z.number().int()).optional(),
+  maxCompletionTokens: z.nullable(z.number().int()).optional(),
+  logprobs: z.nullable(z.boolean()).optional(),
+  topLogprobs: z.nullable(z.number().int()).optional(),
+  n: z.nullable(z.number().int()).optional(),
+  presencePenalty: z.nullable(z.number()).optional(),
+  responseFormat: z.union([
+    z.lazy(() => GetPromptVersionResponseFormatText$outboundSchema),
+    z.lazy(() => GetPromptVersionResponseFormatJSONObject$outboundSchema),
+    z.lazy(() =>
+      GetPromptVersionResponseFormatPromptsJSONSchema$outboundSchema
+    ),
+  ]).optional(),
+  reasoningEffort: GetPromptVersionReasoningEffort$outboundSchema.optional(),
+  verbosity: z.string().optional(),
+  seed: z.nullable(z.number()).optional(),
+  stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
+  streamOptions: z.nullable(
+    z.lazy(() => GetPromptVersionStreamOptions$outboundSchema),
+  ).optional(),
+  thinking: z.union([
+    components.ThinkingConfigDisabledSchema$outboundSchema,
+    components.ThinkingConfigEnabledSchema$outboundSchema,
+  ]).optional(),
+  temperature: z.nullable(z.number()).optional(),
+  topP: z.nullable(z.number()).optional(),
+  topK: z.nullable(z.number()).optional(),
+  toolChoice: z.union([
+    z.lazy(() => GetPromptVersionToolChoice2$outboundSchema),
+    GetPromptVersionToolChoice1$outboundSchema,
+  ]).optional(),
+  parallelToolCalls: z.boolean().optional(),
+  modalities: z.nullable(z.array(GetPromptVersionModalities$outboundSchema))
+    .optional(),
+  guardrails: z.array(z.lazy(() => GetPromptVersionGuardrails$outboundSchema))
+    .optional(),
+  messages: z.array(
+    z.union([
+      z.lazy(() => GetPromptVersionMessagesSystemMessage$outboundSchema),
+      z.lazy(() => GetPromptVersionMessagesUserMessage$outboundSchema),
+      z.lazy(() => GetPromptVersionMessagesAssistantMessage$outboundSchema),
+      z.lazy(() => GetPromptVersionMessagesToolMessage$outboundSchema),
+    ]),
+  ).optional(),
+  model: z.nullable(z.string()).optional(),
   version: z.string().optional(),
-  messages: z.array(z.lazy(() => GetPromptVersionMessages$outboundSchema)),
 }).transform((v) => {
   return remap$(v, {
-    modelDbId: "model_db_id",
-    modelType: "model_type",
-    modelParameters: "model_parameters",
-    integrationId: "integration_id",
+    frequencyPenalty: "frequency_penalty",
+    maxTokens: "max_tokens",
+    maxCompletionTokens: "max_completion_tokens",
+    topLogprobs: "top_logprobs",
+    presencePenalty: "presence_penalty",
+    responseFormat: "response_format",
+    reasoningEffort: "reasoning_effort",
+    streamOptions: "stream_options",
+    topP: "top_p",
+    topK: "top_k",
+    toolChoice: "tool_choice",
+    parallelToolCalls: "parallel_tool_calls",
   });
 });
 
-export function getPromptVersionPromptConfigToJSON(
-  getPromptVersionPromptConfig: GetPromptVersionPromptConfig,
+export function getPromptVersionPromptFieldToJSON(
+  getPromptVersionPromptField: GetPromptVersionPromptField,
 ): string {
   return JSON.stringify(
-    GetPromptVersionPromptConfig$outboundSchema.parse(
-      getPromptVersionPromptConfig,
+    GetPromptVersionPromptField$outboundSchema.parse(
+      getPromptVersionPromptField,
     ),
   );
 }
-export function getPromptVersionPromptConfigFromJSON(
+export function getPromptVersionPromptFieldFromJSON(
   jsonString: string,
-): SafeParseResult<GetPromptVersionPromptConfig, SDKValidationError> {
+): SafeParseResult<GetPromptVersionPromptField, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetPromptVersionPromptConfig$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetPromptVersionPromptConfig' from JSON`,
+    (x) => GetPromptVersionPromptField$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPromptVersionPromptField' from JSON`,
   );
 }
 
@@ -1828,7 +4567,9 @@ export const GetPromptVersionResponseBody$inboundSchema: z.ZodType<
   created_by_id: z.nullable(z.string()).optional(),
   updated_by_id: z.nullable(z.string()).optional(),
   description: z.nullable(z.string()).optional(),
-  prompt_config: z.lazy(() => GetPromptVersionPromptConfig$inboundSchema),
+  prompt_config: z.lazy(() => GetPromptVersionPromptConfig$inboundSchema)
+    .optional(),
+  prompt: z.lazy(() => GetPromptVersionPromptField$inboundSchema),
   metadata: z.lazy(() => GetPromptVersionMetadata$inboundSchema).optional(),
   timestamp: z.string(),
 }).transform((v) => {
@@ -1845,7 +4586,8 @@ export type GetPromptVersionResponseBody$Outbound = {
   created_by_id?: string | null | undefined;
   updated_by_id?: string | null | undefined;
   description?: string | null | undefined;
-  prompt_config: GetPromptVersionPromptConfig$Outbound;
+  prompt_config?: GetPromptVersionPromptConfig$Outbound | undefined;
+  prompt: GetPromptVersionPromptField$Outbound;
   metadata?: GetPromptVersionMetadata$Outbound | undefined;
   timestamp: string;
 };
@@ -1860,7 +4602,9 @@ export const GetPromptVersionResponseBody$outboundSchema: z.ZodType<
   createdById: z.nullable(z.string()).optional(),
   updatedById: z.nullable(z.string()).optional(),
   description: z.nullable(z.string()).optional(),
-  promptConfig: z.lazy(() => GetPromptVersionPromptConfig$outboundSchema),
+  promptConfig: z.lazy(() => GetPromptVersionPromptConfig$outboundSchema)
+    .optional(),
+  prompt: z.lazy(() => GetPromptVersionPromptField$outboundSchema),
   metadata: z.lazy(() => GetPromptVersionMetadata$outboundSchema).optional(),
   timestamp: z.string(),
 }).transform((v) => {