selectwin 0.1.0__py3-none-any.whl

selectwin/_core/models/simulate_installment_response_200.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+
+from ..models.simulate_installment_response_200_resource import (
+    SimulateInstallmentResponse200Resource,
+)
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.simulate_installment_response_200_amount import (
+        SimulateInstallmentResponse200Amount,
+    )
+    from ..models.simulate_installment_response_200_links import (
+        SimulateInstallmentResponse200Links,
+    )
+    from ..models.simulate_installment_response_200_merchant import (
+        SimulateInstallmentResponse200Merchant,
+    )
+    from ..models.simulate_installment_response_200_original import (
+        SimulateInstallmentResponse200Original,
+    )
+    from ..models.simulate_installment_response_200_total_fees import (
+        SimulateInstallmentResponse200TotalFees,
+    )
+
+
+T = TypeVar("T", bound="SimulateInstallmentResponse200")
+
+
+@_attrs_define
+class SimulateInstallmentResponse200:
+    """
+    Attributes:
+        resource (SimulateInstallmentResponse200Resource):
+        is_custom (bool):
+        amount (SimulateInstallmentResponse200Amount):
+        original (SimulateInstallmentResponse200Original):
+        total_fees (SimulateInstallmentResponse200TotalFees):
+        field_links (SimulateInstallmentResponse200Links):
+        merchant (SimulateInstallmentResponse200Merchant | Unset):
+    """
+
+    resource: SimulateInstallmentResponse200Resource
+    is_custom: bool
+    amount: SimulateInstallmentResponse200Amount
+    original: SimulateInstallmentResponse200Original
+    total_fees: SimulateInstallmentResponse200TotalFees
+    field_links: SimulateInstallmentResponse200Links
+    merchant: SimulateInstallmentResponse200Merchant | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        resource = self.resource.value
+
+        is_custom = self.is_custom
+
+        amount = self.amount.to_dict()
+
+        original = self.original.to_dict()
+
+        total_fees = self.total_fees.to_dict()
+
+        field_links = self.field_links.to_dict()
+
+        merchant: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.merchant, Unset):
+            merchant = self.merchant.to_dict()
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "resource": resource,
+                "isCustom": is_custom,
+                "amount": amount,
+                "original": original,
+                "totalFees": total_fees,
+                "_links": field_links,
+            }
+        )
+        if merchant is not UNSET:
+            field_dict["merchant"] = merchant
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.simulate_installment_response_200_amount import (
+            SimulateInstallmentResponse200Amount,
+        )
+        from ..models.simulate_installment_response_200_links import (
+            SimulateInstallmentResponse200Links,
+        )
+        from ..models.simulate_installment_response_200_merchant import (
+            SimulateInstallmentResponse200Merchant,
+        )
+        from ..models.simulate_installment_response_200_original import (
+            SimulateInstallmentResponse200Original,
+        )
+        from ..models.simulate_installment_response_200_total_fees import (
+            SimulateInstallmentResponse200TotalFees,
+        )
+
+        d = dict(src_dict)
+        resource = SimulateInstallmentResponse200Resource(d.pop("resource"))
+
+        is_custom = d.pop("isCustom")
+
+        amount = SimulateInstallmentResponse200Amount.from_dict(d.pop("amount"))
+
+        original = SimulateInstallmentResponse200Original.from_dict(d.pop("original"))
+
+        total_fees = SimulateInstallmentResponse200TotalFees.from_dict(
+            d.pop("totalFees")
+        )
+
+        field_links = SimulateInstallmentResponse200Links.from_dict(d.pop("_links"))
+
+        _merchant = d.pop("merchant", UNSET)
+        merchant: SimulateInstallmentResponse200Merchant | Unset
+        if isinstance(_merchant, Unset):
+            merchant = UNSET
+        else:
+            merchant = SimulateInstallmentResponse200Merchant.from_dict(_merchant)
+
+        simulate_installment_response_200 = cls(
+            resource=resource,
+            is_custom=is_custom,
+            amount=amount,
+            original=original,
+            total_fees=total_fees,
+            field_links=field_links,
+            merchant=merchant,
+        )
+
+        return simulate_installment_response_200

