dart-tools 0.6.11__py3-none-any.whl

dart/generated/models/relationship_kind_create.py

@@ -0,0 +1,117 @@
+from typing import Any, Dict, List, Type, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.relationship_kind_kind import RelationshipKindKind
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="RelationshipKindCreate")
+
+
+@_attrs_define
+class RelationshipKindCreate:
+    """
+    Attributes:
+        duid (str):
+        directed (bool):
+        forward_text (str):
+        kind (Union[Unset, RelationshipKindKind]): * `Parent Of` - PARENT_OF
+            * `Blocks` - BLOCKS
+            * `Relates To` - RELATES_TO
+            * `Duplicates` - DUPLICATES
+            * `Custom` - CUSTOM
+        backward_text (Union[None, Unset, str]):
+    """
+
+    duid: str
+    directed: bool
+    forward_text: str
+    kind: Union[Unset, RelationshipKindKind] = UNSET
+    backward_text: Union[None, Unset, str] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        duid = self.duid
+
+        directed = self.directed
+
+        forward_text = self.forward_text
+
+        kind: Union[Unset, str] = UNSET
+        if not isinstance(self.kind, Unset):
+            kind = self.kind.value
+
+        backward_text: Union[None, Unset, str]
+        if isinstance(self.backward_text, Unset):
+            backward_text = UNSET
+        else:
+            backward_text = self.backward_text
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "duid": duid,
+                "directed": directed,
+                "forwardText": forward_text,
+            }
+        )
+        if kind is not UNSET:
+            field_dict["kind"] = kind
+        if backward_text is not UNSET:
+            field_dict["backwardText"] = backward_text
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        duid = d.pop("duid")
+
+        directed = d.pop("directed")
+
+        forward_text = d.pop("forwardText")
+
+        _kind = d.pop("kind", UNSET)
+        kind: Union[Unset, RelationshipKindKind]
+        if isinstance(_kind, Unset):
+            kind = UNSET
+        else:
+            kind = RelationshipKindKind(_kind)
+
+        def _parse_backward_text(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)
+
+        backward_text = _parse_backward_text(d.pop("backwardText", UNSET))
+
+        relationship_kind_create = cls(
+            duid=duid,
+            directed=directed,
+            forward_text=forward_text,
+            kind=kind,
+            backward_text=backward_text,
+        )
+
+        relationship_kind_create.additional_properties = d
+        return relationship_kind_create
+
+    @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/relationship_kind_kind.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class RelationshipKindKind(str, Enum):
+    BLOCKS = "Blocks"
+    CUSTOM = "Custom"
+    DUPLICATES = "Duplicates"
+    PARENT_OF = "Parent Of"
+    RELATES_TO = "Relates To"
+
+    def __str__(self) -> str:
+        return str(self.value)

dart/generated/models/relationship_kind_update.py

@@ -0,0 +1,119 @@
+from typing import Any, Dict, List, Type, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.relationship_kind_kind import RelationshipKindKind
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="RelationshipKindUpdate")
+
+
+@_attrs_define
+class RelationshipKindUpdate:
+    """
+    Attributes:
+        duid (str):
+        kind (Union[Unset, RelationshipKindKind]): * `Parent Of` - PARENT_OF
+            * `Blocks` - BLOCKS
+            * `Relates To` - RELATES_TO
+            * `Duplicates` - DUPLICATES
+            * `Custom` - CUSTOM
+        directed (Union[Unset, bool]):
+        forward_text (Union[Unset, str]):
+        backward_text (Union[None, Unset, str]):
+    """
+
+    duid: str
+    kind: Union[Unset, RelationshipKindKind] = UNSET
+    directed: Union[Unset, bool] = UNSET
+    forward_text: Union[Unset, str] = UNSET
+    backward_text: Union[None, Unset, str] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        duid = self.duid
+
+        kind: Union[Unset, str] = UNSET
+        if not isinstance(self.kind, Unset):
+            kind = self.kind.value
+
+        directed = self.directed
+
+        forward_text = self.forward_text
+
+        backward_text: Union[None, Unset, str]
+        if isinstance(self.backward_text, Unset):
+            backward_text = UNSET
+        else:
+            backward_text = self.backward_text
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "duid": duid,
+            }
+        )
+        if kind is not UNSET:
+            field_dict["kind"] = kind
+        if directed is not UNSET:
+            field_dict["directed"] = directed
+        if forward_text is not UNSET:
+            field_dict["forwardText"] = forward_text
+        if backward_text is not UNSET:
+            field_dict["backwardText"] = backward_text
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        duid = d.pop("duid")
+
+        _kind = d.pop("kind", UNSET)
+        kind: Union[Unset, RelationshipKindKind]
+        if isinstance(_kind, Unset):
+            kind = UNSET
+        else:
+            kind = RelationshipKindKind(_kind)
+
+        directed = d.pop("directed", UNSET)
+
+        forward_text = d.pop("forwardText", UNSET)
+
+        def _parse_backward_text(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)
+
+        backward_text = _parse_backward_text(d.pop("backwardText", UNSET))
+
+        relationship_kind_update = cls(
+            duid=duid,
+            kind=kind,
+            directed=directed,
+            forward_text=forward_text,
+            backward_text=backward_text,
+        )
+
+        relationship_kind_update.additional_properties = d
+        return relationship_kind_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/report_kind.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ReportKind(str, Enum):
+    CHANGELOG = "Changelog"
+    STANDUP = "Standup"
+
+    def __str__(self) -> str:
+        return str(self.value)

dart/generated/models/request_body.py

