orq-ai-sdk 4.2.0rc28__py3-none-any.whl → 4.2.6__py3-none-any.whl

orq_ai_sdk/models/getallpromptsop.py

@@ -1,6 +1,30 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .audiocontentpartschema import (
+    AudioContentPartSchema,
+    AudioContentPartSchemaTypedDict,
+)
+from .filecontentpartschema import FileContentPartSchema, FileContentPartSchemaTypedDict
+from .imagecontentpartschema import (
+    ImageContentPartSchema,
+    ImageContentPartSchemaTypedDict,
+)
+from .reasoningpartschema import ReasoningPartSchema, ReasoningPartSchemaTypedDict
+from .redactedreasoningpartschema import (
+    RedactedReasoningPartSchema,
+    RedactedReasoningPartSchemaTypedDict,
+)
+from .refusalpartschema import RefusalPartSchema, RefusalPartSchemaTypedDict
+from .textcontentpartschema import TextContentPartSchema, TextContentPartSchemaTypedDict
+from .thinkingconfigdisabledschema import (
+    ThinkingConfigDisabledSchema,
+    ThinkingConfigDisabledSchemaTypedDict,
+)
+from .thinkingconfigenabledschema import (
+    ThinkingConfigEnabledSchema,
+    ThinkingConfigEnabledSchemaTypedDict,
+)
 from orq_ai_sdk.types import (
     BaseModel,
     Nullable,
@@ -12,7 +36,13 @@ from orq_ai_sdk.utils import FieldMetadata, QueryParamMetadata, get_discriminato
 import pydantic
 from pydantic import Discriminator, Tag, model_serializer
 from typing import Any, Dict, List, Literal, Optional, Union
-from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+from typing_extensions import (
+    Annotated,
+    NotRequired,
+    TypeAliasType,
+    TypedDict,
+    deprecated,
+)
 
 
 class GetAllPromptsRequestTypedDict(TypedDict):
@@ -43,6 +73,22 @@ class GetAllPromptsRequest(BaseModel):
     ] = None
     r"""A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 20 objects, starting with `01JJ1HDHN79XAS7A01WB3HYSDB`, your subsequent call can include `before=01JJ1HDHN79XAS7A01WB3HYSDB` in order to fetch the previous page of the list."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["limit", "starting_after", "ending_before"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 GetAllPromptsObject = Literal["list",]
 
@@ -58,6 +104,7 @@ GetAllPromptsModelType = Literal[
     "tts",
     "stt",
     "rerank",
+    "ocr",
     "moderation",
     "vision",
 ]
@@ -98,39 +145,43 @@ GetAllPromptsResponseFormat4 = Literal[
 ]
 
 
-GetAllPromptsResponseFormatPromptsResponseType = Literal["text",]
+GetAllPromptsResponseFormatPromptsResponse200ApplicationJSONResponseBodyType = Literal[
+    "text",
+]
 
 
 class GetAllPromptsResponseFormat3TypedDict(TypedDict):
-    type: GetAllPromptsResponseFormatPromptsResponseType
+    type: GetAllPromptsResponseFormatPromptsResponse200ApplicationJSONResponseBodyType
 
 
 class GetAllPromptsResponseFormat3(BaseModel):
-    type: GetAllPromptsResponseFormatPromptsResponseType
+    type: GetAllPromptsResponseFormatPromptsResponse200ApplicationJSONResponseBodyType
 
 
-GetAllPromptsResponseFormatPromptsType = Literal["json_object",]
+GetAllPromptsResponseFormatPromptsResponse200ApplicationJSONType = Literal[
+    "json_object",
+]
 
 
 class GetAllPromptsResponseFormat2TypedDict(TypedDict):
-    type: GetAllPromptsResponseFormatPromptsType
+    type: GetAllPromptsResponseFormatPromptsResponse200ApplicationJSONType
 
 
 class GetAllPromptsResponseFormat2(BaseModel):
-    type: GetAllPromptsResponseFormatPromptsType
+    type: GetAllPromptsResponseFormatPromptsResponse200ApplicationJSONType
 
 
-GetAllPromptsResponseFormatType = Literal["json_schema",]
+GetAllPromptsResponseFormatPromptsResponse200Type = Literal["json_schema",]
 
 
-class GetAllPromptsResponseFormatJSONSchemaTypedDict(TypedDict):
+class GetAllPromptsResponseFormatPromptsResponseJSONSchemaTypedDict(TypedDict):
     name: str
     schema_: Dict[str, Any]
     description: NotRequired[str]
     strict: NotRequired[bool]
 
 
-class GetAllPromptsResponseFormatJSONSchema(BaseModel):
+class GetAllPromptsResponseFormatPromptsResponseJSONSchema(BaseModel):
     name: str
 
     schema_: Annotated[Dict[str, Any], pydantic.Field(alias="schema")]
@@ -139,23 +190,55 @@ class GetAllPromptsResponseFormatJSONSchema(BaseModel):
 
     strict: Optional[bool] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["description", "strict"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class GetAllPromptsResponseFormat1TypedDict(TypedDict):
-    type: GetAllPromptsResponseFormatType
-    json_schema: GetAllPromptsResponseFormatJSONSchemaTypedDict
+    type: GetAllPromptsResponseFormatPromptsResponse200Type
+    json_schema: GetAllPromptsResponseFormatPromptsResponseJSONSchemaTypedDict
     display_name: NotRequired[str]
 
 
 class GetAllPromptsResponseFormat1(BaseModel):
-    type: GetAllPromptsResponseFormatType
+    type: GetAllPromptsResponseFormatPromptsResponse200Type
 
-    json_schema: GetAllPromptsResponseFormatJSONSchema
+    json_schema: GetAllPromptsResponseFormatPromptsResponseJSONSchema
 
     display_name: Optional[str] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["display_name"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
-GetAllPromptsResponseFormatTypedDict = TypeAliasType(
-    "GetAllPromptsResponseFormatTypedDict",
+        return m
+
+
+GetAllPromptsPromptsResponseFormatTypedDict = TypeAliasType(
+    "GetAllPromptsPromptsResponseFormatTypedDict",
     Union[
         GetAllPromptsResponseFormat2TypedDict,
         GetAllPromptsResponseFormat3TypedDict,
@@ -175,8 +258,8 @@ Important: when using JSON mode, you must also instruct the model to produce JSO
 """
 
 
