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

api_sdk_py/models/editor_session.py

@@ -0,0 +1,122 @@
+# 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, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class EditorSession(BaseModel):
+    """
+    An editor session you have just made. `token` is shown once and cannot be read again: hand it to the browser of this one user and keep it out of logs and storage. 
+    """ # noqa: E501
+    token: StrictStr = Field(description="The credential the browser sends as `Authorization: Bearer <token>`. It starts with `wgt_ses_`. It works only for the calls of the session's surfaces, only for this managed user's content, and only until `expiresAt`. ")
+    session_id: StrictStr = Field(description="Identifies the session, so you can end it (`revokeManagedUserEditorSession`). It is not a credential.", alias="sessionId")
+    managed_user_id: StrictStr = Field(alias="managedUserId")
+    managed_user_external_id: StrictStr = Field(description="Your own identifier for the managed user", alias="managedUserExternalId")
+    surfaces: List[StrictStr]
+    allowed_origin: Optional[StrictStr] = Field(default=None, description="The web page origin the session is bound to, or null when it is not bound", alias="allowedOrigin")
+    max_credits: Optional[StrictInt] = Field(default=None, description="The most credits the session may spend on Widgetic's AI (`max_credits`), or null when it has no limit of its own", alias="maxCredits")
+    expires_at: datetime = Field(alias="expiresAt")
+    created_at: datetime = Field(alias="createdAt")
+    __properties: ClassVar[List[str]] = ["token", "sessionId", "managedUserId", "managedUserExternalId", "surfaces", "allowedOrigin", "maxCredits", "expiresAt", "createdAt"]
+
+    @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 EditorSession 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
+
+        # set to None if max_credits (nullable) is None
+        # and model_fields_set contains the field
+        if self.max_credits is None and "max_credits" in self.model_fields_set:
+            _dict['maxCredits'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of EditorSession from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "token": obj.get("token"),
+            "sessionId": obj.get("sessionId"),
+            "managedUserId": obj.get("managedUserId"),
+            "managedUserExternalId": obj.get("managedUserExternalId"),
+            "surfaces": obj.get("surfaces"),
+            "allowedOrigin": obj.get("allowedOrigin"),
+            "maxCredits": obj.get("maxCredits"),
+            "expiresAt": obj.get("expiresAt"),
+            "createdAt": obj.get("createdAt")
+        })
+        return _obj
+
+

api_sdk_py/models/editor_session_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.editor_session import EditorSession
+from api_sdk_py.models.response_meta import ResponseMeta
+from typing import Optional, Set
+from typing_extensions import Self
+
+class EditorSessionResponse(BaseModel):
+    """
+    EditorSessionResponse
+    """ # noqa: E501
+    success: StrictBool = Field(description="Always `true` on a success.")
+    data: EditorSession
+    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 EditorSessionResponse 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 EditorSessionResponse 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": EditorSession.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/entitlement.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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Entitlement(BaseModel):
+    """
+    Feature entitlement for users, partners, or managed users
+    """ # noqa: E501
+    id: Optional[StrictStr] = Field(default=None, description="Unique identifier for the entitlement")
+    user_id: Optional[StrictStr] = Field(default=None, description="ID of the user (if user-level entitlement)", alias="userId")
+    partner_id: Optional[StrictStr] = Field(default=None, description="ID of the partner (if partner-level entitlement)", alias="partnerId")
+    managed_user_id: Optional[StrictStr] = Field(default=None, description="ID of the managed user (if managed user-level entitlement)", alias="managedUserId")
+    feature: Optional[StrictStr] = Field(default=None, description="Feature identifier that this entitlement grants access to")
+    value: Optional[StrictStr] = Field(default=None, description="Value or limit for this feature")
+    expires_at: Optional[datetime] = Field(default=None, description="When this entitlement expires (null for permanent)", alias="expiresAt")
+    source: Optional[StrictStr] = Field(default=None, description="Source of the entitlement")
+    source_id: Optional[StrictStr] = Field(default=None, description="ID of the source object that granted this entitlement", alias="sourceId")
+    created_at: Optional[datetime] = Field(default=None, description="When the entitlement was created", alias="createdAt")
+    updated_at: Optional[datetime] = Field(default=None, description="When the entitlement was last updated", alias="updatedAt")
+    __properties: ClassVar[List[str]] = ["id", "userId", "partnerId", "managedUserId", "feature", "value", "expiresAt", "source", "sourceId", "createdAt", "updatedAt"]
+
+    @field_validator('source')
+    def source_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['subscription', 'contract', 'manual', 'marketplace', 'addon']):
+            raise ValueError("must be one of enum values ('subscription', 'contract', 'manual', 'marketplace', 'addon')")
+        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 Entitlement 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 Entitlement 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"),
+            "userId": obj.get("userId"),
+            "partnerId": obj.get("partnerId"),
+            "managedUserId": obj.get("managedUserId"),
+            "feature": obj.get("feature"),
+            "value": obj.get("value"),
+            "expiresAt": obj.get("expiresAt"),
+            "source": obj.get("source"),
+            "sourceId": obj.get("sourceId"),
+            "createdAt": obj.get("createdAt"),
+            "updatedAt": obj.get("updatedAt")
+        })
+        return _obj
+
+