@@ -0,0 +1,80 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.transaction import Transaction
+
+
+T = TypeVar("T", bound="RequestBody")
+
+
+@_attrs_define
+class RequestBody:
+    """
+    Attributes:
+        items (List['Transaction']):
+        client_duid (str):
+    """
+
+    items: List["Transaction"]
+    client_duid: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        items = []
+        for items_item_data in self.items:
+            items_item = items_item_data.to_dict()
+            items.append(items_item)
+
+        client_duid = self.client_duid
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "items": items,
+                "clientDuid": client_duid,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.transaction import Transaction
+
+        d = src_dict.copy()
+        items = []
+        _items = d.pop("items")
+        for items_item_data in _items:
+            items_item = Transaction.from_dict(items_item_data)
+
+            items.append(items_item)
+
+        client_duid = d.pop("clientDuid")
+
+        request_body = cls(
+            items=items,
+            client_duid=client_duid,
+        )
+
+        request_body.additional_properties = d
+        return request_body
+
+    @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/response_body.py

@@ -0,0 +1,72 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.transaction_response import TransactionResponse
+
+
+T = TypeVar("T", bound="ResponseBody")
+
+
+@_attrs_define
+class ResponseBody:
+    """
+    Attributes:
+        results (List['TransactionResponse']):
+    """
+
+    results: List["TransactionResponse"]
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        results = []
+        for results_item_data in self.results:
+            results_item = results_item_data.to_dict()
+            results.append(results_item)
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "results": results,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.transaction_response import TransactionResponse
+
+        d = src_dict.copy()
+        results = []
+        _results = d.pop("results")
+        for results_item_data in _results:
+            results_item = TransactionResponse.from_dict(results_item_data)
+
+            results.append(results_item)
+
+        response_body = cls(
+            results=results,
+        )
+
+        response_body.additional_properties = d
+        return response_body
+
+    @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/saml_config.py

@@ -0,0 +1,77 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.saml_config_tenant_extension_status import SamlConfigTenantExtensionStatus
+
+T = TypeVar("T", bound="SamlConfig")
+
+
+@_attrs_define
+class SamlConfig:
+    """
+    Attributes:
+        status (SamlConfigTenantExtensionStatus): * `Disabled` - DISABLED
+            * `Enabled` - ENABLED
+        idp_url (str):
+        idp_xml (str):
+    """
+
+    status: SamlConfigTenantExtensionStatus
+    idp_url: str
+    idp_xml: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        status = self.status.value
+
+        idp_url = self.idp_url
+
+        idp_xml = self.idp_xml
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status": status,
+                "idpUrl": idp_url,
+                "idpXml": idp_xml,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        status = SamlConfigTenantExtensionStatus(d.pop("status"))
+
+        idp_url = d.pop("idpUrl")
+
+        idp_xml = d.pop("idpXml")
+
+        saml_config = cls(
+            status=status,
+            idp_url=idp_url,
+            idp_xml=idp_xml,
+        )
+
+        saml_config.additional_properties = d
+        return saml_config
+
+    @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/saml_config_tenant_extension_status.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class SamlConfigTenantExtensionStatus(str, Enum):
+    DISABLED = "Disabled"
+    ENABLED = "Enabled"
+
+    def __str__(self) -> str:
+        return str(self.value)

dart/generated/models/slack_integration.py

@@ -0,0 +1,90 @@
+from typing import Any, Dict, List, Type, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.slack_integration_tenant_extension_status import SlackIntegrationTenantExtensionStatus
+
+T = TypeVar("T", bound="SlackIntegration")
+
+
+@_attrs_define
+class SlackIntegration:
+    """
+    Attributes:
+        status (SlackIntegrationTenantExtensionStatus): * `Disabled` - DISABLED
+            * `Pending` - PENDING
+            * `Enabled` - ENABLED
+        workspace_name (Union[None, str]):
+        workspace_icon (Union[None, str]):
+    """
+
+    status: SlackIntegrationTenantExtensionStatus
+    workspace_name: Union[None, str]
+    workspace_icon: Union[None, str]
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        status = self.status.value
+
+        workspace_name: Union[None, str]
+        workspace_name = self.workspace_name
+
+        workspace_icon: Union[None, str]
+        workspace_icon = self.workspace_icon
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status": status,
+                "workspaceName": workspace_name,
+                "workspaceIcon": workspace_icon,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        status = SlackIntegrationTenantExtensionStatus(d.pop("status"))
+
+        def _parse_workspace_name(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        workspace_name = _parse_workspace_name(d.pop("workspaceName"))
+
+        def _parse_workspace_icon(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        workspace_icon = _parse_workspace_icon(d.pop("workspaceIcon"))
+
+        slack_integration = cls(
+            status=status,
+            workspace_name=workspace_name,
+            workspace_icon=workspace_icon,
+        )
+
+        slack_integration.additional_properties = d
+        return slack_integration
+
+    @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/slack_integration_tenant_extension_status.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class SlackIntegrationTenantExtensionStatus(str, Enum):
+    DISABLED = "Disabled"
+    ENABLED = "Enabled"
+    PENDING = "Pending"
+
+    def __str__(self) -> str:
+        return str(self.value)

dart/generated/models/sort.py

@@ -0,0 +1,66 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="Sort")
+
+
+@_attrs_define
+class Sort:
+    """
+    Attributes:
+        field (str):
+        is_ascending (bool):
+    """
+
+    field: str
+    is_ascending: bool
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        field = self.field
+
+        is_ascending = self.is_ascending
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "field": field,
+                "isAscending": is_ascending,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        field = d.pop("field")
+
+        is_ascending = d.pop("isAscending")
+
+        sort = cls(
+            field=field,
+            is_ascending=is_ascending,
+        )
+
+        sort.additional_properties = d
+        return sort
+
+    @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