-GetAllPromptsResponseFormat = TypeAliasType(
-    "GetAllPromptsResponseFormat",
+GetAllPromptsPromptsResponseFormat = TypeAliasType(
+    "GetAllPromptsPromptsResponseFormat",
     Union[
         GetAllPromptsResponseFormat2,
         GetAllPromptsResponseFormat3,
@@ -210,7 +293,7 @@ GetAllPromptsEncodingFormat = Literal[
 r"""The format to return the embeddings"""
 
 
-GetAllPromptsReasoningEffort = Literal[
+GetAllPromptsPromptsReasoningEffort = Literal[
     "none",
     "disable",
     "minimal",
@@ -263,7 +346,7 @@ class GetAllPromptsModelParametersTypedDict(TypedDict):
     r"""Only supported on `image` models."""
     style: NotRequired[str]
     r"""Only supported on `image` models."""
-    response_format: NotRequired[Nullable[GetAllPromptsResponseFormatTypedDict]]
+    response_format: NotRequired[Nullable[GetAllPromptsPromptsResponseFormatTypedDict]]
     r"""An object specifying the format that the model must output.
 
     Setting to `{ \"type\": \"json_schema\", \"json_schema\": {...} }` enables Structured Outputs which ensures the model will match your supplied JSON schema
@@ -276,7 +359,7 @@ class GetAllPromptsModelParametersTypedDict(TypedDict):
     r"""The version of photoReal to use. Must be v1 or v2. Only available for `leonardoai` provider"""
     encoding_format: NotRequired[GetAllPromptsEncodingFormat]
     r"""The format to return the embeddings"""
-    reasoning_effort: NotRequired[GetAllPromptsReasoningEffort]
+    reasoning_effort: NotRequired[GetAllPromptsPromptsReasoningEffort]
     r"""Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response."""
     budget_tokens: NotRequired[float]
     r"""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`"""
@@ -332,7 +415,7 @@ class GetAllPromptsModelParameters(BaseModel):
     r"""Only supported on `image` models."""
 
     response_format: Annotated[
-        OptionalNullable[GetAllPromptsResponseFormat],
+        OptionalNullable[GetAllPromptsPromptsResponseFormat],
         pydantic.Field(alias="responseFormat"),
     ] = UNSET
     r"""An object specifying the format that the model must output.
@@ -354,7 +437,8 @@ class GetAllPromptsModelParameters(BaseModel):
     r"""The format to return the embeddings"""
 
     reasoning_effort: Annotated[
-        Optional[GetAllPromptsReasoningEffort], pydantic.Field(alias="reasoningEffort")
+        Optional[GetAllPromptsPromptsReasoningEffort],
+        pydantic.Field(alias="reasoningEffort"),
     ] = None
     r"""Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response."""
 
@@ -373,51 +457,48 @@ class GetAllPromptsModelParameters(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "temperature",
-            "maxTokens",
-            "topK",
-            "topP",
-            "frequencyPenalty",
-            "presencePenalty",
-            "numImages",
-            "seed",
-            "format",
-            "dimensions",
-            "quality",
-            "style",
-            "responseFormat",
-            "photoRealVersion",
-            "encoding_format",
-            "reasoningEffort",
-            "budgetTokens",
-            "verbosity",
-            "thinkingLevel",
-        ]
-        nullable_fields = ["responseFormat"]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "temperature",
+                "maxTokens",
+                "topK",
+                "topP",
+                "frequencyPenalty",
+                "presencePenalty",
+                "numImages",
+                "seed",
+                "format",
+                "dimensions",
+                "quality",
+                "style",
+                "responseFormat",
+                "photoRealVersion",
+                "encoding_format",
+                "reasoningEffort",
+                "budgetTokens",
+                "verbosity",
+                "thinkingLevel",
+            ]
+        )
+        nullable_fields = set(["responseFormat"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m
 
@@ -493,6 +574,22 @@ class GetAllPrompts2File(BaseModel):
     filename: Optional[str] = None
     r"""The name of the file, used when passing the file to the model as a string."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["file_data", "uri", "mimeType", "filename"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class GetAllPrompts23TypedDict(TypedDict):
     type: GetAllPrompts2PromptsResponseType
@@ -529,6 +626,22 @@ class GetAllPrompts2ImageURL(BaseModel):
     detail: Optional[str] = None
     r"""Specifies the detail level of the image. Currently only supported with OpenAI models"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["id", "detail"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class GetAllPrompts22TypedDict(TypedDict):
     r"""The image part of the prompt message. Only supported with vision models."""
@@ -591,7 +704,7 @@ GetAllPromptsContent = TypeAliasType(
 r"""The contents of the user message. Either the text content of the message or an array of content parts with a defined type, each can be of type `text` or `image_url` when passing in images. You can pass multiple images by adding multiple `image_url` content parts. Can be null for tool messages in certain scenarios."""
 
 
-GetAllPromptsPromptsType = Literal["function",]
+GetAllPromptsPromptsResponseType = Literal["function",]
 
 
 class GetAllPromptsFunctionTypedDict(TypedDict):
@@ -608,14 +721,14 @@ class GetAllPromptsFunction(BaseModel):
 
 
 class GetAllPromptsToolCallsTypedDict(TypedDict):
-    type: GetAllPromptsPromptsType
+    type: GetAllPromptsPromptsResponseType
     function: GetAllPromptsFunctionTypedDict
     id: NotRequired[str]
     index: NotRequired[float]
 
 
 class GetAllPromptsToolCalls(BaseModel):
-    type: GetAllPromptsPromptsType
+    type: GetAllPromptsPromptsResponseType
 
     function: GetAllPromptsFunction
 
@@ -623,6 +736,22 @@ class GetAllPromptsToolCalls(BaseModel):
 
     index: Optional[float] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["id", "index"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class GetAllPromptsMessagesTypedDict(TypedDict):
     role: GetAllPromptsRole
@@ -646,61 +775,62 @@ class GetAllPromptsMessages(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["tool_calls", "tool_call_id"]
-        nullable_fields = ["content", "tool_call_id"]
-        null_default_fields = []
-
+        optional_fields = set(["tool_calls", "tool_call_id"])
+        nullable_fields = set(["content", "tool_call_id"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m
 
 
+@deprecated(
+    "warning: ** DEPRECATED ** - This will be removed in a future release, please migrate away from it as soon as possible."
+)
 class GetAllPromptsPromptConfigTypedDict(TypedDict):
-    r"""A list of messages compatible with the openAI schema"""
+    r"""[DEPRECATED] Use the `prompt` property instead. A list of messages compatible with the openAI schema."""
 
     messages: List[GetAllPromptsMessagesTypedDict]
     stream: NotRequired[bool]
-    model: NotRequired[str]
+    model: NotRequired[Nullable[str]]
     model_db_id: NotRequired[Nullable[str]]
     r"""The id of the resource"""
     model_type: NotRequired[Nullable[GetAllPromptsModelType]]
     r"""The modality of the model"""
     model_parameters: NotRequired[GetAllPromptsModelParametersTypedDict]
     r"""Model Parameters: Not all parameters apply to every model"""
-    provider: NotRequired[GetAllPromptsProvider]
+    provider: NotRequired[Nullable[GetAllPromptsProvider]]
     integration_id: NotRequired[Nullable[str]]
     r"""The ID of the integration to use"""
     version: NotRequired[str]
 
 
+@deprecated(
+    "warning: ** DEPRECATED ** - This will be removed in a future release, please migrate away from it as soon as possible."
+)
 class GetAllPromptsPromptConfig(BaseModel):
-    r"""A list of messages compatible with the openAI schema"""
+    r"""[DEPRECATED] Use the `prompt` property instead. A list of messages compatible with the openAI schema."""
 
     messages: List[GetAllPromptsMessages]
 
     stream: Optional[bool] = None
 
-    model: Optional[str] = None
+    model: OptionalNullable[str] = UNSET
 
     model_db_id: OptionalNullable[str] = UNSET
     r"""The id of the resource"""
@@ -711,7 +841,7 @@ class GetAllPromptsPromptConfig(BaseModel):
     model_parameters: Optional[GetAllPromptsModelParameters] = None
     r"""Model Parameters: Not all parameters apply to every model"""
 
-    provider: Optional[GetAllPromptsProvider] = None
+    provider: OptionalNullable[GetAllPromptsProvider] = UNSET
 
     integration_id: OptionalNullable[str] = UNSET
     r"""The ID of the integration to use"""
@@ -720,202 +850,1532 @@ class GetAllPromptsPromptConfig(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "stream",
-            "model",
-            "model_db_id",
-            "model_type",
-            "model_parameters",
-            "provider",
-            "integration_id",
-            "version",
-        ]
-        nullable_fields = ["model_db_id", "model_type", "integration_id"]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "stream",
+                "model",
+                "model_db_id",
+                "model_type",
+                "model_parameters",
+                "provider",
+                "integration_id",
+                "version",
+            ]
+        )
+        nullable_fields = set(
+            ["model", "model_db_id", "model_type", "provider", "integration_id"]
+        )
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m
 
 
-GetAllPromptsUseCases = Literal[
-    "Agents simulations",
-    "Agents",
-    "API interaction",
-    "Autonomous Agents",
-    "Chatbots",
-    "Classification",
-    "Code understanding",
-    "Code writing",
-    "Conversation",
-    "Documents QA",
-    "Evaluation",
-    "Extraction",
-    "Multi-modal",
-    "Self-checking",
-    "Sentiment analysis",
-    "SQL",
-    "Summarization",
-    "Tagging",
-    "Translation (document)",
-    "Translation (sentences)",
+GetAllPromptsVoice = Literal[
+    "alloy",
+    "echo",
+    "fable",
+    "onyx",
+    "nova",
+    "shimmer",
 ]
+r"""The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer."""
 
 
-GetAllPromptsLanguage = Literal[
-    "Chinese",
-    "Dutch",
-    "English",
-    "French",
-    "German",
-    "Russian",
-    "Spanish",
+GetAllPromptsPromptsFormat = Literal[
+    "wav",
+    "mp3",
+    "flac",
+    "opus",
+    "pcm16",
 ]
-r"""The language that the prompt is written in. Use this field to categorize the prompt for your own purpose"""
+r"""Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16."""
 
 
-class GetAllPromptsMetadataTypedDict(TypedDict):
-    use_cases: NotRequired[List[GetAllPromptsUseCases]]
-    r"""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"""
-    language: NotRequired[Nullable[GetAllPromptsLanguage]]
-    r"""The language that the prompt is written in. Use this field to categorize the prompt for your own purpose"""
+class GetAllPromptsAudioTypedDict(TypedDict):
+    r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
+    voice: GetAllPromptsVoice
+    r"""The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer."""
+    format_: GetAllPromptsPromptsFormat
+    r"""Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16."""
 
-class GetAllPromptsMetadata(BaseModel):
-    use_cases: Optional[List[GetAllPromptsUseCases]] = None
-    r"""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"""
 
-    language: OptionalNullable[GetAllPromptsLanguage] = UNSET
-    r"""The language that the prompt is written in. Use this field to categorize the prompt for your own purpose"""
+class GetAllPromptsAudio(BaseModel):
+    r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
+
+    voice: GetAllPromptsVoice
+    r"""The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer."""
+
+    format_: Annotated[GetAllPromptsPromptsFormat, pydantic.Field(alias="format")]
+    r"""Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16."""
+
+
+GetAllPromptsResponseFormatPromptsResponseType = Literal["json_schema",]
+
+
+class GetAllPromptsResponseFormatJSONSchemaTypedDict(TypedDict):
+    name: str
+    r"""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."""
+    description: NotRequired[str]
+    r"""A description of what the response format is for, used by the model to determine how to respond in the format."""
+    schema_: NotRequired[Any]
+    r"""The schema for the response format, described as a JSON Schema object."""
+    strict: NotRequired[bool]
+    r"""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."""
+
+
+class GetAllPromptsResponseFormatJSONSchema(BaseModel):
+    name: str
+    r"""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."""
+
+    description: Optional[str] = None
+    r"""A description of what the response format is for, used by the model to determine how to respond in the format."""
+
+    schema_: Annotated[Optional[Any], pydantic.Field(alias="schema")] = None
+    r"""The schema for the response format, described as a JSON Schema object."""
+
+    strict: Optional[bool] = False
+    r"""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."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["use_cases", "language"]
-        nullable_fields = ["language"]
-        null_default_fields = []
-
+        optional_fields = set(["description", "schema", "strict"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
 
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
         return m
 
 
-class GetAllPromptsPromptTypedDict(TypedDict):
-    r"""A prompt entity with configuration, metadata, and versioning."""
+class GetAllPromptsResponseFormatPromptsJSONSchemaTypedDict(TypedDict):
+    r"""
 
-    id: str
-    type: GetAllPromptsType
-    owner: str
-    domain_id: str
-    created: str
-    updated: str
-    display_name: str
-    r"""The prompt’s name, meant to be displayable in the UI."""
-    prompt_config: GetAllPromptsPromptConfigTypedDict
-    r"""A list of messages compatible with the openAI schema"""
-    created_by_id: NotRequired[Nullable[str]]
-    updated_by_id: NotRequired[Nullable[str]]
-    description: NotRequired[Nullable[str]]
-    r"""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"""
-    metadata: NotRequired[GetAllPromptsMetadataTypedDict]
+    JSON Schema response format. Used to generate structured JSON responses
+    """
 
+    type: GetAllPromptsResponseFormatPromptsResponseType
+    json_schema: GetAllPromptsResponseFormatJSONSchemaTypedDict
 
-class GetAllPromptsPrompt(BaseModel):
-    r"""A prompt entity with configuration, metadata, and versioning."""
 
-    id: Annotated[str, pydantic.Field(alias="_id")]
+class GetAllPromptsResponseFormatPromptsJSONSchema(BaseModel):
+    r"""
 
-    type: GetAllPromptsType
+    JSON Schema response format. Used to generate structured JSON responses
+    """
 
-    owner: str
+    type: GetAllPromptsResponseFormatPromptsResponseType
 
-    domain_id: str
+    json_schema: GetAllPromptsResponseFormatJSONSchema
 
-    created: str
 
-    updated: str
+GetAllPromptsResponseFormatPromptsType = Literal["json_object",]
 
-    display_name: str
-    r"""The prompt’s name, meant to be displayable in the UI."""
 
-    prompt_config: GetAllPromptsPromptConfig
-    r"""A list of messages compatible with the openAI schema"""
+class GetAllPromptsResponseFormatJSONObjectTypedDict(TypedDict):
+    r"""
 
-    created_by_id: OptionalNullable[str] = UNSET
+    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.
+    """
 
-    updated_by_id: OptionalNullable[str] = UNSET
+    type: GetAllPromptsResponseFormatPromptsType
 
-    description: OptionalNullable[str] = UNSET
-    r"""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"""
 
-    metadata: Optional[GetAllPromptsMetadata] = None
+class GetAllPromptsResponseFormatJSONObject(BaseModel):
+    r"""
 
-    @model_serializer(mode="wrap")
-    def serialize_model(self, handler):
-        optional_fields = ["created_by_id", "updated_by_id", "description", "metadata"]
-        nullable_fields = ["created_by_id", "updated_by_id", "description"]
-        null_default_fields = []
+    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.
+    """
 
-        serialized = handler(self)
+    type: GetAllPromptsResponseFormatPromptsType
+
+
+GetAllPromptsResponseFormatType = Literal["text",]
 
+
+class GetAllPromptsResponseFormatTextTypedDict(TypedDict):
+    r"""
+
+    Default response format. Used to generate text responses
+    """
+
+    type: GetAllPromptsResponseFormatType
+
+
+class GetAllPromptsResponseFormatText(BaseModel):
+    r"""
+
+    Default response format. Used to generate text responses
+    """
+
+    type: GetAllPromptsResponseFormatType
+
+
+GetAllPromptsResponseFormatTypedDict = TypeAliasType(
+    "GetAllPromptsResponseFormatTypedDict",
+    Union[
+        GetAllPromptsResponseFormatTextTypedDict,
+        GetAllPromptsResponseFormatJSONObjectTypedDict,
+        GetAllPromptsResponseFormatPromptsJSONSchemaTypedDict,
+    ],
+)
+r"""An object specifying the format that the model must output"""
+
+
+GetAllPromptsResponseFormat = Annotated[
+    Union[
+        Annotated[GetAllPromptsResponseFormatText, Tag("text")],
+        Annotated[GetAllPromptsResponseFormatJSONObject, Tag("json_object")],
+        Annotated[GetAllPromptsResponseFormatPromptsJSONSchema, Tag("json_schema")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+r"""An object specifying the format that the model must output"""
+
+
+GetAllPromptsReasoningEffort = Literal[
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+]
+r"""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.
+
+- `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\".
+"""
+
+
+GetAllPromptsStopTypedDict = TypeAliasType(
+    "GetAllPromptsStopTypedDict", Union[str, List[str]]
+)
+r"""Up to 4 sequences where the API will stop generating further tokens."""
+
+
+GetAllPromptsStop = TypeAliasType("GetAllPromptsStop", Union[str, List[str]])
+r"""Up to 4 sequences where the API will stop generating further tokens."""
+
+
+class GetAllPromptsStreamOptionsTypedDict(TypedDict):
+    r"""Options for streaming response. Only set this when you set stream: true."""
+
+    include_usage: NotRequired[bool]
+    r"""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."""
+
+
+class GetAllPromptsStreamOptions(BaseModel):
+    r"""Options for streaming response. Only set this when you set stream: true."""
+
+    include_usage: Optional[bool] = None
+    r"""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."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["include_usage"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+GetAllPromptsThinkingTypedDict = TypeAliasType(
+    "GetAllPromptsThinkingTypedDict",
+    Union[ThinkingConfigDisabledSchemaTypedDict, ThinkingConfigEnabledSchemaTypedDict],
+)
+
+
+GetAllPromptsThinking = Annotated[
+    Union[
+        Annotated[ThinkingConfigDisabledSchema, Tag("disabled")],
+        Annotated[ThinkingConfigEnabledSchema, Tag("enabled")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+GetAllPromptsToolChoiceType = Literal["function",]
+r"""The type of the tool. Currently, only function is supported."""
+
+
+class GetAllPromptsToolChoiceFunctionTypedDict(TypedDict):
+    name: str
+    r"""The name of the function to call."""
+
+
+class GetAllPromptsToolChoiceFunction(BaseModel):
+    name: str
+    r"""The name of the function to call."""
+
+
+class GetAllPromptsToolChoice2TypedDict(TypedDict):
+    function: GetAllPromptsToolChoiceFunctionTypedDict
+    type: NotRequired[GetAllPromptsToolChoiceType]
+    r"""The type of the tool. Currently, only function is supported."""
+
+
+class GetAllPromptsToolChoice2(BaseModel):
+    function: GetAllPromptsToolChoiceFunction
+
+    type: Optional[GetAllPromptsToolChoiceType] = None
+    r"""The type of the tool. Currently, only function is supported."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["type"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+GetAllPromptsToolChoice1 = Literal[
+    "none",
+    "auto",
+    "required",
+]
+
+
+GetAllPromptsToolChoiceTypedDict = TypeAliasType(
+    "GetAllPromptsToolChoiceTypedDict",
+    Union[GetAllPromptsToolChoice2TypedDict, GetAllPromptsToolChoice1],
+)
+r"""Controls which (if any) tool is called by the model."""
+
+
+GetAllPromptsToolChoice = TypeAliasType(
+    "GetAllPromptsToolChoice", Union[GetAllPromptsToolChoice2, GetAllPromptsToolChoice1]
+)
+r"""Controls which (if any) tool is called by the model."""
+
+
+GetAllPromptsModalities = Literal[
+    "text",
+    "audio",
+]
+
+
+GetAllPromptsID1 = Literal[
+    "orq_pii_detection",
+    "orq_sexual_moderation",
+    "orq_harmful_moderation",
+]
+r"""The key of the guardrail."""
+
+
+GetAllPromptsIDTypedDict = TypeAliasType(
+    "GetAllPromptsIDTypedDict", Union[GetAllPromptsID1, str]
+)
+
+
+GetAllPromptsID = TypeAliasType("GetAllPromptsID", Union[GetAllPromptsID1, str])
+
+
+GetAllPromptsExecuteOn = Literal[
+    "input",
+    "output",
+]
+r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
+
+
+class GetAllPromptsGuardrailsTypedDict(TypedDict):
+    id: GetAllPromptsIDTypedDict
+    execute_on: GetAllPromptsExecuteOn
+    r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
+
+
+class GetAllPromptsGuardrails(BaseModel):
+    id: GetAllPromptsID
+
+    execute_on: GetAllPromptsExecuteOn
+    r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
+
+
+class GetAllPromptsFallbacksTypedDict(TypedDict):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class GetAllPromptsFallbacks(BaseModel):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class GetAllPromptsRetryTypedDict(TypedDict):
+    r"""Retry configuration for the request"""
+
+    count: NotRequired[float]
+    r"""Number of retry attempts (1-5)"""
+    on_codes: NotRequired[List[float]]
+    r"""HTTP status codes that trigger retry logic"""
+
+
+class GetAllPromptsRetry(BaseModel):
+    r"""Retry configuration for the request"""
+
+    count: Optional[float] = 3
+    r"""Number of retry attempts (1-5)"""
+
+    on_codes: Optional[List[float]] = None
+    r"""HTTP status codes that trigger retry logic"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["count", "on_codes"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+GetAllPromptsPromptsType = Literal["exact_match",]
+
+
+class GetAllPromptsCacheTypedDict(TypedDict):
+    r"""Cache configuration for the request."""
+
+    type: GetAllPromptsPromptsType
+    ttl: NotRequired[float]
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
+
+
+class GetAllPromptsCache(BaseModel):
+    r"""Cache configuration for the request."""
+
+    type: GetAllPromptsPromptsType
+
+    ttl: Optional[float] = 1800
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["ttl"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+GetAllPromptsLoadBalancerType = Literal["weight_based",]
+
+
+class GetAllPromptsLoadBalancerModelsTypedDict(TypedDict):
+    model: str
+    r"""Model identifier for load balancing"""
+    weight: NotRequired[float]
+    r"""Weight assigned to this model for load balancing"""
+
+
+class GetAllPromptsLoadBalancerModels(BaseModel):
+    model: str
+    r"""Model identifier for load balancing"""
+
+    weight: Optional[float] = 0.5
+    r"""Weight assigned to this model for load balancing"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["weight"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class GetAllPromptsLoadBalancer1TypedDict(TypedDict):
+    type: GetAllPromptsLoadBalancerType
+    models: List[GetAllPromptsLoadBalancerModelsTypedDict]
+
+
+class GetAllPromptsLoadBalancer1(BaseModel):
+    type: GetAllPromptsLoadBalancerType
+
+    models: List[GetAllPromptsLoadBalancerModels]
+
+
+GetAllPromptsLoadBalancerTypedDict = GetAllPromptsLoadBalancer1TypedDict
+r"""Load balancer configuration for the request."""
+
+
+GetAllPromptsLoadBalancer = GetAllPromptsLoadBalancer1
+r"""Load balancer configuration for the request."""
+
+
+class GetAllPromptsTimeoutTypedDict(TypedDict):
+    r"""Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured."""
+
+    call_timeout: float
+    r"""Timeout value in milliseconds"""
+
+
+class GetAllPromptsTimeout(BaseModel):
+    r"""Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured."""
+
+    call_timeout: float
+    r"""Timeout value in milliseconds"""
+
+
+GetAllPromptsMessagesPromptsResponse200Role = Literal["tool",]
+r"""The role of the messages author, in this case tool."""
+
+
+GetAllPromptsContentPromptsResponse2002TypedDict = TextContentPartSchemaTypedDict
+
+
+GetAllPromptsContentPromptsResponse2002 = TextContentPartSchema
+
+
+GetAllPromptsMessagesPromptsResponse200ContentTypedDict = TypeAliasType(
+    "GetAllPromptsMessagesPromptsResponse200ContentTypedDict",
+    Union[str, List[GetAllPromptsContentPromptsResponse2002TypedDict]],
+)
+r"""The contents of the tool message."""
+
+
+GetAllPromptsMessagesPromptsResponse200Content = TypeAliasType(
+    "GetAllPromptsMessagesPromptsResponse200Content",
+    Union[str, List[GetAllPromptsContentPromptsResponse2002]],
+)
+r"""The contents of the tool message."""
+
+
+GetAllPromptsMessagesPromptsType = Literal["ephemeral",]
+r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+
+
+GetAllPromptsMessagesTTL = Literal[
+    "5m",
+    "1h",
+]
+r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+
+- `5m`: 5 minutes
+- `1h`: 1 hour
+
+Defaults to `5m`. Only supported by `Anthropic` Claude models.
+"""
+
+
+class GetAllPromptsMessagesCacheControlTypedDict(TypedDict):
+    type: GetAllPromptsMessagesPromptsType
+    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+    ttl: NotRequired[GetAllPromptsMessagesTTL]
+    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+
+    - `5m`: 5 minutes
+    - `1h`: 1 hour
+
+    Defaults to `5m`. Only supported by `Anthropic` Claude models.
+    """
+
+
+class GetAllPromptsMessagesCacheControl(BaseModel):
+    type: GetAllPromptsMessagesPromptsType
+    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+
+    ttl: Optional[GetAllPromptsMessagesTTL] = "5m"
+    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+
+    - `5m`: 5 minutes
+    - `1h`: 1 hour
+
+    Defaults to `5m`. Only supported by `Anthropic` Claude models.
+    """
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["ttl"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class GetAllPromptsMessagesToolMessageTypedDict(TypedDict):
+    role: GetAllPromptsMessagesPromptsResponse200Role
+    r"""The role of the messages author, in this case tool."""
+    content: GetAllPromptsMessagesPromptsResponse200ContentTypedDict
+    r"""The contents of the tool message."""
+    tool_call_id: Nullable[str]
+    r"""Tool call that this message is responding to."""
+    cache_control: NotRequired[GetAllPromptsMessagesCacheControlTypedDict]
+
+
+class GetAllPromptsMessagesToolMessage(BaseModel):
+    role: GetAllPromptsMessagesPromptsResponse200Role
+    r"""The role of the messages author, in this case tool."""
+
+    content: GetAllPromptsMessagesPromptsResponse200Content
+    r"""The contents of the tool message."""
+
+    tool_call_id: Nullable[str]
+    r"""Tool call that this message is responding to."""
+
+    cache_control: Optional[GetAllPromptsMessagesCacheControl] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["cache_control"])
+        nullable_fields = set(["tool_call_id"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+GetAllPromptsContentPromptsResponse2TypedDict = TypeAliasType(
+    "GetAllPromptsContentPromptsResponse2TypedDict",
+    Union[
+        RefusalPartSchemaTypedDict,
+        RedactedReasoningPartSchemaTypedDict,
+        TextContentPartSchemaTypedDict,
+        ReasoningPartSchemaTypedDict,
+    ],
+)
+
+
+GetAllPromptsContentPromptsResponse2 = Annotated[
+    Union[
+        Annotated[TextContentPartSchema, Tag("text")],
+        Annotated[RefusalPartSchema, Tag("refusal")],
+        Annotated[ReasoningPartSchema, Tag("reasoning")],
+        Annotated[RedactedReasoningPartSchema, Tag("redacted_reasoning")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+GetAllPromptsMessagesPromptsResponseContentTypedDict = TypeAliasType(
+    "GetAllPromptsMessagesPromptsResponseContentTypedDict",
+    Union[str, List[GetAllPromptsContentPromptsResponse2TypedDict]],
+)
+r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
+
+
+GetAllPromptsMessagesPromptsResponseContent = TypeAliasType(
+    "GetAllPromptsMessagesPromptsResponseContent",
+    Union[str, List[GetAllPromptsContentPromptsResponse2]],
+)
+r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
+
+
+GetAllPromptsMessagesPromptsResponseRole = Literal["assistant",]
+r"""The role of the messages author, in this case `assistant`."""
+
+
+class GetAllPromptsMessagesAudioTypedDict(TypedDict):
+    r"""Data about a previous audio response from the model."""
+
+    id: str
+    r"""Unique identifier for a previous audio response from the model."""
+
+
+class GetAllPromptsMessagesAudio(BaseModel):
+    r"""Data about a previous audio response from the model."""
+
+    id: str
+    r"""Unique identifier for a previous audio response from the model."""
+
+
+GetAllPromptsMessagesType = Literal["function",]
+r"""The type of the tool. Currently, only `function` is supported."""
+
+
+class GetAllPromptsMessagesFunctionTypedDict(TypedDict):
+    name: NotRequired[str]
+    r"""The name of the function to call."""
+    arguments: NotRequired[str]
+    r"""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."""
+
+
+class GetAllPromptsMessagesFunction(BaseModel):
+    name: Optional[str] = None
+    r"""The name of the function to call."""
+
+    arguments: Optional[str] = None
+    r"""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."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["name", "arguments"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class GetAllPromptsMessagesToolCallsTypedDict(TypedDict):
+    id: str
+    r"""The ID of the tool call."""
+    type: GetAllPromptsMessagesType
+    r"""The type of the tool. Currently, only `function` is supported."""
+    function: GetAllPromptsMessagesFunctionTypedDict
+    thought_signature: NotRequired[str]
+    r"""Encrypted representation of the model internal reasoning state during function calling. Required by Gemini 3 models when continuing a conversation after a tool call."""
+
+
+class GetAllPromptsMessagesToolCalls(BaseModel):
+    id: str
+    r"""The ID of the tool call."""
+
+    type: GetAllPromptsMessagesType
+    r"""The type of the tool. Currently, only `function` is supported."""
+
+    function: GetAllPromptsMessagesFunction
+
+    thought_signature: Optional[str] = None
+    r"""Encrypted representation of the model internal reasoning state during function calling. Required by Gemini 3 models when continuing a conversation after a tool call."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["thought_signature"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class GetAllPromptsMessagesAssistantMessageTypedDict(TypedDict):
+    role: GetAllPromptsMessagesPromptsResponseRole
+    r"""The role of the messages author, in this case `assistant`."""
+    content: NotRequired[Nullable[GetAllPromptsMessagesPromptsResponseContentTypedDict]]
+    r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
+    refusal: NotRequired[Nullable[str]]
+    r"""The refusal message by the assistant."""
+    name: NotRequired[str]
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
+    audio: NotRequired[Nullable[GetAllPromptsMessagesAudioTypedDict]]
+    r"""Data about a previous audio response from the model."""
+    tool_calls: NotRequired[List[GetAllPromptsMessagesToolCallsTypedDict]]
+    r"""The tool calls generated by the model, such as function calls."""
+
+
+class GetAllPromptsMessagesAssistantMessage(BaseModel):
+    role: GetAllPromptsMessagesPromptsResponseRole
+    r"""The role of the messages author, in this case `assistant`."""
+
+    content: OptionalNullable[GetAllPromptsMessagesPromptsResponseContent] = UNSET
+    r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
+
+    refusal: OptionalNullable[str] = UNSET
+    r"""The refusal message by the assistant."""
+
+    name: Optional[str] = None
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
+
+    audio: OptionalNullable[GetAllPromptsMessagesAudio] = UNSET
+    r"""Data about a previous audio response from the model."""
+
+    tool_calls: Optional[List[GetAllPromptsMessagesToolCalls]] = None
+    r"""The tool calls generated by the model, such as function calls."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["content", "refusal", "name", "audio", "tool_calls"])
+        nullable_fields = set(["content", "refusal", "audio"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+GetAllPromptsMessagesPromptsRole = Literal["user",]
+r"""The role of the messages author, in this case `user`."""
+
+
+GetAllPrompts2PromptsResponse200Type = Literal["file",]
+r"""The type of the content part. Always `file`."""
+
+
+GetAllPrompts2PromptsResponse200ApplicationJSONType = Literal["ephemeral",]
+r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+
+
+GetAllPrompts2TTL = Literal[
+    "5m",
+    "1h",
+]
+r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+
+- `5m`: 5 minutes
+- `1h`: 1 hour
+
+Defaults to `5m`. Only supported by `Anthropic` Claude models.
+"""
+
+
+class GetAllPrompts2CacheControlTypedDict(TypedDict):
+    type: GetAllPrompts2PromptsResponse200ApplicationJSONType
+    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+    ttl: NotRequired[GetAllPrompts2TTL]
+    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+
+    - `5m`: 5 minutes
+    - `1h`: 1 hour
+
+    Defaults to `5m`. Only supported by `Anthropic` Claude models.
+    """
+
+
+class GetAllPrompts2CacheControl(BaseModel):
+    type: GetAllPrompts2PromptsResponse200ApplicationJSONType
+    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+
+    ttl: Optional[GetAllPrompts2TTL] = "5m"
+    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+
+    - `5m`: 5 minutes
+    - `1h`: 1 hour
+
+    Defaults to `5m`. Only supported by `Anthropic` Claude models.
+    """
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["ttl"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class GetAllPrompts24TypedDict(TypedDict):
+    type: GetAllPrompts2PromptsResponse200Type
+    r"""The type of the content part. Always `file`."""
+    file: FileContentPartSchemaTypedDict
+    r"""File data for the content part. Must contain either file_data or uri, but not both."""
+    cache_control: NotRequired[GetAllPrompts2CacheControlTypedDict]
+
+
+class GetAllPrompts24(BaseModel):
+    type: GetAllPrompts2PromptsResponse200Type
+    r"""The type of the content part. Always `file`."""
+
+    file: FileContentPartSchema
+    r"""File data for the content part. Must contain either file_data or uri, but not both."""
+
+    cache_control: Optional[GetAllPrompts2CacheControl] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["cache_control"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+GetAllPromptsContentPrompts2TypedDict = TypeAliasType(
+    "GetAllPromptsContentPrompts2TypedDict",
+    Union[
+        AudioContentPartSchemaTypedDict,
+        TextContentPartSchemaTypedDict,
+        ImageContentPartSchemaTypedDict,
+        GetAllPrompts24TypedDict,
+    ],
+)
+
+
+GetAllPromptsContentPrompts2 = Annotated[
+    Union[
+        Annotated[TextContentPartSchema, Tag("text")],
+        Annotated[ImageContentPartSchema, Tag("image_url")],
+        Annotated[AudioContentPartSchema, Tag("input_audio")],
+        Annotated[GetAllPrompts24, Tag("file")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+GetAllPromptsMessagesPromptsContentTypedDict = TypeAliasType(
+    "GetAllPromptsMessagesPromptsContentTypedDict",
+    Union[str, List[GetAllPromptsContentPrompts2TypedDict]],
+)
+r"""The contents of the user message."""
+
+
+GetAllPromptsMessagesPromptsContent = TypeAliasType(
+    "GetAllPromptsMessagesPromptsContent",
+    Union[str, List[GetAllPromptsContentPrompts2]],
+)
+r"""The contents of the user message."""
+
+
+class GetAllPromptsMessagesUserMessageTypedDict(TypedDict):
+    role: GetAllPromptsMessagesPromptsRole
+    r"""The role of the messages author, in this case `user`."""
+    content: GetAllPromptsMessagesPromptsContentTypedDict
+    r"""The contents of the user message."""
+    name: NotRequired[str]
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
+
+
+class GetAllPromptsMessagesUserMessage(BaseModel):
+    role: GetAllPromptsMessagesPromptsRole
+    r"""The role of the messages author, in this case `user`."""
+
+    content: GetAllPromptsMessagesPromptsContent
+    r"""The contents of the user message."""
+
+    name: Optional[str] = None
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["name"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+GetAllPromptsMessagesRole = Literal["system",]
+r"""The role of the messages author, in this case `system`."""
+
+
+GetAllPromptsMessagesContentTypedDict = TypeAliasType(
+    "GetAllPromptsMessagesContentTypedDict",
+    Union[str, List[TextContentPartSchemaTypedDict]],
+)
+r"""The contents of the system message."""
+
+
+GetAllPromptsMessagesContent = TypeAliasType(
+    "GetAllPromptsMessagesContent", Union[str, List[TextContentPartSchema]]
+)
+r"""The contents of the system message."""
+
+
+class GetAllPromptsMessagesSystemMessageTypedDict(TypedDict):
+    r"""Developer-provided instructions that the model should follow, regardless of messages sent by the user."""
+
+    role: GetAllPromptsMessagesRole
+    r"""The role of the messages author, in this case `system`."""
+    content: GetAllPromptsMessagesContentTypedDict
+    r"""The contents of the system message."""
+    name: NotRequired[str]
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
+
+
+class GetAllPromptsMessagesSystemMessage(BaseModel):
+    r"""Developer-provided instructions that the model should follow, regardless of messages sent by the user."""
+
+    role: GetAllPromptsMessagesRole
+    r"""The role of the messages author, in this case `system`."""
+
+    content: GetAllPromptsMessagesContent
+    r"""The contents of the system message."""
+
+    name: Optional[str] = None
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["name"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+GetAllPromptsPromptsMessagesTypedDict = TypeAliasType(
+    "GetAllPromptsPromptsMessagesTypedDict",
+    Union[
+        GetAllPromptsMessagesSystemMessageTypedDict,
+        GetAllPromptsMessagesUserMessageTypedDict,
+        GetAllPromptsMessagesToolMessageTypedDict,
+        GetAllPromptsMessagesAssistantMessageTypedDict,
+    ],
+)
+
+
+GetAllPromptsPromptsMessages = Annotated[
+    Union[
+        Annotated[GetAllPromptsMessagesSystemMessage, Tag("system")],
+        Annotated[GetAllPromptsMessagesUserMessage, Tag("user")],
+        Annotated[GetAllPromptsMessagesAssistantMessage, Tag("assistant")],
+        Annotated[GetAllPromptsMessagesToolMessage, Tag("tool")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "role", "role")),
+]
+
+
+class GetAllPromptsPromptFieldTypedDict(TypedDict):
+    r"""Prompt configuration with model and messages. Use this instead of prompt_config."""
+
+    audio: NotRequired[Nullable[GetAllPromptsAudioTypedDict]]
+    r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
+    frequency_penalty: NotRequired[Nullable[float]]
+    r"""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."""
+    max_tokens: NotRequired[Nullable[int]]
+    r"""`[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.
+
+    This value is now `deprecated` in favor of `max_completion_tokens`, and is not compatible with o1 series models.
+    """
+    max_completion_tokens: NotRequired[Nullable[int]]
+    r"""An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and reasoning tokens"""
+    logprobs: NotRequired[Nullable[bool]]
+    r"""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."""
+    top_logprobs: NotRequired[Nullable[int]]
+    r"""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."""
+    n: NotRequired[Nullable[int]]
+    r"""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."""
+    presence_penalty: NotRequired[Nullable[float]]
+    r"""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."""
+    response_format: NotRequired[GetAllPromptsResponseFormatTypedDict]
+    r"""An object specifying the format that the model must output"""
+    reasoning_effort: NotRequired[GetAllPromptsReasoningEffort]
+    r"""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.
+
+    - `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\".
+    """
+    verbosity: NotRequired[str]
+    r"""Adjusts response verbosity. Lower levels yield shorter answers."""
+    seed: NotRequired[Nullable[float]]
+    r"""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."""
+    stop: NotRequired[Nullable[GetAllPromptsStopTypedDict]]
+    r"""Up to 4 sequences where the API will stop generating further tokens."""
+    stream_options: NotRequired[Nullable[GetAllPromptsStreamOptionsTypedDict]]
+    r"""Options for streaming response. Only set this when you set stream: true."""
+    thinking: NotRequired[GetAllPromptsThinkingTypedDict]
+    temperature: NotRequired[Nullable[float]]
+    r"""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."""
+    top_p: NotRequired[Nullable[float]]
+    r"""An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass."""
+    top_k: NotRequired[Nullable[float]]
+    r"""Limits the model to consider only the top k most likely tokens at each step."""
+    tool_choice: NotRequired[GetAllPromptsToolChoiceTypedDict]
+    r"""Controls which (if any) tool is called by the model."""
+    parallel_tool_calls: NotRequired[bool]
+    r"""Whether to enable parallel function calling during tool use."""
+    modalities: NotRequired[Nullable[List[GetAllPromptsModalities]]]
+    r"""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\"]."""
+    guardrails: NotRequired[List[GetAllPromptsGuardrailsTypedDict]]
+    r"""A list of guardrails to apply to the request."""
+    fallbacks: NotRequired[List[GetAllPromptsFallbacksTypedDict]]
+    r"""Array of fallback models to use if primary model fails"""
+    retry: NotRequired[GetAllPromptsRetryTypedDict]
+    r"""Retry configuration for the request"""
+    cache: NotRequired[GetAllPromptsCacheTypedDict]
+    r"""Cache configuration for the request."""
+    load_balancer: NotRequired[GetAllPromptsLoadBalancerTypedDict]
+    r"""Load balancer configuration for the request."""
+    timeout: NotRequired[GetAllPromptsTimeoutTypedDict]
+    r"""Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured."""
+    messages: NotRequired[List[GetAllPromptsPromptsMessagesTypedDict]]
+    r"""Array of messages that make up the conversation. Each message has a role (system, user, assistant, or tool) and content."""
+    model: NotRequired[Nullable[str]]
+    r"""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}`."""
+    version: NotRequired[str]
+
+
+class GetAllPromptsPromptField(BaseModel):
+    r"""Prompt configuration with model and messages. Use this instead of prompt_config."""
+
+    audio: OptionalNullable[GetAllPromptsAudio] = UNSET
+    r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
+
+    frequency_penalty: OptionalNullable[float] = UNSET
+    r"""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."""
+
+    max_tokens: OptionalNullable[int] = UNSET
+    r"""`[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.
+
+    This value is now `deprecated` in favor of `max_completion_tokens`, and is not compatible with o1 series models.
+    """
+
+    max_completion_tokens: OptionalNullable[int] = UNSET
+    r"""An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and reasoning tokens"""
+
+    logprobs: OptionalNullable[bool] = UNSET
+    r"""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."""
+
+    top_logprobs: OptionalNullable[int] = UNSET
+    r"""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."""
+
+    n: OptionalNullable[int] = UNSET
+    r"""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."""
+
+    presence_penalty: OptionalNullable[float] = UNSET
+    r"""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."""
+
+    response_format: Optional[GetAllPromptsResponseFormat] = None
+    r"""An object specifying the format that the model must output"""
+
+    reasoning_effort: Optional[GetAllPromptsReasoningEffort] = None
+    r"""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.
+
+    - `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\".
+    """
+
+    verbosity: Optional[str] = None
+    r"""Adjusts response verbosity. Lower levels yield shorter answers."""
+
+    seed: OptionalNullable[float] = UNSET
+    r"""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."""
+
+    stop: OptionalNullable[GetAllPromptsStop] = UNSET
+    r"""Up to 4 sequences where the API will stop generating further tokens."""
+
+    stream_options: OptionalNullable[GetAllPromptsStreamOptions] = UNSET
+    r"""Options for streaming response. Only set this when you set stream: true."""
+
+    thinking: Optional[GetAllPromptsThinking] = None
+
+    temperature: OptionalNullable[float] = UNSET
+    r"""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."""
+
+    top_p: OptionalNullable[float] = UNSET
+    r"""An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass."""
+
+    top_k: OptionalNullable[float] = UNSET
+    r"""Limits the model to consider only the top k most likely tokens at each step."""
+
+    tool_choice: Optional[GetAllPromptsToolChoice] = None
+    r"""Controls which (if any) tool is called by the model."""
+
+    parallel_tool_calls: Optional[bool] = None
+    r"""Whether to enable parallel function calling during tool use."""
+
+    modalities: OptionalNullable[List[GetAllPromptsModalities]] = UNSET
+    r"""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\"]."""
+
+    guardrails: Optional[List[GetAllPromptsGuardrails]] = None
+    r"""A list of guardrails to apply to the request."""
+
+    fallbacks: Optional[List[GetAllPromptsFallbacks]] = None
+    r"""Array of fallback models to use if primary model fails"""
+
+    retry: Optional[GetAllPromptsRetry] = None
+    r"""Retry configuration for the request"""
+
+    cache: Optional[GetAllPromptsCache] = None
+    r"""Cache configuration for the request."""
+
+    load_balancer: Optional[GetAllPromptsLoadBalancer] = None
+    r"""Load balancer configuration for the request."""
+
+    timeout: Optional[GetAllPromptsTimeout] = None
+    r"""Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured."""
+
+    messages: Optional[List[GetAllPromptsPromptsMessages]] = None
+    r"""Array of messages that make up the conversation. Each message has a role (system, user, assistant, or tool) and content."""
+
+    model: OptionalNullable[str] = UNSET
+    r"""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}`."""
+
+    version: Optional[str] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "audio",
+                "frequency_penalty",
+                "max_tokens",
+                "max_completion_tokens",
+                "logprobs",
+                "top_logprobs",
+                "n",
+                "presence_penalty",
+                "response_format",
+                "reasoning_effort",
+                "verbosity",
+                "seed",
+                "stop",
+                "stream_options",
+                "thinking",
+                "temperature",
+                "top_p",
+                "top_k",
+                "tool_choice",
+                "parallel_tool_calls",
+                "modalities",
+                "guardrails",
+                "fallbacks",
+                "retry",
+                "cache",
+                "load_balancer",
+                "timeout",
+                "messages",
+                "model",
+                "version",
+            ]
+        )
+        nullable_fields = set(
+            [
+                "audio",
+                "frequency_penalty",
+                "max_tokens",
+                "max_completion_tokens",
+                "logprobs",
+                "top_logprobs",
+                "n",
+                "presence_penalty",
+                "seed",
+                "stop",
+                "stream_options",
+                "temperature",
+                "top_p",
+                "top_k",
+                "modalities",
+                "model",
+            ]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+GetAllPromptsUseCases = Literal[
+    "Agents simulations",
+    "Agents",
+    "API interaction",
+    "Autonomous Agents",
+    "Chatbots",
+    "Classification",
+    "Code understanding",
+    "Code writing",
+    "Conversation",
+    "Documents QA",
+    "Evaluation",
+    "Extraction",
+    "Multi-modal",
+    "Self-checking",
+    "Sentiment analysis",
+    "SQL",
+    "Summarization",
+    "Tagging",
+    "Translation (document)",
+    "Translation (sentences)",
+]
+
+
+GetAllPromptsLanguage = Literal[
+    "Chinese",
+    "Dutch",
+    "English",
+    "French",
+    "German",
+    "Russian",
+    "Spanish",
+]
+r"""The language that the prompt is written in. Use this field to categorize the prompt for your own purpose"""
+
+
+class GetAllPromptsMetadataTypedDict(TypedDict):
+    use_cases: NotRequired[List[GetAllPromptsUseCases]]
+    r"""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"""
+    language: NotRequired[Nullable[GetAllPromptsLanguage]]
+    r"""The language that the prompt is written in. Use this field to categorize the prompt for your own purpose"""
+
+
+class GetAllPromptsMetadata(BaseModel):
+    use_cases: Optional[List[GetAllPromptsUseCases]] = None
+    r"""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"""
+
+    language: OptionalNullable[GetAllPromptsLanguage] = UNSET
+    r"""The language that the prompt is written in. Use this field to categorize the prompt for your own purpose"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["use_cases", "language"])
+        nullable_fields = set(["language"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+class GetAllPromptsPromptTypedDict(TypedDict):
+    r"""A prompt entity with configuration, metadata, and versioning."""
+
+    id: str
+    type: GetAllPromptsType
+    owner: str
+    domain_id: str
+    created: str
+    updated: str
+    display_name: str
+    r"""The prompt’s name, meant to be displayable in the UI."""
+    prompt: GetAllPromptsPromptFieldTypedDict
+    r"""Prompt configuration with model and messages. Use this instead of prompt_config."""
+    created_by_id: NotRequired[Nullable[str]]
+    updated_by_id: NotRequired[Nullable[str]]
+    description: NotRequired[Nullable[str]]
+    r"""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"""
+    prompt_config: NotRequired[GetAllPromptsPromptConfigTypedDict]
+    r"""[DEPRECATED] Use the `prompt` property instead. A list of messages compatible with the openAI schema."""
+    metadata: NotRequired[GetAllPromptsMetadataTypedDict]
+
+
+class GetAllPromptsPrompt(BaseModel):
+    r"""A prompt entity with configuration, metadata, and versioning."""
+
+    id: Annotated[str, pydantic.Field(alias="_id")]
+
+    type: GetAllPromptsType
+
+    owner: str
+
+    domain_id: str
+
+    created: str
+
+    updated: str
+
+    display_name: str
+    r"""The prompt’s name, meant to be displayable in the UI."""
+
+    prompt: GetAllPromptsPromptField
+    r"""Prompt configuration with model and messages. Use this instead of prompt_config."""
+
+    created_by_id: OptionalNullable[str] = UNSET
+
+    updated_by_id: OptionalNullable[str] = UNSET
+
+    description: OptionalNullable[str] = UNSET
+    r"""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"""
+
+    prompt_config: Annotated[
+        Optional[GetAllPromptsPromptConfig],
+        pydantic.Field(
+            deprecated="warning: ** DEPRECATED ** - This will be removed in a future release, please migrate away from it as soon as possible."
+        ),
+    ] = None
+    r"""[DEPRECATED] Use the `prompt` property instead. A list of messages compatible with the openAI schema."""
+
+    metadata: Optional[GetAllPromptsMetadata] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "created_by_id",
+                "updated_by_id",
+                "description",
+                "prompt_config",
+                "metadata",
+            ]
+        )
+        nullable_fields = set(["created_by_id", "updated_by_id", "description"])
+        serialized = handler(self)
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m