api_sdk_py/models/error_detail.py

@@ -0,0 +1,104 @@
+# 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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ErrorDetail(BaseModel):
+    """
+    ErrorDetail
+    """ # noqa: E501
+    code: StrictStr = Field(description="Machine-readable error code.")
+    message: StrictStr = Field(description="Human-readable explanation.")
+    param: Optional[StrictStr] = Field(default=None, description="The field that caused the error, when one did.")
+    doc_url: Optional[StrictStr] = Field(default=None, description="Where this error is explained.", alias="docUrl")
+    suggested_action: Optional[StrictStr] = Field(default=None, description="What to do about it.", alias="suggestedAction")
+    retry_after: Optional[StrictInt] = Field(default=None, description="Seconds to wait before trying again (rate limits). The same number is in the `Retry-After` header.", alias="retryAfter")
+    details: Optional[Dict[str, Any]] = Field(default=None, description="More about the error: the fields that failed, a limit that was reached.")
+    correlation_id: Optional[StrictStr] = Field(default=None, description="Quote this when you ask support about the call.", alias="correlationId")
+    timestamp: datetime
+    __properties: ClassVar[List[str]] = ["code", "message", "param", "docUrl", "suggestedAction", "retryAfter", "details", "correlationId", "timestamp"]
+
+    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 ErrorDetail 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 ErrorDetail from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "code": obj.get("code"),
+            "message": obj.get("message"),
+            "param": obj.get("param"),
+            "docUrl": obj.get("docUrl"),
+            "suggestedAction": obj.get("suggestedAction"),
+            "retryAfter": obj.get("retryAfter"),
+            "details": obj.get("details"),
+            "correlationId": obj.get("correlationId"),
+            "timestamp": obj.get("timestamp")
+        })
+        return _obj
+
+

api_sdk_py/models/error_response.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, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List
+from api_sdk_py.models.error_detail import ErrorDetail
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ErrorResponse(BaseModel):
+    """
+    ErrorResponse
+    """ # noqa: E501
+    success: StrictBool = Field(description="Always `false` on a failure.")
+    message: StrictStr = Field(description="The same text as `error.message`, for a caller that reads one line.")
+    error: ErrorDetail
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["success", "message", "error"]
+
+    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 ErrorResponse 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.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of error
+        if self.error:
+            _dict['error'] = self.error.to_dict()
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ErrorResponse 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"),
+            "message": obj.get("message"),
+            "error": ErrorDetail.from_dict(obj["error"]) if obj.get("error") is not None else None
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

api_sdk_py/models/export_composition_entry_items200_response.py

@@ -0,0 +1,103 @@
+# 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, StrictBool
+from typing import Any, ClassVar, Dict, List
+from api_sdk_py.models.composition_entry_item import CompositionEntryItem
+from api_sdk_py.models.export_composition_entry_items200_response_meta import ExportCompositionEntryItems200ResponseMeta
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ExportCompositionEntryItems200Response(BaseModel):
+    """
+    ExportCompositionEntryItems200Response
+    """ # noqa: E501
+    success: StrictBool
+    data: List[CompositionEntryItem]
+    meta: ExportCompositionEntryItems200ResponseMeta
+    __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 ExportCompositionEntryItems200Response 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 each item in data (list)
+        _items = []
+        if self.data:
+            for _item_data in self.data:
+                if _item_data:
+                    _items.append(_item_data.to_dict())
+            _dict['data'] = _items
+        # 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 ExportCompositionEntryItems200Response 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": [CompositionEntryItem.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+            "meta": ExportCompositionEntryItems200ResponseMeta.from_dict(obj["meta"]) if obj.get("meta") is not None else None
+        })
+        return _obj
+
+