api-sdk-py 1.11.66__py3-none-any.whl

api_sdk_py/models/new_composition.py

@@ -0,0 +1,108 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class NewComposition(BaseModel):
+    """
+    NewComposition
+    """ # noqa: E501
+    name: StrictStr = Field(description="Name of the composition")
+    widget_id: StrictStr = Field(description="ID of the widget this composition is based on", alias="widgetId")
+    creator_id: Optional[StrictStr] = Field(default=None, description="ID of the user creating the composition", alias="creatorId")
+    content: Optional[Dict[str, Any]] = Field(default=None, description="Content data for the composition")
+    status: Optional[StrictStr] = Field(default='draft', description="Initial status of the composition")
+    embed_settings: Optional[Dict[str, Any]] = Field(default=None, description="Settings for embedding the composition", alias="embedSettings")
+    design: Optional[Dict[str, Any]] = Field(default=None, description="Design settings for the composition")
+    database_schema: Optional[Dict[str, Any]] = Field(default=None, description="The tables this composition keeps what visitors send it in (votes, ratings, answers). They are made when the composition is created, in a schema of their own that no other composition can reach: in Widgetic's database, or in your own Neon database when you have set one with `setPartnerDataDatabase`. They are deleted with the composition.  The shape is `{ \"tables\": [ ... ] }`. A table has a `name`, a list of `columns` and, optionally, a list of `indexes`. A column has a `name` and a `type`, and optionally `primaryKey`, `notNull`, `unique` and `default`. An index has a `name` and the `columns` it covers (1 to 8), and optionally `unique`. Any other key is refused.  - Names (tables, columns, indexes) use lower-case letters, digits and underscores, start with a letter and   are at most 63 characters long. A name that starts with `_` or `pg_` is reserved. - `type` is one of `text`, `smallint`, `integer` (or `int`), `bigint`, `numeric`, `real`,   `double precision`, `boolean` (or `bool`), `date`, `timestamp`, `timestamptz` (or   `timestamp with time zone`), `uuid`, `json`, `jsonb`, `serial`, `bigserial`. - `default` is a number, `true` or `false`, a text of at most 500 characters (no backslash), a JSON value   for a `json` or `jsonb` column, or one of `now()`, `current_timestamp` and `current_date` (date and   timestamp columns) and `gen_random_uuid()` (a `uuid` column). A `serial` column numbers itself and has   no default. - A composition declares at most 20 tables, with at most 64 columns and 10 indexes each.  A declaration that cannot be used is refused with `400` and `INVALID_DATABASE_SCHEMA`; `error.details.problems` lists what to change. Tables that already exist are never changed or dropped: sending more tables later, when you update the composition, adds the ones that are missing. When the composition is saved but its tables cannot be made just now, the answer says so in `meta.warnings`: send the same `databaseSchema` again to retry.  Leave it out and the composition gets the tables its widget declares in its own source (`src/lib/meta/database.json`), if any. Send `{ \"tables\": [] }` to give the composition no tables and keep it from getting its widget's. ", alias="databaseSchema")
+    project_id: Optional[StrictStr] = Field(default=None, description="ID of the project this composition belongs to", alias="projectId")
+    managed_user_id: Optional[StrictStr] = Field(default=None, description="Make the composition for one of your managed users, by Widgetic's id for the user. Send this or `managedUserExternalId`, not both. The managed user must be yours and active. The composition stays in your account; the tag lets you list one user's compositions and keeps it out of the others' lists. It is set here and does not change afterwards.", alias="managedUserId")
+    managed_user_external_id: Optional[Annotated[str, Field(strict=True, max_length=255)]] = Field(default=None, description="The same, by your own identifier for the user, the `externalId` you gave when you created the managed user (answers show it as `externalId`). Send this or `managedUserId`, not both.", alias="managedUserExternalId")
+    __properties: ClassVar[List[str]] = ["name", "widgetId", "creatorId", "content", "status", "embedSettings", "design", "databaseSchema", "projectId", "managedUserId", "managedUserExternalId"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of NewComposition from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of NewComposition from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "widgetId": obj.get("widgetId"),
+            "creatorId": obj.get("creatorId"),
+            "content": obj.get("content"),
+            "status": obj.get("status") if obj.get("status") is not None else 'draft',
+            "embedSettings": obj.get("embedSettings"),
+            "design": obj.get("design"),
+            "databaseSchema": obj.get("databaseSchema"),
+            "projectId": obj.get("projectId"),
+            "managedUserId": obj.get("managedUserId"),
+            "managedUserExternalId": obj.get("managedUserExternalId")
+        })
+        return _obj
+
+

api_sdk_py/models/new_editor_session.py

