dart-tools 0.6.6__py3-none-any.whl

dart/generated/models/tenant.py

@@ -0,0 +1,378 @@
+import datetime
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.subscription import Subscription
+
+if TYPE_CHECKING:
+    from ..models.discord_integration import DiscordIntegration
+    from ..models.github_integration import GithubIntegration
+    from ..models.notion_integration import NotionIntegration
+    from ..models.saml_config import SamlConfig
+    from ..models.slack_integration import SlackIntegration
+    from ..models.zapier_integration import ZapierIntegration
+
+
+T = TypeVar("T", bound="Tenant")
+
+
+@_attrs_define
+class Tenant:
+    """
+    Attributes:
+        duid (str):
+        is_dart (bool):
+        name (str):
+        created_at (datetime.datetime):
+        timezone (str):
+        subscription (Subscription): * `Personal` - PERSONAL
+            * `Premium` - PREMIUM
+        entitlement_overrides (Any):
+        image_url (Union[None, str]):
+        backlog_enabled (bool):
+        ai_assignment_enabled (bool):
+        email_integration_enabled (bool):
+        close_parent_on_close_all_subtasks (bool):
+        move_subtasks_on_move_parent (bool):
+        update_subtasks_status_on_update_parent_status (bool):
+        copy_parent_fields_on_create (bool):
+        update_blockee_dates_on_update_blocker_due_date (bool):
+        webhook_enabled (bool):
+        webhook_secret (str):
+        saml_config (Union['SamlConfig', None]):
+        notion_integration (Union['NotionIntegration', None]):
+        slack_integration (Union['SlackIntegration', None]):
+        discord_integration (Union['DiscordIntegration', None]):
+        github_integration (Union['GithubIntegration', None]):
+        zapier_integration (Union['ZapierIntegration', None]):
+    """
+
+    duid: str
+    is_dart: bool
+    name: str
+    created_at: datetime.datetime
+    timezone: str
+    subscription: Subscription
+    entitlement_overrides: Any
+    image_url: Union[None, str]
+    backlog_enabled: bool
+    ai_assignment_enabled: bool
+    email_integration_enabled: bool
+    close_parent_on_close_all_subtasks: bool
+    move_subtasks_on_move_parent: bool
+    update_subtasks_status_on_update_parent_status: bool
+    copy_parent_fields_on_create: bool
+    update_blockee_dates_on_update_blocker_due_date: bool
+    webhook_enabled: bool
+    webhook_secret: str
+    saml_config: Union["SamlConfig", None]
+    notion_integration: Union["NotionIntegration", None]
+    slack_integration: Union["SlackIntegration", None]
+    discord_integration: Union["DiscordIntegration", None]
+    github_integration: Union["GithubIntegration", None]
+    zapier_integration: Union["ZapierIntegration", None]
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        from ..models.discord_integration import DiscordIntegration
+        from ..models.github_integration import GithubIntegration
+        from ..models.notion_integration import NotionIntegration
+        from ..models.saml_config import SamlConfig
+        from ..models.slack_integration import SlackIntegration
+        from ..models.zapier_integration import ZapierIntegration
+
+        duid = self.duid
+
+        is_dart = self.is_dart
+
+        name = self.name
+
+        created_at = self.created_at.isoformat()
+
+        timezone = self.timezone
+
+        subscription = self.subscription.value
+
+        entitlement_overrides = self.entitlement_overrides
+
+        image_url: Union[None, str]
+        image_url = self.image_url
+
+        backlog_enabled = self.backlog_enabled
+
+        ai_assignment_enabled = self.ai_assignment_enabled
+
+        email_integration_enabled = self.email_integration_enabled
+
+        close_parent_on_close_all_subtasks = self.close_parent_on_close_all_subtasks
+
+        move_subtasks_on_move_parent = self.move_subtasks_on_move_parent
+
+        update_subtasks_status_on_update_parent_status = self.update_subtasks_status_on_update_parent_status
+
+        copy_parent_fields_on_create = self.copy_parent_fields_on_create
+
+        update_blockee_dates_on_update_blocker_due_date = self.update_blockee_dates_on_update_blocker_due_date
+
+        webhook_enabled = self.webhook_enabled
+
+        webhook_secret = self.webhook_secret
+
+        saml_config: Union[Dict[str, Any], None]
+        if isinstance(self.saml_config, SamlConfig):
+            saml_config = self.saml_config.to_dict()
+        else:
+            saml_config = self.saml_config
+
+        notion_integration: Union[Dict[str, Any], None]
+        if isinstance(self.notion_integration, NotionIntegration):
+            notion_integration = self.notion_integration.to_dict()
+        else:
+            notion_integration = self.notion_integration
+
+        slack_integration: Union[Dict[str, Any], None]
+        if isinstance(self.slack_integration, SlackIntegration):
+            slack_integration = self.slack_integration.to_dict()
+        else:
+            slack_integration = self.slack_integration
+
+        discord_integration: Union[Dict[str, Any], None]
+        if isinstance(self.discord_integration, DiscordIntegration):
+            discord_integration = self.discord_integration.to_dict()
+        else:
+            discord_integration = self.discord_integration
+
+        github_integration: Union[Dict[str, Any], None]
+        if isinstance(self.github_integration, GithubIntegration):
+            github_integration = self.github_integration.to_dict()
+        else:
+            github_integration = self.github_integration
+
+        zapier_integration: Union[Dict[str, Any], None]
+        if isinstance(self.zapier_integration, ZapierIntegration):
+            zapier_integration = self.zapier_integration.to_dict()
+        else:
+            zapier_integration = self.zapier_integration
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "duid": duid,
+                "isDart": is_dart,
+                "name": name,
+                "createdAt": created_at,
+                "timezone": timezone,
+                "subscription": subscription,
+                "entitlementOverrides": entitlement_overrides,
+                "imageUrl": image_url,
+                "backlogEnabled": backlog_enabled,
+                "aiAssignmentEnabled": ai_assignment_enabled,
+                "emailIntegrationEnabled": email_integration_enabled,
+                "closeParentOnCloseAllSubtasks": close_parent_on_close_all_subtasks,
+                "moveSubtasksOnMoveParent": move_subtasks_on_move_parent,
+                "updateSubtasksStatusOnUpdateParentStatus": update_subtasks_status_on_update_parent_status,
+                "copyParentFieldsOnCreate": copy_parent_fields_on_create,
+                "updateBlockeeDatesOnUpdateBlockerDueDate": update_blockee_dates_on_update_blocker_due_date,
+                "webhookEnabled": webhook_enabled,
+                "webhookSecret": webhook_secret,
+                "samlConfig": saml_config,
+                "notionIntegration": notion_integration,
+                "slackIntegration": slack_integration,
+                "discordIntegration": discord_integration,
+                "githubIntegration": github_integration,
+                "zapierIntegration": zapier_integration,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.discord_integration import DiscordIntegration
+        from ..models.github_integration import GithubIntegration
+        from ..models.notion_integration import NotionIntegration
+        from ..models.saml_config import SamlConfig
+        from ..models.slack_integration import SlackIntegration
+        from ..models.zapier_integration import ZapierIntegration
+
+        d = src_dict.copy()
+        duid = d.pop("duid")
+
+        is_dart = d.pop("isDart")
+
+        name = d.pop("name")
+
+        created_at = isoparse(d.pop("createdAt"))
+
+        timezone = d.pop("timezone")
+
+        subscription = Subscription(d.pop("subscription"))
+
+        entitlement_overrides = d.pop("entitlementOverrides")
+
+        def _parse_image_url(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        image_url = _parse_image_url(d.pop("imageUrl"))
+
+        backlog_enabled = d.pop("backlogEnabled")
+
+        ai_assignment_enabled = d.pop("aiAssignmentEnabled")
+
+        email_integration_enabled = d.pop("emailIntegrationEnabled")
+
+        close_parent_on_close_all_subtasks = d.pop("closeParentOnCloseAllSubtasks")
+
+        move_subtasks_on_move_parent = d.pop("moveSubtasksOnMoveParent")
+
+        update_subtasks_status_on_update_parent_status = d.pop("updateSubtasksStatusOnUpdateParentStatus")
+
+        copy_parent_fields_on_create = d.pop("copyParentFieldsOnCreate")
+
+        update_blockee_dates_on_update_blocker_due_date = d.pop("updateBlockeeDatesOnUpdateBlockerDueDate")
+
+        webhook_enabled = d.pop("webhookEnabled")
+
+        webhook_secret = d.pop("webhookSecret")
+
+        def _parse_saml_config(data: object) -> Union["SamlConfig", None]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                saml_config_type_0 = SamlConfig.from_dict(data)
+
+                return saml_config_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["SamlConfig", None], data)
+
+        saml_config = _parse_saml_config(d.pop("samlConfig"))
+
+        def _parse_notion_integration(data: object) -> Union["NotionIntegration", None]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                notion_integration_type_0 = NotionIntegration.from_dict(data)
+
+                return notion_integration_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["NotionIntegration", None], data)
+
+        notion_integration = _parse_notion_integration(d.pop("notionIntegration"))
+
+        def _parse_slack_integration(data: object) -> Union["SlackIntegration", None]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                slack_integration_type_0 = SlackIntegration.from_dict(data)
+
+                return slack_integration_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["SlackIntegration", None], data)
+
+        slack_integration = _parse_slack_integration(d.pop("slackIntegration"))
+
+        def _parse_discord_integration(data: object) -> Union["DiscordIntegration", None]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                discord_integration_type_0 = DiscordIntegration.from_dict(data)
+
+                return discord_integration_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["DiscordIntegration", None], data)
+
+        discord_integration = _parse_discord_integration(d.pop("discordIntegration"))
+
+        def _parse_github_integration(data: object) -> Union["GithubIntegration", None]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                github_integration_type_0 = GithubIntegration.from_dict(data)
+
+                return github_integration_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["GithubIntegration", None], data)
+
+        github_integration = _parse_github_integration(d.pop("githubIntegration"))
+
+        def _parse_zapier_integration(data: object) -> Union["ZapierIntegration", None]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                zapier_integration_type_0 = ZapierIntegration.from_dict(data)
+
+                return zapier_integration_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["ZapierIntegration", None], data)
+
+        zapier_integration = _parse_zapier_integration(d.pop("zapierIntegration"))
+
+        tenant = cls(
+            duid=duid,
+            is_dart=is_dart,
+            name=name,
+            created_at=created_at,
+            timezone=timezone,
+            subscription=subscription,
+            entitlement_overrides=entitlement_overrides,
+            image_url=image_url,
+            backlog_enabled=backlog_enabled,
+            ai_assignment_enabled=ai_assignment_enabled,
+            email_integration_enabled=email_integration_enabled,
+            close_parent_on_close_all_subtasks=close_parent_on_close_all_subtasks,
+            move_subtasks_on_move_parent=move_subtasks_on_move_parent,
+            update_subtasks_status_on_update_parent_status=update_subtasks_status_on_update_parent_status,
+            copy_parent_fields_on_create=copy_parent_fields_on_create,
+            update_blockee_dates_on_update_blocker_due_date=update_blockee_dates_on_update_blocker_due_date,
+            webhook_enabled=webhook_enabled,
+            webhook_secret=webhook_secret,
+            saml_config=saml_config,
+            notion_integration=notion_integration,
+            slack_integration=slack_integration,
+            discord_integration=discord_integration,
+            github_integration=github_integration,
+            zapier_integration=zapier_integration,
+        )
+
+        tenant.additional_properties = d
+        return tenant
+
+    @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

