holder-python 0.2.5__py3-none-any.whl

holder/generated/models/card_patch_response.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from typing_extensions import Self
+
+if TYPE_CHECKING:
+    from ..models.card_patch_response_data import CardPatchResponseData
+
+
+T = TypeVar("T", bound="CardPatchResponse")
+
+
+@_attrs_define
+class CardPatchResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (CardPatchResponseData):
+    """
+
+    ok: bool
+    data: CardPatchResponseData
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ok = self.ok
+
+        data = self.data.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "ok": ok,
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.card_patch_response_data import (
+            CardPatchResponseData,
+        )
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = CardPatchResponseData.from_dict(d.pop("data"))
+
+        card_patch_response = cls(
+            ok=ok,
+            data=data,
+        )
+
+        card_patch_response.additional_properties = d
+        return card_patch_response
+
+    @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

holder/generated/models/card_patch_response_data.py

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

holder/generated/models/card_reference_candidate.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from typing_extensions import Self
+
+T = TypeVar("T", bound="CardReferenceCandidate")
+
+
+@_attrs_define
+class CardReferenceCandidate:
+    """
+    Attributes:
+        card_id (str): Canonical full card UUID.
+        title (str):
+        deleted_at (int | None):
+    """
+
+    card_id: str
+    title: str
+    deleted_at: int | None
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        card_id = self.card_id
+
+        title = self.title
+
+        deleted_at: int | None
+        deleted_at = self.deleted_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "card_id": card_id,
+                "title": title,
+                "deleted_at": deleted_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        card_id = d.pop("card_id")
+
+        title = d.pop("title")
+
+        def _parse_deleted_at(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        deleted_at = _parse_deleted_at(d.pop("deleted_at"))
+
+        card_reference_candidate = cls(
+            card_id=card_id,
+            title=title,
+            deleted_at=deleted_at,
+        )
+
+        card_reference_candidate.additional_properties = d
+        return card_reference_candidate
+
+    @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

holder/generated/models/card_reference_resolve_data.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from typing_extensions import Self
+
+from ..models.card_reference_resolve_data_match_kind import (
+    CardReferenceResolveDataMatchKind,
+)
+from ..models.card_reference_resolve_data_status import CardReferenceResolveDataStatus
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.card_reference_candidate import CardReferenceCandidate
+
+
+T = TypeVar("T", bound="CardReferenceResolveData")
+
+
+@_attrs_define
+class CardReferenceResolveData:
+    """
+    Attributes:
+        status (CardReferenceResolveDataStatus):
+        match_kind (CardReferenceResolveDataMatchKind | Unset): Present for resolved and ambiguous results.
+        card (CardReferenceCandidate | Unset):
+        candidates (list[CardReferenceCandidate] | Unset): Present for an ambiguous result and contains two candidates.
+    """
+
+    status: CardReferenceResolveDataStatus
+    match_kind: CardReferenceResolveDataMatchKind | Unset = UNSET
+    card: CardReferenceCandidate | Unset = UNSET
+    candidates: list[CardReferenceCandidate] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        status = self.status.value
+
+        match_kind: str | Unset = UNSET
+        if not isinstance(self.match_kind, Unset):
+            match_kind = self.match_kind.value
+
+        card: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.card, Unset):
+            card = self.card.to_dict()
+
+        candidates: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.candidates, Unset):
+            candidates = []
+            for candidates_item_data in self.candidates:
+                candidates_item = candidates_item_data.to_dict()
+                candidates.append(candidates_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status": status,
+            }
+        )
+        if match_kind is not UNSET:
+            field_dict["match_kind"] = match_kind
+        if card is not UNSET:
+            field_dict["card"] = card
+        if candidates is not UNSET:
+            field_dict["candidates"] = candidates
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.card_reference_candidate import (
+            CardReferenceCandidate,
+        )
+
+        d = dict(src_dict)
+        status = CardReferenceResolveDataStatus(d.pop("status"))
+
+        _match_kind = d.pop("match_kind", UNSET)
+        match_kind: CardReferenceResolveDataMatchKind | Unset
+        if isinstance(_match_kind, Unset):
+            match_kind = UNSET
+        else:
+            match_kind = CardReferenceResolveDataMatchKind(_match_kind)
+
+        _card = d.pop("card", UNSET)
+        card: CardReferenceCandidate | Unset
+        if isinstance(_card, Unset):
+            card = UNSET
+        else:
+            card = CardReferenceCandidate.from_dict(_card)
+
+        _candidates = d.pop("candidates", UNSET)
+        candidates: list[CardReferenceCandidate] | Unset = UNSET
+        if _candidates is not UNSET:
+            candidates = []
+            for candidates_item_data in _candidates:
+                candidates_item = CardReferenceCandidate.from_dict(candidates_item_data)
+
+                candidates.append(candidates_item)
+
+        card_reference_resolve_data = cls(
+            status=status,
+            match_kind=match_kind,
+            card=card,
+            candidates=candidates,
+        )
+
+        card_reference_resolve_data.additional_properties = d
+        return card_reference_resolve_data
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

holder/generated/models/card_reference_resolve_data_match_kind.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+
+class CardReferenceResolveDataMatchKind(StrEnum):
+    EXACT_TITLE = "exact_title"
+    FULL_ID = "full_id"
+    ID_PREFIX = "id_prefix"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/card_reference_resolve_data_status.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+
+class CardReferenceResolveDataStatus(StrEnum):
+    AMBIGUOUS = "ambiguous"
+    NOT_FOUND = "not_found"
+    RESOLVED = "resolved"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/card_reference_resolve_request.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from typing_extensions import Self
+
+from ..models.card_reference_resolve_request_scope import (
+    CardReferenceResolveRequestScope,
+)
+
+T = TypeVar("T", bound="CardReferenceResolveRequest")
+
+
+@_attrs_define
+class CardReferenceResolveRequest:
+    """
+    Attributes:
+        project_id (str):
+        reference (str): Full canonical UUID, eligible UUID prefix, or exact card title.
+        scope (CardReferenceResolveRequestScope):
+    """
+
+    project_id: str
+    reference: str
+    scope: CardReferenceResolveRequestScope
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        project_id = self.project_id
+
+        reference = self.reference
+
+        scope = self.scope.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "project_id": project_id,
+                "reference": reference,
+                "scope": scope,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        project_id = d.pop("project_id")
+
+        reference = d.pop("reference")
+
+        scope = CardReferenceResolveRequestScope(d.pop("scope"))
+
+        card_reference_resolve_request = cls(
+            project_id=project_id,
+            reference=reference,
+            scope=scope,
+        )
+
+        card_reference_resolve_request.additional_properties = d
+        return card_reference_resolve_request
+
+    @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

holder/generated/models/card_reference_resolve_request_scope.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+
+class CardReferenceResolveRequestScope(StrEnum):
+    EITHER = "either"
+    LIVE = "live"
+    TRASHED = "trashed"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/card_reference_resolve_response.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from typing_extensions import Self
+
+if TYPE_CHECKING:
+    from ..models.card_reference_resolve_data import CardReferenceResolveData
+
+
+T = TypeVar("T", bound="CardReferenceResolveResponse")
+
+
+@_attrs_define
+class CardReferenceResolveResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (CardReferenceResolveData):
+    """
+
+    ok: bool
+    data: CardReferenceResolveData
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ok = self.ok
+
+        data = self.data.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "ok": ok,
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.card_reference_resolve_data import (
+            CardReferenceResolveData,
+        )
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = CardReferenceResolveData.from_dict(d.pop("data"))
+
+        card_reference_resolve_response = cls(
+            ok=ok,
+            data=data,
+        )
+
+        card_reference_resolve_response.additional_properties = d
+        return card_reference_resolve_response
+
+    @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