selectwin/_core/models/simulate_installment_response_200_amount.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+
+T = TypeVar("T", bound="SimulateInstallmentResponse200Amount")
+
+
+@_attrs_define
+class SimulateInstallmentResponse200Amount:
+    """
+    Attributes:
+        cents (int):
+        decimal (float):
+    """
+
+    cents: int
+    decimal: float
+
+    def to_dict(self) -> dict[str, Any]:
+        cents = self.cents
+
+        decimal = self.decimal
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "cents": cents,
+                "decimal": decimal,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        cents = d.pop("cents")
+
+        decimal = d.pop("decimal")
+
+        simulate_installment_response_200_amount = cls(
+            cents=cents,
+            decimal=decimal,
+        )
+
+        return simulate_installment_response_200_amount

selectwin/_core/models/simulate_installment_response_200_links.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+
+if TYPE_CHECKING:
+    from ..models.simulate_installment_response_200_links_installments import (
+        SimulateInstallmentResponse200LinksInstallments,
+    )
+    from ..models.simulate_installment_response_200_links_payment_methods import (
+        SimulateInstallmentResponse200LinksPaymentMethods,
+    )
+    from ..models.simulate_installment_response_200_links_self import (
+        SimulateInstallmentResponse200LinksSelf,
+    )
+
+
+T = TypeVar("T", bound="SimulateInstallmentResponse200Links")
+
+
+@_attrs_define
+class SimulateInstallmentResponse200Links:
+    """
+    Attributes:
+        self_ (SimulateInstallmentResponse200LinksSelf):
+        installments (SimulateInstallmentResponse200LinksInstallments):
+        payment_methods (SimulateInstallmentResponse200LinksPaymentMethods):
+    """
+
+    self_: SimulateInstallmentResponse200LinksSelf
+    installments: SimulateInstallmentResponse200LinksInstallments
+    payment_methods: SimulateInstallmentResponse200LinksPaymentMethods
+
+    def to_dict(self) -> dict[str, Any]:
+        self_ = self.self_.to_dict()
+
+        installments = self.installments.to_dict()
+
+        payment_methods = self.payment_methods.to_dict()
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "self": self_,
+                "installments": installments,
+                "paymentMethods": payment_methods,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.simulate_installment_response_200_links_installments import (
+            SimulateInstallmentResponse200LinksInstallments,
+        )
+        from ..models.simulate_installment_response_200_links_payment_methods import (
+            SimulateInstallmentResponse200LinksPaymentMethods,
+        )
+        from ..models.simulate_installment_response_200_links_self import (
+            SimulateInstallmentResponse200LinksSelf,
+        )
+
+        d = dict(src_dict)
+        self_ = SimulateInstallmentResponse200LinksSelf.from_dict(d.pop("self"))
+
+        installments = SimulateInstallmentResponse200LinksInstallments.from_dict(
+            d.pop("installments")
+        )
+
+        payment_methods = SimulateInstallmentResponse200LinksPaymentMethods.from_dict(
+            d.pop("paymentMethods")
+        )
+
+        simulate_installment_response_200_links = cls(
+            self_=self_,
+            installments=installments,
+            payment_methods=payment_methods,
+        )
+
+        return simulate_installment_response_200_links

selectwin/_core/models/simulate_installment_response_200_links_installments.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+
+T = TypeVar("T", bound="SimulateInstallmentResponse200LinksInstallments")
+
+
+@_attrs_define
+class SimulateInstallmentResponse200LinksInstallments:
+    """
+    Attributes:
+        href (str):
+        method (str):
+    """
+
+    href: str
+    method: str
+
+    def to_dict(self) -> dict[str, Any]:
+        href = self.href
+
+        method = self.method
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "href": href,
+                "method": method,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        href = d.pop("href")
+
+        method = d.pop("method")
+
+        simulate_installment_response_200_links_installments = cls(
+            href=href,
+            method=method,
+        )
+
+        return simulate_installment_response_200_links_installments

selectwin/_core/models/simulate_installment_response_200_links_payment_methods.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+
+T = TypeVar("T", bound="SimulateInstallmentResponse200LinksPaymentMethods")
+
+
+@_attrs_define
+class SimulateInstallmentResponse200LinksPaymentMethods:
+    """
+    Attributes:
+        href (str):
+        method (str):
+    """
+
+    href: str
+    method: str
+
+    def to_dict(self) -> dict[str, Any]:
+        href = self.href
+
+        method = self.method
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "href": href,
+                "method": method,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        href = d.pop("href")
+
+        method = d.pop("method")
+
+        simulate_installment_response_200_links_payment_methods = cls(
+            href=href,
+            method=method,
+        )
+
+        return simulate_installment_response_200_links_payment_methods