dart/generated/models/tenant_update.py

@@ -0,0 +1,157 @@
+from typing import Any, Dict, List, Type, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="TenantUpdate")
+
+
+@_attrs_define
+class TenantUpdate:
+    """
+    Attributes:
+        name (Union[Unset, str]):
+        timezone (Union[Unset, str]):
+        backlog_enabled (Union[Unset, bool]):
+        ai_assignment_enabled (Union[Unset, bool]):
+        email_integration_enabled (Union[Unset, bool]):
+        close_parent_on_close_all_subtasks (Union[Unset, bool]):
+        move_subtasks_on_move_parent (Union[Unset, bool]):
+        update_subtasks_status_on_update_parent_status (Union[Unset, bool]):
+        copy_parent_fields_on_create (Union[Unset, bool]):
+        update_blockee_dates_on_update_blocker_due_date (Union[Unset, bool]):
+        webhook_enabled (Union[Unset, bool]):
+        webhook_secret (Union[Unset, str]):
+    """
+
+    name: Union[Unset, str] = UNSET
+    timezone: Union[Unset, str] = UNSET
+    backlog_enabled: Union[Unset, bool] = UNSET
+    ai_assignment_enabled: Union[Unset, bool] = UNSET
+    email_integration_enabled: Union[Unset, bool] = UNSET
+    close_parent_on_close_all_subtasks: Union[Unset, bool] = UNSET
+    move_subtasks_on_move_parent: Union[Unset, bool] = UNSET
+    update_subtasks_status_on_update_parent_status: Union[Unset, bool] = UNSET
+    copy_parent_fields_on_create: Union[Unset, bool] = UNSET
+    update_blockee_dates_on_update_blocker_due_date: Union[Unset, bool] = UNSET
+    webhook_enabled: Union[Unset, bool] = UNSET
+    webhook_secret: Union[Unset, str] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        name = self.name
+
+        timezone = self.timezone
+
+        backlog_enabled = self.backlog_enabled
+
+        ai_assignment_enabled = self.ai_assignment_enabled
+
+        email_integration_enabled = self.email_integration_enabled
+
+        close_parent_on_close_all_subtasks = self.close_parent_on_close_all_subtasks
+
+        move_subtasks_on_move_parent = self.move_subtasks_on_move_parent
+
+        update_subtasks_status_on_update_parent_status = self.update_subtasks_status_on_update_parent_status
+
+        copy_parent_fields_on_create = self.copy_parent_fields_on_create
+
+        update_blockee_dates_on_update_blocker_due_date = self.update_blockee_dates_on_update_blocker_due_date
+
+        webhook_enabled = self.webhook_enabled
+
+        webhook_secret = self.webhook_secret
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+        if timezone is not UNSET:
+            field_dict["timezone"] = timezone
+        if backlog_enabled is not UNSET:
+            field_dict["backlogEnabled"] = backlog_enabled
+        if ai_assignment_enabled is not UNSET:
+            field_dict["aiAssignmentEnabled"] = ai_assignment_enabled
+        if email_integration_enabled is not UNSET:
+            field_dict["emailIntegrationEnabled"] = email_integration_enabled
+        if close_parent_on_close_all_subtasks is not UNSET:
+            field_dict["closeParentOnCloseAllSubtasks"] = close_parent_on_close_all_subtasks
+        if move_subtasks_on_move_parent is not UNSET:
+            field_dict["moveSubtasksOnMoveParent"] = move_subtasks_on_move_parent
+        if update_subtasks_status_on_update_parent_status is not UNSET:
+            field_dict["updateSubtasksStatusOnUpdateParentStatus"] = update_subtasks_status_on_update_parent_status
+        if copy_parent_fields_on_create is not UNSET:
+            field_dict["copyParentFieldsOnCreate"] = copy_parent_fields_on_create
+        if update_blockee_dates_on_update_blocker_due_date is not UNSET:
+            field_dict["updateBlockeeDatesOnUpdateBlockerDueDate"] = update_blockee_dates_on_update_blocker_due_date
+        if webhook_enabled is not UNSET:
+            field_dict["webhookEnabled"] = webhook_enabled
+        if webhook_secret is not UNSET:
+            field_dict["webhookSecret"] = webhook_secret
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        name = d.pop("name", UNSET)
+
+        timezone = d.pop("timezone", UNSET)
+
+        backlog_enabled = d.pop("backlogEnabled", UNSET)
+
+        ai_assignment_enabled = d.pop("aiAssignmentEnabled", UNSET)
+
+        email_integration_enabled = d.pop("emailIntegrationEnabled", UNSET)
+
+        close_parent_on_close_all_subtasks = d.pop("closeParentOnCloseAllSubtasks", UNSET)
+
+        move_subtasks_on_move_parent = d.pop("moveSubtasksOnMoveParent", UNSET)
+
+        update_subtasks_status_on_update_parent_status = d.pop("updateSubtasksStatusOnUpdateParentStatus", UNSET)
+
+        copy_parent_fields_on_create = d.pop("copyParentFieldsOnCreate", UNSET)
+
+        update_blockee_dates_on_update_blocker_due_date = d.pop("updateBlockeeDatesOnUpdateBlockerDueDate", UNSET)
+
+        webhook_enabled = d.pop("webhookEnabled", UNSET)
+
+        webhook_secret = d.pop("webhookSecret", UNSET)
+
+        tenant_update = cls(
+            name=name,
+            timezone=timezone,
+            backlog_enabled=backlog_enabled,
+            ai_assignment_enabled=ai_assignment_enabled,
+            email_integration_enabled=email_integration_enabled,
+            close_parent_on_close_all_subtasks=close_parent_on_close_all_subtasks,
+            move_subtasks_on_move_parent=move_subtasks_on_move_parent,
+            update_subtasks_status_on_update_parent_status=update_subtasks_status_on_update_parent_status,
+            copy_parent_fields_on_create=copy_parent_fields_on_create,
+            update_blockee_dates_on_update_blocker_due_date=update_blockee_dates_on_update_blocker_due_date,
+            webhook_enabled=webhook_enabled,
+            webhook_secret=webhook_secret,
+        )
+
+        tenant_update.additional_properties = d
+        return tenant_update
+
+    @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

