statuspro-openapi-client 0.1.0__py3-none-any.whl

statuspro_public_api_client/models/locale_translation.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import (
+    define as _attrs_define,
+    field as _attrs_field,
+)
+
+from ..client_types import UNSET, Unset
+
+T = TypeVar("T", bound="LocaleTranslation")
+
+
+@_attrs_define
+class LocaleTranslation:
+    name: str | Unset = UNSET
+    description: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        description = self.description
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+        if description is not UNSET:
+            field_dict["description"] = description
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name", UNSET)
+
+        description = d.pop("description", UNSET)
+
+        locale_translation = cls(
+            name=name,
+            description=description,
+        )
+
+        locale_translation.additional_properties = d
+        return locale_translation
+
+    @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

statuspro_public_api_client/models/mail_log.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,
+    field as _attrs_field,
+)
+
+from ..client_types import UNSET, Unset
+
+T = TypeVar("T", bound="MailLog")
+
+
+@_attrs_define
+class MailLog:
+    from_: str | Unset = UNSET
+    to: str | Unset = UNSET
+    subject: str | Unset = UNSET
+    delivery_status: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from_ = self.from_
+
+        to = self.to
+
+        subject = self.subject
+
+        delivery_status = self.delivery_status
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if from_ is not UNSET:
+            field_dict["from"] = from_
+        if to is not UNSET:
+            field_dict["to"] = to
+        if subject is not UNSET:
+            field_dict["subject"] = subject
+        if delivery_status is not UNSET:
+            field_dict["delivery_status"] = delivery_status
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        from_ = d.pop("from", UNSET)
+
+        to = d.pop("to", UNSET)
+
+        subject = d.pop("subject", UNSET)
+
+        delivery_status = d.pop("delivery_status", UNSET)
+
+        mail_log = cls(
+            from_=from_,
+            to=to,
+            subject=subject,
+            delivery_status=delivery_status,
+        )
+
+        mail_log.additional_properties = d
+        return mail_log
+
+    @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

statuspro_public_api_client/models/message_response.py

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