@@ -0,0 +1,107 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class NewEditorSession(BaseModel):
+    """
+    NewEditorSession
+    """ # noqa: E501
+    surfaces: Annotated[List[StrictStr], Field(min_length=1)] = Field(description="The pieces of Widgetic's editor the session may drive. `files` is the media library (the File Browser: upload a file, list the files uploaded for this user); what a user uploads is kept in your own storage destination. Partner storage is not optional: a session of any surface can be made only once you have set a destination up (`setPartnerStorageDestination`), and is refused with `409 PARTNER_STORAGE_REQUIRED` until then. `editor` is editing one of this user's compositions: read it, change its name, content, design and embed settings, read its schemas, and ask where to show it (`getCompositionPreview`: the widget's published page). `creator` is Widgetic's widget creator, with its drawing canvas and its AI: this user's canvases, the widgets on them and the conversation of each widget, the generation, build and publish calls that make a widget, and the compositions of those widgets (list, make). The surfaces do not imply one another: the whole creator also saves a composition (`editor`) and attaches pictures to its chat (`files`), so ask for `[\"creator\", \"editor\", \"files\"]`. ")
+    expires_in_seconds: Optional[Annotated[int, Field(le=14400, strict=True, ge=60)]] = Field(default=3600, description="How long the session lasts, in seconds. It cannot be extended; make a new session when it ends.", alias="expiresInSeconds")
+    allowed_origin: Optional[StrictStr] = Field(default=None, description="Bind the session to one web page origin, such as `https://app.example.com` (no path; `http` is accepted only for `localhost`). The session is then refused from any other origin, and from a request that carries no `Origin` header. Leave it out for a session that can be used from anywhere, which is what a server-side caller needs. ", alias="allowedOrigin")
+    max_credits: Optional[Annotated[int, Field(le=1000000, strict=True, ge=1)]] = Field(default=None, description="The most credits this session may spend on Widgetic's AI, one credit being one generation. Once the operations it ran have taken that many, the next one is refused (402, `EDITOR_SESSION_CREDIT_LIMIT_REACHED`) and the browser is only told that the feature is not available right now. A generation that fails is refunded and does not count. Leave it out to get the limit Widgetic has set for your account, if it has set one (it sets none unless you ask), and otherwise no limit of its own, which leaves the credits of your account as the only ceiling. Send `null` to ask for no limit of its own even when a default is set. ", alias="maxCredits")
+    __properties: ClassVar[List[str]] = ["surfaces", "expiresInSeconds", "allowedOrigin", "maxCredits"]
+
+    @field_validator('surfaces')
+    def surfaces_validate_enum(cls, value):
+        """Validates the enum"""
+        for i in value:
+            if i not in set(['files', 'editor', 'creator']):
+                raise ValueError("each list item must be one of ('files', 'editor', 'creator')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of NewEditorSession from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if allowed_origin (nullable) is None
+        # and model_fields_set contains the field
+        if self.allowed_origin is None and "allowed_origin" in self.model_fields_set:
+            _dict['allowedOrigin'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of NewEditorSession from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "surfaces": obj.get("surfaces"),
+            "expiresInSeconds": obj.get("expiresInSeconds") if obj.get("expiresInSeconds") is not None else 3600,
+            "allowedOrigin": obj.get("allowedOrigin"),
+            "maxCredits": obj.get("maxCredits")
+        })
+        return _obj
+
+

api_sdk_py/models/new_managed_user.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class NewManagedUser(BaseModel):
+    """
+    NewManagedUser
+    """ # noqa: E501
+    external_id: StrictStr = Field(description="Your own identifier for the managed user. Must be unique among the managed users you manage (409 otherwise); another partner using the same value does not matter.", alias="externalId")
+    manager_id: Optional[StrictStr] = Field(default=None, description="ID of the user who will manage this managed user. Defaults to your own user ID; a partner can only use their own ID (403 otherwise), only an admin can name another manager.", alias="managerId")
+    metadata: Optional[Dict[str, Any]] = Field(default=None, description="Additional metadata for the managed user")
+    __properties: ClassVar[List[str]] = ["externalId", "managerId", "metadata"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of NewManagedUser from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of NewManagedUser from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "externalId": obj.get("externalId"),
+            "managerId": obj.get("managerId"),
+            "metadata": obj.get("metadata")
+        })
+        return _obj
+
+

api_sdk_py/models/new_widget.py