dart/generated/models/theme.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class Theme(str, Enum):
+    DARK = "Dark"
+    LIGHT = "Light"
+    SYSTEM_DEFAULT = "System Default"
+
+    def __str__(self) -> str:
+        return str(self.value)

dart/generated/models/transaction.py

@@ -0,0 +1,155 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.transaction_kind import TransactionKind
+
+if TYPE_CHECKING:
+    from ..models.operation import Operation
+
+
+T = TypeVar("T", bound="Transaction")
+
+
+@_attrs_define
+class Transaction:
+    """
+    Attributes:
+        duid (str):
+        kind (TransactionKind): * `brainstorm_create` - BRAINSTORM_CREATE
+            * `brainstorm_delete` - BRAINSTORM_DELETE
+            * `brainstorm_update` - BRAINSTORM_UPDATE
+            * `comment_create` - COMMENT_CREATE
+            * `comment_update` - COMMENT_UPDATE
+            * `comment_delete` - COMMENT_DELETE
+            * `comment_reaction_create` - COMMENT_REACTION_CREATE
+            * `comment_reaction_delete` - COMMENT_REACTION_DELETE
+            * `sprint_rollover` - SPRINT_ROLLOVER
+            * `dartboard_create` - DARTBOARD_CREATE
+            * `dartboard_delete` - DARTBOARD_DELETE
+            * `dartboard_update` - DARTBOARD_UPDATE
+            * `dashboard_create` - DASHBOARD_CREATE
+            * `dashboard_delete` - DASHBOARD_DELETE
+            * `dashboard_update` - DASHBOARD_UPDATE
+            * `doc_create` - DOC_CREATE
+            * `doc_delete` - DOC_DELETE
+            * `doc_update` - DOC_UPDATE
+            * `event_create` - EVENT_CREATE
+            * `folder_create` - FOLDER_CREATE
+            * `folder_delete` - FOLDER_DELETE
+            * `folder_update` - FOLDER_UPDATE
+            * `form_create` - FORM_CREATE
+            * `form_delete` - FORM_DELETE
+            * `form_update` - FORM_UPDATE
+            * `layout_create` - LAYOUT_CREATE
+            * `layout_delete` - LAYOUT_DELETE
+            * `layout_update` - LAYOUT_UPDATE
+            * `notification_update` - NOTIFICATION_UPDATE
+            * `option_create` - OPTION_CREATE
+            * `option_delete` - OPTION_DELETE
+            * `option_update` - OPTION_UPDATE
+            * `property_create` - PROPERTY_CREATE
+            * `property_update` - PROPERTY_UPDATE
+            * `property_delete` - PROPERTY_DELETE
+            * `relationship_create` - RELATIONSHIP_CREATE
+            * `relationship_update` - RELATIONSHIP_UPDATE
+            * `relationship_delete` - RELATIONSHIP_DELETE
+            * `space_create` - SPACE_CREATE
+            * `space_update_perms` - SPACE_UPDATE_PERMS
+            * `space_update_other` - SPACE_UPDATE_OTHER
+            * `space_delete` - SPACE_DELETE
+            * `status_create` - STATUS_CREATE
+            * `status_delete` - STATUS_DELETE
+            * `status_update` - STATUS_UPDATE
+            * `task_complete` - TASK_COMPLETE
+            * `task_create` - TASK_CREATE
+            * `task_delete` - TASK_DELETE
+            * `task_rename` - TASK_RENAME
+            * `task_update` - TASK_UPDATE
+            * `task_doc_relationship_create` - TASK_DOC_RELATIONSHIP_CREATE
+            * `task_doc_relationship_delete` - TASK_DOC_RELATIONSHIP_DELETE
+            * `task_kind_create` - TASK_KIND_CREATE
+            * `task_kind_delete` - TASK_KIND_DELETE
+            * `task_kind_update` - TASK_KIND_UPDATE
+            * `tenant_update` - TENANT_UPDATE
+            * `user_dartboard_layout_create` - USER_DARTBOARD_LAYOUT_CREATE
+            * `user_dartboard_layout_delete` - USER_DARTBOARD_LAYOUT_DELETE
+            * `user_dartboard_layout_update` - USER_DARTBOARD_LAYOUT_UPDATE
+            * `user_update` - USER_UPDATE
+            * `view_create` - VIEW_CREATE
+            * `view_delete` - VIEW_DELETE
+            * `view_update` - VIEW_UPDATE
+            * `webhook_create` - WEBHOOK_CREATE
+            * `webhook_delete` - WEBHOOK_DELETE
+            * `webhook_update` - WEBHOOK_UPDATE
+        operations (List['Operation']):
+    """
+
+    duid: str
+    kind: TransactionKind
+    operations: List["Operation"]
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        duid = self.duid
+
+        kind = self.kind.value
+
+        operations = []
+        for operations_item_data in self.operations:
+            operations_item = operations_item_data.to_dict()
+            operations.append(operations_item)
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "duid": duid,
+                "kind": kind,
+                "operations": operations,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.operation import Operation
+
+        d = src_dict.copy()
+        duid = d.pop("duid")
+
+        kind = TransactionKind(d.pop("kind"))
+
+        operations = []
+        _operations = d.pop("operations")
+        for operations_item_data in _operations:
+            operations_item = Operation.from_dict(operations_item_data)
+
+            operations.append(operations_item)
+
+        transaction = cls(
+            duid=duid,
+            kind=kind,
+            operations=operations,
+        )
+
+        transaction.additional_properties = d
+        return transaction
+
+    @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