langwatch-scenario 0.6.0__py3-none-any.whl → 0.7.2__py3-none-any.whl

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/post_api_prompts_by_id_versions_response_200.py

@@ -0,0 +1,155 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.post_api_prompts_by_id_versions_response_200_config_data import (
+        PostApiPromptsByIdVersionsResponse200ConfigData,
+    )
+
+
+T = TypeVar("T", bound="PostApiPromptsByIdVersionsResponse200")
+
+
+@_attrs_define
+class PostApiPromptsByIdVersionsResponse200:
+    """
+    Attributes:
+        id (str):
+        author_id (Union[None, str]):
+        project_id (str):
+        config_id (str):
+        schema_version (Literal['1.0']):
+        version (float):
+        created_at (str):
+        config_data (PostApiPromptsByIdVersionsResponse200ConfigData):
+        commit_message (Union[None, Unset, str]):
+    """
+
+    id: str
+    author_id: Union[None, str]
+    project_id: str
+    config_id: str
+    schema_version: Literal["1.0"]
+    version: float
+    created_at: str
+    config_data: "PostApiPromptsByIdVersionsResponse200ConfigData"
+    commit_message: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        author_id: Union[None, str]
+        author_id = self.author_id
+
+        project_id = self.project_id
+
+        config_id = self.config_id
+
+        schema_version = self.schema_version
+
+        version = self.version
+
+        created_at = self.created_at
+
+        config_data = self.config_data.to_dict()
+
+        commit_message: Union[None, Unset, str]
+        if isinstance(self.commit_message, Unset):
+            commit_message = UNSET
+        else:
+            commit_message = self.commit_message
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "authorId": author_id,
+                "projectId": project_id,
+                "configId": config_id,
+                "schemaVersion": schema_version,
+                "version": version,
+                "createdAt": created_at,
+                "configData": config_data,
+            }
+        )
+        if commit_message is not UNSET:
+            field_dict["commitMessage"] = commit_message
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.post_api_prompts_by_id_versions_response_200_config_data import (
+            PostApiPromptsByIdVersionsResponse200ConfigData,
+        )
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        def _parse_author_id(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        author_id = _parse_author_id(d.pop("authorId"))
+
+        project_id = d.pop("projectId")
+
+        config_id = d.pop("configId")
+
+        schema_version = cast(Literal["1.0"], d.pop("schemaVersion"))
+        if schema_version != "1.0":
+            raise ValueError(f"schemaVersion must match const '1.0', got '{schema_version}'")
+
+        version = d.pop("version")
+
+        created_at = d.pop("createdAt")
+
+        config_data = PostApiPromptsByIdVersionsResponse200ConfigData.from_dict(d.pop("configData"))
+
+        def _parse_commit_message(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        commit_message = _parse_commit_message(d.pop("commitMessage", UNSET))
+
+        post_api_prompts_by_id_versions_response_200 = cls(
+            id=id,
+            author_id=author_id,
+            project_id=project_id,
+            config_id=config_id,
+            schema_version=schema_version,
+            version=version,
+            created_at=created_at,
+            config_data=config_data,
+            commit_message=commit_message,
+        )
+
+        post_api_prompts_by_id_versions_response_200.additional_properties = d
+        return post_api_prompts_by_id_versions_response_200
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/post_api_prompts_by_id_versions_response_200_config_data.py

@@ -0,0 +1,206 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.post_api_prompts_by_id_versions_response_200_config_data_demonstrations import (
+        PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrations,
+    )
+    from ..models.post_api_prompts_by_id_versions_response_200_config_data_inputs_item import (
+        PostApiPromptsByIdVersionsResponse200ConfigDataInputsItem,
+    )
+    from ..models.post_api_prompts_by_id_versions_response_200_config_data_messages_item import (
+        PostApiPromptsByIdVersionsResponse200ConfigDataMessagesItem,
+    )
+    from ..models.post_api_prompts_by_id_versions_response_200_config_data_outputs_item import (
+        PostApiPromptsByIdVersionsResponse200ConfigDataOutputsItem,
+    )
+    from ..models.post_api_prompts_by_id_versions_response_200_config_data_prompting_technique import (
+        PostApiPromptsByIdVersionsResponse200ConfigDataPromptingTechnique,
+    )
+
+
+T = TypeVar("T", bound="PostApiPromptsByIdVersionsResponse200ConfigData")
+
+
+@_attrs_define
+class PostApiPromptsByIdVersionsResponse200ConfigData:
+    """
+    Attributes:
+        prompt (str):
+        messages (list['PostApiPromptsByIdVersionsResponse200ConfigDataMessagesItem']):
+        inputs (list['PostApiPromptsByIdVersionsResponse200ConfigDataInputsItem']):
+        outputs (list['PostApiPromptsByIdVersionsResponse200ConfigDataOutputsItem']):
+        model (str):
+        demonstrations (PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrations):
+        version (Union[Unset, float]):
+        temperature (Union[Unset, float]):
+        max_tokens (Union[Unset, float]):
+        prompting_technique (Union[Unset, PostApiPromptsByIdVersionsResponse200ConfigDataPromptingTechnique]):
+    """
+
+    prompt: str
+    messages: list["PostApiPromptsByIdVersionsResponse200ConfigDataMessagesItem"]
+    inputs: list["PostApiPromptsByIdVersionsResponse200ConfigDataInputsItem"]
+    outputs: list["PostApiPromptsByIdVersionsResponse200ConfigDataOutputsItem"]
+    model: str
+    demonstrations: "PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrations"
+    version: Union[Unset, float] = UNSET
+    temperature: Union[Unset, float] = UNSET
+    max_tokens: Union[Unset, float] = UNSET
+    prompting_technique: Union[Unset, "PostApiPromptsByIdVersionsResponse200ConfigDataPromptingTechnique"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        prompt = self.prompt
+
+        messages = []
+        for messages_item_data in self.messages:
+            messages_item = messages_item_data.to_dict()
+            messages.append(messages_item)
+
+        inputs = []
+        for inputs_item_data in self.inputs:
+            inputs_item = inputs_item_data.to_dict()
+            inputs.append(inputs_item)
+
+        outputs = []
+        for outputs_item_data in self.outputs:
+            outputs_item = outputs_item_data.to_dict()
+            outputs.append(outputs_item)
+
+        model = self.model
+
+        demonstrations = self.demonstrations.to_dict()
+
+        version = self.version
+
+        temperature = self.temperature
+
+        max_tokens = self.max_tokens
+
+        prompting_technique: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.prompting_technique, Unset):
+            prompting_technique = self.prompting_technique.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "prompt": prompt,
+                "messages": messages,
+                "inputs": inputs,
+                "outputs": outputs,
+                "model": model,
+                "demonstrations": demonstrations,
+            }
+        )
+        if version is not UNSET:
+            field_dict["version"] = version
+        if temperature is not UNSET:
+            field_dict["temperature"] = temperature
+        if max_tokens is not UNSET:
+            field_dict["max_tokens"] = max_tokens
+        if prompting_technique is not UNSET:
+            field_dict["prompting_technique"] = prompting_technique
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.post_api_prompts_by_id_versions_response_200_config_data_demonstrations import (
+            PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrations,
+        )
+        from ..models.post_api_prompts_by_id_versions_response_200_config_data_inputs_item import (
+            PostApiPromptsByIdVersionsResponse200ConfigDataInputsItem,
+        )
+        from ..models.post_api_prompts_by_id_versions_response_200_config_data_messages_item import (
+            PostApiPromptsByIdVersionsResponse200ConfigDataMessagesItem,
+        )
+        from ..models.post_api_prompts_by_id_versions_response_200_config_data_outputs_item import (
+            PostApiPromptsByIdVersionsResponse200ConfigDataOutputsItem,
+        )
+        from ..models.post_api_prompts_by_id_versions_response_200_config_data_prompting_technique import (
+            PostApiPromptsByIdVersionsResponse200ConfigDataPromptingTechnique,
+        )
+
+        d = dict(src_dict)
+        prompt = d.pop("prompt")
+
+        messages = []
+        _messages = d.pop("messages")
+        for messages_item_data in _messages:
+            messages_item = PostApiPromptsByIdVersionsResponse200ConfigDataMessagesItem.from_dict(messages_item_data)
+
+            messages.append(messages_item)
+
+        inputs = []
+        _inputs = d.pop("inputs")
+        for inputs_item_data in _inputs:
+            inputs_item = PostApiPromptsByIdVersionsResponse200ConfigDataInputsItem.from_dict(inputs_item_data)
+
+            inputs.append(inputs_item)
+
+        outputs = []
+        _outputs = d.pop("outputs")
+        for outputs_item_data in _outputs:
+            outputs_item = PostApiPromptsByIdVersionsResponse200ConfigDataOutputsItem.from_dict(outputs_item_data)
+
+            outputs.append(outputs_item)
+
+        model = d.pop("model")
+
+        demonstrations = PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrations.from_dict(
+            d.pop("demonstrations")
+        )
+
+        version = d.pop("version", UNSET)
+
+        temperature = d.pop("temperature", UNSET)
+
+        max_tokens = d.pop("max_tokens", UNSET)
+
+        _prompting_technique = d.pop("prompting_technique", UNSET)
+        prompting_technique: Union[Unset, PostApiPromptsByIdVersionsResponse200ConfigDataPromptingTechnique]
+        if isinstance(_prompting_technique, Unset):
+            prompting_technique = UNSET
+        else:
+            prompting_technique = PostApiPromptsByIdVersionsResponse200ConfigDataPromptingTechnique.from_dict(
+                _prompting_technique
+            )
+
+        post_api_prompts_by_id_versions_response_200_config_data = cls(
+            prompt=prompt,
+            messages=messages,
+            inputs=inputs,
+            outputs=outputs,
+            model=model,
+            demonstrations=demonstrations,
+            version=version,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            prompting_technique=prompting_technique,
+        )
+
+        post_api_prompts_by_id_versions_response_200_config_data.additional_properties = d
+        return post_api_prompts_by_id_versions_response_200_config_data
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/post_api_prompts_by_id_versions_response_200_config_data_demonstrations.py