@@ -0,0 +1,118 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class NewWidget(BaseModel):
+    """
+    What a new widget starts from. Only the fields listed here are used. The widget is created without code: it is a record with a name, a type and some starting content, on a canvas (a new one, unless you name one of yours). It has no database: what the visitors of a composition leave is kept in the tables of that composition. 
+    """ # noqa: E501
+    name: Annotated[str, Field(min_length=1, strict=True)] = Field(description="Name of the widget.")
+    type: Annotated[str, Field(min_length=1, strict=True)] = Field(description="What kind of widget this is, as a label of your choosing (for example chart, form, gallery).")
+    content: Dict[str, Any] = Field(description="Starting content for the widget. An empty object is fine.")
+    is_public: Optional[StrictBool] = Field(default=False, description="Whether the widget is public.", alias="isPublic")
+    is_draft: Optional[StrictBool] = Field(default=True, description="Whether the widget starts as a draft. A widget created without this is a draft.", alias="isDraft")
+    canvas_id: Optional[StrictStr] = Field(default=None, description="Put the widget on this existing canvas instead of a new one. You must own the canvas.", alias="canvasId")
+    project_id: Optional[StrictStr] = Field(default=None, description="Project to file the widget in. You must be able to edit the project.", alias="projectId")
+    organization_id: Optional[StrictStr] = Field(default=None, description="Organization the widget belongs to. You must be a member who may create widgets there.", alias="organizationId")
+    workspace_type: Optional[StrictStr] = Field(default=None, description="Whether the widget lives in your personal workspace or in an organization's.", alias="workspaceType")
+    managed_user_id: Optional[StrictStr] = Field(default=None, description="Make the widget for one of your managed users, by Widgetic's id for the user. Send this or `managedUserExternalId`, not both. The managed user must be yours and active. The widget stays in your account; the tag lets you list one user's widgets and keeps it out of the others' lists. It is set here and does not change afterwards.", alias="managedUserId")
+    managed_user_external_id: Optional[Annotated[str, Field(strict=True, max_length=255)]] = Field(default=None, description="The same, by your own identifier for the user, the `externalId` you gave when you created the managed user (answers show it as `externalId`). Send this or `managedUserId`, not both.", alias="managedUserExternalId")
+    __properties: ClassVar[List[str]] = ["name", "type", "content", "isPublic", "isDraft", "canvasId", "projectId", "organizationId", "workspaceType", "managedUserId", "managedUserExternalId"]
+
+    @field_validator('workspace_type')
+    def workspace_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['personal', 'organization']):
+            raise ValueError("must be one of enum values ('personal', 'organization')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of NewWidget from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of NewWidget from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "type": obj.get("type"),
+            "content": obj.get("content"),
+            "isPublic": obj.get("isPublic") if obj.get("isPublic") is not None else False,
+            "isDraft": obj.get("isDraft") if obj.get("isDraft") is not None else True,
+            "canvasId": obj.get("canvasId"),
+            "projectId": obj.get("projectId"),
+            "organizationId": obj.get("organizationId"),
+            "workspaceType": obj.get("workspaceType"),
+            "managedUserId": obj.get("managedUserId"),
+            "managedUserExternalId": obj.get("managedUserExternalId")
+        })
+        return _obj
+
+

api_sdk_py/models/operations_id_get_response.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from api_sdk_py.models.operations_id_get_response_data import OperationsIdGetResponseData
+from api_sdk_py.models.response_meta import ResponseMeta
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OperationsIdGetResponse(BaseModel):
+    """
+    OperationsIdGetResponse
+    """ # noqa: E501
+    success: StrictBool = Field(description="Always `true` on a success.")
+    data: OperationsIdGetResponseData
+    meta: Optional[ResponseMeta] = None
+    __properties: ClassVar[List[str]] = ["success", "data", "meta"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of OperationsIdGetResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of data
+        if self.data:
+            _dict['data'] = self.data.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of meta
+        if self.meta:
+            _dict['meta'] = self.meta.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OperationsIdGetResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "success": obj.get("success"),
+            "data": OperationsIdGetResponseData.from_dict(obj["data"]) if obj.get("data") is not None else None,
+            "meta": ResponseMeta.from_dict(obj["meta"]) if obj.get("meta") is not None else None
+        })
+        return _obj
+
+

api_sdk_py/models/operations_id_get_response_data.py

@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+    Widgetic API Gateway
+
+    API documentation for the Widgetic API Gateway
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OperationsIdGetResponseData(BaseModel):
+    """
+    Operation payload including status, metadata, and timestamps.
+    """ # noqa: E501
+    id: Optional[StrictStr] = Field(default=None, description="The operation's identifier, the `operationId` the call that started it returned")
+    type: Optional[StrictStr] = Field(default=None, description="What the operation does")
+    status: Optional[StrictStr] = Field(default=None, description="Where the operation stands. `completed`, `failed` and `cancelled` are final")
+    progress: Optional[Annotated[int, Field(le=100, strict=True, ge=0)]] = Field(default=None, description="How far the operation has got, in percent")
+    metadata: Optional[Dict[str, Any]] = Field(default=None, description="What the operation tells about its work. A finished composition duplication names the new composition in `newCompositionId`, and lists any problem with its database in `warnings` (absent when there is none). ")
+    error: Optional[StrictStr] = Field(default=None, description="Why a `failed` operation failed (absent otherwise)")
+    created_at: Optional[datetime] = Field(default=None, alias="createdAt")
+    updated_at: Optional[datetime] = Field(default=None, alias="updatedAt")
+    __properties: ClassVar[List[str]] = ["id", "type", "status", "progress", "metadata", "error", "createdAt", "updatedAt"]
+
+    @field_validator('status')
+    def status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['pending', 'running', 'completed', 'failed', 'cancelled']):
+            raise ValueError("must be one of enum values ('pending', 'running', 'completed', 'failed', 'cancelled')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of OperationsIdGetResponseData from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OperationsIdGetResponseData from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "type": obj.get("type"),
+            "status": obj.get("status"),
+            "progress": obj.get("progress"),
+            "metadata": obj.get("metadata"),
+            "error": obj.get("error"),
+            "createdAt": obj.get("createdAt"),
+            "updatedAt": obj.get("updatedAt")
+        })
+        return _obj
+
+