holder/generated/models/card_tag_mutation_request.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from typing_extensions import Self
+
+T = TypeVar("T", bound="CardTagMutationRequest")
+
+
+@_attrs_define
+class CardTagMutationRequest:
+    """
+    Attributes:
+        project_id (str): Project that must own the live card.
+        tag (str): Tag without the leading
+    """
+
+    project_id: str
+    tag: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        project_id = self.project_id
+
+        tag = self.tag
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "project_id": project_id,
+                "tag": tag,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        project_id = d.pop("project_id")
+
+        tag = d.pop("tag")
+
+        card_tag_mutation_request = cls(
+            project_id=project_id,
+            tag=tag,
+        )
+
+        card_tag_mutation_request.additional_properties = d
+        return card_tag_mutation_request
+
+    @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

holder/generated/models/card_tag_mutation_response.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from typing_extensions import Self
+
+if TYPE_CHECKING:
+    from ..models.card_tag_mutation_result import CardTagMutationResult
+
+
+T = TypeVar("T", bound="CardTagMutationResponse")
+
+
+@_attrs_define
+class CardTagMutationResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (CardTagMutationResult):
+    """
+
+    ok: bool
+    data: CardTagMutationResult
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ok = self.ok
+
+        data = self.data.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "ok": ok,
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.card_tag_mutation_result import (
+            CardTagMutationResult,
+        )
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = CardTagMutationResult.from_dict(d.pop("data"))
+
+        card_tag_mutation_response = cls(
+            ok=ok,
+            data=data,
+        )
+
+        card_tag_mutation_response.additional_properties = d
+        return card_tag_mutation_response
+
+    @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