selectwin/_core/models/simulate_installment_response_200_links_self.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+
+T = TypeVar("T", bound="SimulateInstallmentResponse200LinksSelf")
+
+
+@_attrs_define
+class SimulateInstallmentResponse200LinksSelf:
+    """
+    Attributes:
+        href (str):
+        method (str):
+    """
+
+    href: str
+    method: str
+
+    def to_dict(self) -> dict[str, Any]:
+        href = self.href
+
+        method = self.method
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "href": href,
+                "method": method,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        href = d.pop("href")
+
+        method = d.pop("method")
+
+        simulate_installment_response_200_links_self = cls(
+            href=href,
+            method=method,
+        )
+
+        return simulate_installment_response_200_links_self

selectwin/_core/models/simulate_installment_response_200_merchant.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+
+T = TypeVar("T", bound="SimulateInstallmentResponse200Merchant")
+
+
+@_attrs_define
+class SimulateInstallmentResponse200Merchant:
+    """
+    Attributes:
+        name (None | str):
+        merchant_id (None | str):
+        is_sub_account (bool):
+    """
+
+    name: None | str
+    merchant_id: None | str
+    is_sub_account: bool
+
+    def to_dict(self) -> dict[str, Any]:
+        name: None | str
+        name = self.name
+
+        merchant_id: None | str
+        merchant_id = self.merchant_id
+
+        is_sub_account = self.is_sub_account
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "name": name,
+                "merchantId": merchant_id,
+                "isSubAccount": is_sub_account,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_name(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        name = _parse_name(d.pop("name"))
+
+        def _parse_merchant_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        merchant_id = _parse_merchant_id(d.pop("merchantId"))
+
+        is_sub_account = d.pop("isSubAccount")
+
+        simulate_installment_response_200_merchant = cls(
+            name=name,
+            merchant_id=merchant_id,
+            is_sub_account=is_sub_account,
+        )
+
+        return simulate_installment_response_200_merchant

selectwin/_core/models/simulate_installment_response_200_original.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+
+T = TypeVar("T", bound="SimulateInstallmentResponse200Original")
+
+
+@_attrs_define
+class SimulateInstallmentResponse200Original:
+    """
+    Attributes:
+        cents (int):
+        decimal (float):
+    """
+
+    cents: int
+    decimal: float
+
+    def to_dict(self) -> dict[str, Any]:
+        cents = self.cents
+
+        decimal = self.decimal
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "cents": cents,
+                "decimal": decimal,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        cents = d.pop("cents")
+
+        decimal = d.pop("decimal")
+
+        simulate_installment_response_200_original = cls(
+            cents=cents,
+            decimal=decimal,
+        )
+
+        return simulate_installment_response_200_original

selectwin/_core/models/simulate_installment_response_200_resource.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class SimulateInstallmentResponse200Resource(str, Enum):
+    CREDIT = "credit"
+    NUPAY = "nupay"
+
+    def __str__(self) -> str:
+        return str(self.value)

selectwin/_core/models/simulate_installment_response_200_total_fees.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+
+T = TypeVar("T", bound="SimulateInstallmentResponse200TotalFees")
+
+
+@_attrs_define
+class SimulateInstallmentResponse200TotalFees:
+    """
+    Attributes:
+        cents (int):
+        decimal (float):
+    """
+
+    cents: int
+    decimal: float
+
+    def to_dict(self) -> dict[str, Any]:
+        cents = self.cents
+
+        decimal = self.decimal
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "cents": cents,
+                "decimal": decimal,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        cents = d.pop("cents")
+
+        decimal = d.pop("decimal")
+
+        simulate_installment_response_200_total_fees = cls(
+            cents=cents,
+            decimal=decimal,
+        )
+
+        return simulate_installment_response_200_total_fees

selectwin/_core/models/simulate_installments_resource.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class SimulateInstallmentsResource(str, Enum):
+    CREDIT = "credit"
+    NUPAY = "nupay"
+
+    def __str__(self) -> str:
+        return str(self.value)