@@ -0,0 +1,101 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.post_api_prompts_by_id_versions_response_200_config_data_demonstrations_columns_item import (
+        PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsColumnsItem,
+    )
+    from ..models.post_api_prompts_by_id_versions_response_200_config_data_demonstrations_rows_item import (
+        PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsRowsItem,
+    )
+
+
+T = TypeVar("T", bound="PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrations")
+
+
+@_attrs_define
+class PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrations:
+    """
+    Attributes:
+        columns (list['PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsColumnsItem']):
+        rows (list['PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsRowsItem']):
+    """
+
+    columns: list["PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsColumnsItem"]
+    rows: list["PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsRowsItem"]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        columns = []
+        for columns_item_data in self.columns:
+            columns_item = columns_item_data.to_dict()
+            columns.append(columns_item)
+
+        rows = []
+        for rows_item_data in self.rows:
+            rows_item = rows_item_data.to_dict()
+            rows.append(rows_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "columns": columns,
+                "rows": rows,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.post_api_prompts_by_id_versions_response_200_config_data_demonstrations_columns_item import (
+            PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsColumnsItem,
+        )
+        from ..models.post_api_prompts_by_id_versions_response_200_config_data_demonstrations_rows_item import (
+            PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsRowsItem,
+        )
+
+        d = dict(src_dict)
+        columns = []
+        _columns = d.pop("columns")
+        for columns_item_data in _columns:
+            columns_item = PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsColumnsItem.from_dict(
+                columns_item_data
+            )
+
+            columns.append(columns_item)
+
+        rows = []
+        _rows = d.pop("rows")
+        for rows_item_data in _rows:
+            rows_item = PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsRowsItem.from_dict(rows_item_data)
+
+            rows.append(rows_item)
+
+        post_api_prompts_by_id_versions_response_200_config_data_demonstrations = cls(
+            columns=columns,
+            rows=rows,
+        )
+
+        post_api_prompts_by_id_versions_response_200_config_data_demonstrations.additional_properties = d
+        return post_api_prompts_by_id_versions_response_200_config_data_demonstrations
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/post_api_prompts_by_id_versions_response_200_config_data_demonstrations_columns_item.py

@@ -0,0 +1,79 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.post_api_prompts_by_id_versions_response_200_config_data_demonstrations_columns_item_type import (
+    PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsColumnsItemType,
+)
+
+T = TypeVar("T", bound="PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsColumnsItem")
+
+
+@_attrs_define
+class PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsColumnsItem:
+    """
+    Attributes:
+        id (str):
+        name (str):
+        type_ (PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsColumnsItemType):
+    """
+
+    id: str
+    name: str
+    type_: PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsColumnsItemType
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        name = self.name
+
+        type_ = self.type_.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "name": name,
+                "type": type_,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        name = d.pop("name")
+
+        type_ = PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsColumnsItemType(d.pop("type"))
+
+        post_api_prompts_by_id_versions_response_200_config_data_demonstrations_columns_item = cls(
+            id=id,
+            name=name,
+            type_=type_,
+        )
+
+        post_api_prompts_by_id_versions_response_200_config_data_demonstrations_columns_item.additional_properties = d
+        return post_api_prompts_by_id_versions_response_200_config_data_demonstrations_columns_item
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/post_api_prompts_by_id_versions_response_200_config_data_demonstrations_columns_item_type.py

@@ -0,0 +1,18 @@
+from enum import Enum
+
+
+class PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsColumnsItemType(str, Enum):
+    ANNOTATIONS = "annotations"
+    BOOLEAN = "boolean"
+    CHAT_MESSAGES = "chat_messages"
+    DATE = "date"
+    EVALUATIONS = "evaluations"
+    JSON = "json"
+    LIST = "list"
+    NUMBER = "number"
+    RAG_CONTEXTS = "rag_contexts"
+    SPANS = "spans"
+    STRING = "string"
+
+    def __str__(self) -> str:
+        return str(self.value)

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/post_api_prompts_by_id_versions_response_200_config_data_demonstrations_rows_item.py

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsRowsItem")
+
+
+@_attrs_define
+class PostApiPromptsByIdVersionsResponse200ConfigDataDemonstrationsRowsItem:
+    """
+    Attributes:
+        id (str):
+    """
+
+    id: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        post_api_prompts_by_id_versions_response_200_config_data_demonstrations_rows_item = cls(
+            id=id,
+        )
+
+        post_api_prompts_by_id_versions_response_200_config_data_demonstrations_rows_item.additional_properties = d
+        return post_api_prompts_by_id_versions_response_200_config_data_demonstrations_rows_item
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

scenario/_generated/langwatch_api_client/lang_watch_api_client/models/post_api_prompts_by_id_versions_response_200_config_data_inputs_item.py

@@ -0,0 +1,71 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.post_api_prompts_by_id_versions_response_200_config_data_inputs_item_type import (
+    PostApiPromptsByIdVersionsResponse200ConfigDataInputsItemType,
+)
+
+T = TypeVar("T", bound="PostApiPromptsByIdVersionsResponse200ConfigDataInputsItem")
+
+
+@_attrs_define
+class PostApiPromptsByIdVersionsResponse200ConfigDataInputsItem:
+    """
+    Attributes:
+        identifier (str):
+        type_ (PostApiPromptsByIdVersionsResponse200ConfigDataInputsItemType):
+    """
+
+    identifier: str
+    type_: PostApiPromptsByIdVersionsResponse200ConfigDataInputsItemType
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        identifier = self.identifier
+
+        type_ = self.type_.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "identifier": identifier,
+                "type": type_,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        identifier = d.pop("identifier")
+
+        type_ = PostApiPromptsByIdVersionsResponse200ConfigDataInputsItemType(d.pop("type"))
+
+        post_api_prompts_by_id_versions_response_200_config_data_inputs_item = cls(
+            identifier=identifier,
+            type_=type_,
+        )
+
+        post_api_prompts_by_id_versions_response_200_config_data_inputs_item.additional_properties = d
+        return post_api_prompts_by_id_versions_response_200_config_data_inputs_item
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties