shellrent-sdk 0.1.0__py3-none-any.whl

shellrent_sdk/client/models/recurrence.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.recurrence_frequency import RecurrenceFrequency
+
+
+T = TypeVar("T", bound="Recurrence")
+
+
+@_attrs_define
+class Recurrence:
+    recurrence_id: int
+    frequency: RecurrenceFrequency
+    days_renew: int | None
+    days_autorenew: int | None
+    days_suspension: int | None
+    days_restore: int | None
+    days_dismission: int | None
+    days_cancel: int
+    days_renew_dismission: int | None
+    days_no_secondary: int | None
+    days_no_service_change: int | None
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        recurrence_id = self.recurrence_id
+
+        frequency = self.frequency.to_dict()
+
+        days_renew: int | None
+        days_renew = self.days_renew
+
+        days_autorenew: int | None
+        days_autorenew = self.days_autorenew
+
+        days_suspension: int | None
+        days_suspension = self.days_suspension
+
+        days_restore: int | None
+        days_restore = self.days_restore
+
+        days_dismission: int | None
+        days_dismission = self.days_dismission
+
+        days_cancel = self.days_cancel
+
+        days_renew_dismission: int | None
+        days_renew_dismission = self.days_renew_dismission
+
+        days_no_secondary: int | None
+        days_no_secondary = self.days_no_secondary
+
+        days_no_service_change: int | None
+        days_no_service_change = self.days_no_service_change
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "recurrence_id": recurrence_id,
+                "frequency": frequency,
+                "days_renew": days_renew,
+                "days_autorenew": days_autorenew,
+                "days_suspension": days_suspension,
+                "days_restore": days_restore,
+                "days_dismission": days_dismission,
+                "days_cancel": days_cancel,
+                "days_renew_dismission": days_renew_dismission,
+                "days_no_secondary": days_no_secondary,
+                "days_no_service_change": days_no_service_change,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.recurrence_frequency import RecurrenceFrequency
+
+        d = dict(src_dict)
+        recurrence_id = d.pop("recurrence_id")
+
+        frequency = RecurrenceFrequency.from_dict(d.pop("frequency"))
+
+        def _parse_days_renew(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        days_renew = _parse_days_renew(d.pop("days_renew"))
+
+        def _parse_days_autorenew(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        days_autorenew = _parse_days_autorenew(d.pop("days_autorenew"))
+
+        def _parse_days_suspension(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        days_suspension = _parse_days_suspension(d.pop("days_suspension"))
+
+        def _parse_days_restore(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        days_restore = _parse_days_restore(d.pop("days_restore"))
+
+        def _parse_days_dismission(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        days_dismission = _parse_days_dismission(d.pop("days_dismission"))
+
+        days_cancel = d.pop("days_cancel")
+
+        def _parse_days_renew_dismission(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        days_renew_dismission = _parse_days_renew_dismission(d.pop("days_renew_dismission"))
+
+        def _parse_days_no_secondary(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        days_no_secondary = _parse_days_no_secondary(d.pop("days_no_secondary"))
+
+        def _parse_days_no_service_change(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        days_no_service_change = _parse_days_no_service_change(d.pop("days_no_service_change"))
+
+        recurrence = cls(
+            recurrence_id=recurrence_id,
+            frequency=frequency,
+            days_renew=days_renew,
+            days_autorenew=days_autorenew,
+            days_suspension=days_suspension,
+            days_restore=days_restore,
+            days_dismission=days_dismission,
+            days_cancel=days_cancel,
+            days_renew_dismission=days_renew_dismission,
+            days_no_secondary=days_no_secondary,
+            days_no_service_change=days_no_service_change,
+        )
+
+        recurrence.additional_properties = d
+        return recurrence
+
+    @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

shellrent_sdk/client/models/recurrence_frequency.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="RecurrenceFrequency")
+
+
+@_attrs_define
+class RecurrenceFrequency:
+    family: str
+    value: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        family = self.family
+
+        value = self.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "family": family,
+                "value": value,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        family = d.pop("family")
+
+        value = d.pop("value")
+
+        recurrence_frequency = cls(
+            family=family,
+            value=value,
+        )
+
+        recurrence_frequency.additional_properties = d
+        return recurrence_frequency
+
+    @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

shellrent_sdk/client/models/request_access_token_body.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.o_auth_audience import OAuthAudience
+from ..models.request_access_token_body_grant_type import RequestAccessTokenBodyGrantType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="RequestAccessTokenBody")
+
+
+@_attrs_define
+class RequestAccessTokenBody:
+    grant_type: RequestAccessTokenBodyGrantType
+    client_id: None | str | Unset = UNSET
+    """ Client ID se non fornito tramite Authorization header Basic. """
+    client_secret: None | str | Unset = UNSET
+    """ Client secret se non fornito tramite Authorization header Basic. """
+    scope: None | str | Unset = UNSET
+    """ Scope separati da spazio. Se omesso: tutti gli scope assegnati al client. """
+    audience: None | OAuthAudience | Unset = UNSET
+    """ Se omessa: l'unica audience del client. """
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        grant_type = self.grant_type.value
+
+        client_id: None | str | Unset
+        if isinstance(self.client_id, Unset):
+            client_id = UNSET
+        else:
+            client_id = self.client_id
+
+        client_secret: None | str | Unset
+        if isinstance(self.client_secret, Unset):
+            client_secret = UNSET
+        else:
+            client_secret = self.client_secret
+
+        scope: None | str | Unset
+        if isinstance(self.scope, Unset):
+            scope = UNSET
+        else:
+            scope = self.scope
+
+        audience: None | str | Unset
+        if isinstance(self.audience, Unset):
+            audience = UNSET
+        elif isinstance(self.audience, OAuthAudience):
+            audience = self.audience.value
+        else:
+            audience = self.audience
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "grant_type": grant_type,
+            }
+        )
+        if client_id is not UNSET:
+            field_dict["client_id"] = client_id
+        if client_secret is not UNSET:
+            field_dict["client_secret"] = client_secret
+        if scope is not UNSET:
+            field_dict["scope"] = scope
+        if audience is not UNSET:
+            field_dict["audience"] = audience
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        grant_type = RequestAccessTokenBodyGrantType(d.pop("grant_type"))
+
+        def _parse_client_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        client_id = _parse_client_id(d.pop("client_id", UNSET))
+
+        def _parse_client_secret(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        client_secret = _parse_client_secret(d.pop("client_secret", UNSET))
+
+        def _parse_scope(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        scope = _parse_scope(d.pop("scope", UNSET))
+
+        def _parse_audience(data: object) -> None | OAuthAudience | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                audience_type_0 = OAuthAudience(data)
+
+                return audience_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | OAuthAudience | Unset, data)
+
+        audience = _parse_audience(d.pop("audience", UNSET))
+
+        request_access_token_body = cls(
+            grant_type=grant_type,
+            client_id=client_id,
+            client_secret=client_secret,
+            scope=scope,
+            audience=audience,
+        )
+
+        request_access_token_body.additional_properties = d
+        return request_access_token_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

shellrent_sdk/client/models/request_access_token_body_grant_type.py

@@ -0,0 +1,8 @@
+from enum import StrEnum
+
+
+class RequestAccessTokenBodyGrantType(StrEnum):
+    CLIENT_CREDENTIALS = "client_credentials"
+
+    def __str__(self) -> str:
+        return str(self.value)

shellrent_sdk/client/models/sdi_document_status.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="SdiDocumentStatus")
+
+
+@_attrs_define
+class SdiDocumentStatus:
+    status_code: str
+    status_name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        status_code = self.status_code
+
+        status_name = self.status_name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status_code": status_code,
+                "status_name": status_name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        status_code = d.pop("status_code")
+
+        status_name = d.pop("status_name")
+
+        sdi_document_status = cls(
+            status_code=status_code,
+            status_name=status_name,
+        )
+
+        sdi_document_status.additional_properties = d
+        return sdi_document_status
+
+    @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

shellrent_sdk/client/models/sdi_document_type.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="SdiDocumentType")
+
+
+@_attrs_define
+class SdiDocumentType:
+    type_code: str
+    type_description: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_code = self.type_code
+
+        type_description = self.type_description
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type_code": type_code,
+                "type_description": type_description,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        type_code = d.pop("type_code")
+
+        type_description = d.pop("type_description")
+
+        sdi_document_type = cls(
+            type_code=type_code,
+            type_description=type_description,
+        )
+
+        sdi_document_type.additional_properties = d
+        return sdi_document_type
+
+    @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

shellrent_sdk/client/models/securemail.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="Securemail")
+
+
+@_attrs_define
+class Securemail:
+    securemail_id: int
+    purchase_id: int
+    service_name: None | str
+    purchase_name: None | str
+    purchase_status_code: None | str
+    quantity: int | None
+    domain: None | str
+    relay_to: None | str
+    relay_to_port: int | None
+    is_feasible: bool
+    provider: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        securemail_id = self.securemail_id
+
+        purchase_id = self.purchase_id
+
+        service_name: None | str
+        service_name = self.service_name
+
+        purchase_name: None | str
+        purchase_name = self.purchase_name
+
+        purchase_status_code: None | str
+        purchase_status_code = self.purchase_status_code
+
+        quantity: int | None
+        quantity = self.quantity
+
+        domain: None | str
+        domain = self.domain
+
+        relay_to: None | str
+        relay_to = self.relay_to
+
+        relay_to_port: int | None
+        relay_to_port = self.relay_to_port
+
+        is_feasible = self.is_feasible
+
+        provider = self.provider
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "securemail_id": securemail_id,
+                "purchase_id": purchase_id,
+                "service_name": service_name,
+                "purchase_name": purchase_name,
+                "purchase_status_code": purchase_status_code,
+                "quantity": quantity,
+                "domain": domain,
+                "relay_to": relay_to,
+                "relay_to_port": relay_to_port,
+                "is_feasible": is_feasible,
+                "provider": provider,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        securemail_id = d.pop("securemail_id")
+
+        purchase_id = d.pop("purchase_id")
+
+        def _parse_service_name(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        service_name = _parse_service_name(d.pop("service_name"))
+
+        def _parse_purchase_name(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        purchase_name = _parse_purchase_name(d.pop("purchase_name"))
+
+        def _parse_purchase_status_code(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        purchase_status_code = _parse_purchase_status_code(d.pop("purchase_status_code"))
+
+        def _parse_quantity(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        quantity = _parse_quantity(d.pop("quantity"))
+
+        def _parse_domain(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        domain = _parse_domain(d.pop("domain"))
+
+        def _parse_relay_to(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        relay_to = _parse_relay_to(d.pop("relay_to"))
+
+        def _parse_relay_to_port(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        relay_to_port = _parse_relay_to_port(d.pop("relay_to_port"))
+
+        is_feasible = d.pop("is_feasible")
+
+        provider = d.pop("provider")
+
+        securemail = cls(
+            securemail_id=securemail_id,
+            purchase_id=purchase_id,
+            service_name=service_name,
+            purchase_name=purchase_name,
+            purchase_status_code=purchase_status_code,
+            quantity=quantity,
+            domain=domain,
+            relay_to=relay_to,
+            relay_to_port=relay_to_port,
+            is_feasible=is_feasible,
+            provider=provider,
+        )
+
+        securemail.additional_properties = d
+        return securemail
+
+    @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