statuspro_public_api_client/models/order_list_item.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import (
+    define as _attrs_define,
+    field as _attrs_field,
+)
+from dateutil.parser import isoparse
+
+from ..client_types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.customer import Customer
+    from ..models.status import Status
+
+
+T = TypeVar("T", bound="OrderListItem")
+
+
+@_attrs_define
+class OrderListItem:
+    id: int | Unset = UNSET
+    name: str | Unset = UNSET
+    order_number: str | Unset = UNSET
+    customer: Customer | Unset = UNSET
+    status: Status | Unset = UNSET
+    due_date: datetime.datetime | None | Unset = UNSET
+    due_date_to: datetime.datetime | None | Unset = UNSET
+    history_count: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        name = self.name
+
+        order_number = self.order_number
+
+        customer: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.customer, Unset):
+            customer = self.customer.to_dict()
+
+        status: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.status, Unset):
+            status = self.status.to_dict()
+
+        due_date: None | str | Unset
+        if isinstance(self.due_date, Unset):
+            due_date = UNSET
+        elif isinstance(self.due_date, datetime.datetime):
+            due_date = self.due_date.isoformat()
+        else:
+            due_date = self.due_date
+
+        due_date_to: None | str | Unset
+        if isinstance(self.due_date_to, Unset):
+            due_date_to = UNSET
+        elif isinstance(self.due_date_to, datetime.datetime):
+            due_date_to = self.due_date_to.isoformat()
+        else:
+            due_date_to = self.due_date_to
+
+        history_count = self.history_count
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if id is not UNSET:
+            field_dict["id"] = id
+        if name is not UNSET:
+            field_dict["name"] = name
+        if order_number is not UNSET:
+            field_dict["order_number"] = order_number
+        if customer is not UNSET:
+            field_dict["customer"] = customer
+        if status is not UNSET:
+            field_dict["status"] = status
+        if due_date is not UNSET:
+            field_dict["due_date"] = due_date
+        if due_date_to is not UNSET:
+            field_dict["due_date_to"] = due_date_to
+        if history_count is not UNSET:
+            field_dict["history_count"] = history_count
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.customer import Customer
+        from ..models.status import Status
+
+        d = dict(src_dict)
+        id = d.pop("id", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        order_number = d.pop("order_number", UNSET)
+
+        _customer = d.pop("customer", UNSET)
+        customer: Customer | Unset
+        if isinstance(_customer, Unset):
+            customer = UNSET
+        else:
+            customer = Customer.from_dict(_customer)
+
+        _status = d.pop("status", UNSET)
+        status: Status | Unset
+        if isinstance(_status, Unset):
+            status = UNSET
+        else:
+            status = Status.from_dict(_status)
+
+        def _parse_due_date(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                due_date_type_0 = isoparse(data)
+
+                return due_date_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        due_date = _parse_due_date(d.pop("due_date", UNSET))
+
+        def _parse_due_date_to(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                due_date_to_type_0 = isoparse(data)
+
+                return due_date_to_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        due_date_to = _parse_due_date_to(d.pop("due_date_to", UNSET))
+
+        history_count = d.pop("history_count", UNSET)
+
+        order_list_item = cls(
+            id=id,
+            name=name,
+            order_number=order_number,
+            customer=customer,
+            status=status,
+            due_date=due_date,
+            due_date_to=due_date_to,
+            history_count=history_count,
+        )
+
+        order_list_item.additional_properties = d
+        return order_list_item
+
+    @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

statuspro_public_api_client/models/order_list_meta.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import (
+    define as _attrs_define,
+    field as _attrs_field,
+)
+
+from ..client_types import UNSET, Unset
+
+T = TypeVar("T", bound="OrderListMeta")
+
+
+@_attrs_define
+class OrderListMeta:
+    current_page: int | Unset = UNSET
+    from_: int | None | Unset = UNSET
+    last_page: int | Unset = UNSET
+    per_page: int | Unset = UNSET
+    to: int | None | Unset = UNSET
+    total: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        current_page = self.current_page
+
+        from_: int | None | Unset
+        if isinstance(self.from_, Unset):
+            from_ = UNSET
+        else:
+            from_ = self.from_
+
+        last_page = self.last_page
+
+        per_page = self.per_page
+
+        to: int | None | Unset
+        if isinstance(self.to, Unset):
+            to = UNSET
+        else:
+            to = self.to
+
+        total = self.total
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if current_page is not UNSET:
+            field_dict["current_page"] = current_page
+        if from_ is not UNSET:
+            field_dict["from"] = from_
+        if last_page is not UNSET:
+            field_dict["last_page"] = last_page
+        if per_page is not UNSET:
+            field_dict["per_page"] = per_page
+        if to is not UNSET:
+            field_dict["to"] = to
+        if total is not UNSET:
+            field_dict["total"] = total
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        current_page = d.pop("current_page", UNSET)
+
+        def _parse_from_(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        from_ = _parse_from_(d.pop("from", UNSET))
+
+        last_page = d.pop("last_page", UNSET)
+
+        per_page = d.pop("per_page", UNSET)
+
+        def _parse_to(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        to = _parse_to(d.pop("to", UNSET))
+
+        total = d.pop("total", UNSET)
+
+        order_list_meta = cls(
+            current_page=current_page,
+            from_=from_,
+            last_page=last_page,
+            per_page=per_page,
+            to=to,
+            total=total,
+        )
+
+        order_list_meta.additional_properties = d
+        return order_list_meta
+
+    @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

statuspro_public_api_client/models/order_list_response.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import (
+    define as _attrs_define,
+    field as _attrs_field,
+)
+
+if TYPE_CHECKING:
+    from ..models.order_list_item import OrderListItem
+    from ..models.order_list_meta import OrderListMeta
+
+
+T = TypeVar("T", bound="OrderListResponse")
+
+
+@_attrs_define
+class OrderListResponse:
+    data: list[OrderListItem]
+    meta: OrderListMeta
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        data = []
+        for data_item_data in self.data:
+            data_item = data_item_data.to_dict()
+            data.append(data_item)
+
+        meta = self.meta.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "data": data,
+                "meta": meta,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.order_list_item import OrderListItem
+        from ..models.order_list_meta import OrderListMeta
+
+        d = dict(src_dict)
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = OrderListItem.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        meta = OrderListMeta.from_dict(d.pop("meta"))
+
+        order_list_response = cls(
+            data=data,
+            meta=meta,
+        )
+
+        order_list_response.additional_properties = d
+        return order_list_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