mollie-api-py 1.0.0__py3-none-any.whl

mollie/models/client_link_request.py

@@ -0,0 +1,210 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .locale_response import LocaleResponse
+from mollie.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from mollie.utils import validate_open_enum
+import pydantic
+from pydantic import model_serializer
+from pydantic.functional_validators import PlainValidator
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class OwnerTypedDict(TypedDict):
+    r"""Personal data of your customer."""
+
+    email: str
+    r"""The email address of your customer."""
+    given_name: str
+    r"""The given name (first name) of your customer."""
+    family_name: str
+    r"""The family name (surname) of your customer."""
+    locale: NotRequired[Nullable[LocaleResponse]]
+    r"""Allows you to preset the language to be used."""
+
+
+class Owner(BaseModel):
+    r"""Personal data of your customer."""
+
+    email: str
+    r"""The email address of your customer."""
+
+    given_name: Annotated[str, pydantic.Field(alias="givenName")]
+    r"""The given name (first name) of your customer."""
+
+    family_name: Annotated[str, pydantic.Field(alias="familyName")]
+    r"""The family name (surname) of your customer."""
+
+    locale: Annotated[
+        OptionalNullable[LocaleResponse], PlainValidator(validate_open_enum(False))
+    ] = UNSET
+    r"""Allows you to preset the language to be used."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["locale"]
+        nullable_fields = ["locale"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m
+
+
+class ClientLinkRequestAddressTypedDict(TypedDict):
+    r"""Address of the organization."""
+
+    country: str
+    r"""The country of the address in
+    [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) format.
+    """
+    street_and_number: NotRequired[Nullable[str]]
+    r"""The street name and house number of the organization."""
+    postal_code: NotRequired[Nullable[str]]
+    r"""The postal code of the organization. Required if a street address is provided and if the country has a postal
+    code system.
+    """
+    city: NotRequired[Nullable[str]]
+    r"""The city of the organization. Required if a street address is provided."""
+
+
+class ClientLinkRequestAddress(BaseModel):
+    r"""Address of the organization."""
+
+    country: str
+    r"""The country of the address in
+    [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) format.
+    """
+
+    street_and_number: Annotated[
+        OptionalNullable[str], pydantic.Field(alias="streetAndNumber")
+    ] = UNSET
+    r"""The street name and house number of the organization."""
+
+    postal_code: Annotated[
+        OptionalNullable[str], pydantic.Field(alias="postalCode")
+    ] = UNSET
+    r"""The postal code of the organization. Required if a street address is provided and if the country has a postal
+    code system.
+    """
+
+    city: OptionalNullable[str] = UNSET
+    r"""The city of the organization. Required if a street address is provided."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["streetAndNumber", "postalCode", "city"]
+        nullable_fields = ["streetAndNumber", "postalCode", "city"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m
+
+
+class ClientLinkRequestTypedDict(TypedDict):
+    owner: OwnerTypedDict
+    r"""Personal data of your customer."""
+    name: str
+    r"""Name of the organization."""
+    address: ClientLinkRequestAddressTypedDict
+    r"""Address of the organization."""
+    registration_number: NotRequired[Nullable[str]]
+    r"""The registration number of the organization at their local chamber of commerce."""
+    vat_number: NotRequired[Nullable[str]]
+    r"""The VAT number of the organization, if based in the European Union. VAT numbers are verified against the
+    international registry *VIES*.
+    """
+
+
+class ClientLinkRequest(BaseModel):
+    owner: Owner
+    r"""Personal data of your customer."""
+
+    name: str
+    r"""Name of the organization."""
+
+    address: ClientLinkRequestAddress
+    r"""Address of the organization."""
+
+    registration_number: Annotated[
+        OptionalNullable[str], pydantic.Field(alias="registrationNumber")
+    ] = UNSET
+    r"""The registration number of the organization at their local chamber of commerce."""
+
+    vat_number: Annotated[OptionalNullable[str], pydantic.Field(alias="vatNumber")] = (
+        UNSET
+    )
+    r"""The VAT number of the organization, if based in the European Union. VAT numbers are verified against the
+    international registry *VIES*.
+    """
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["registrationNumber", "vatNumber"]
+        nullable_fields = ["registrationNumber", "vatNumber"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

mollie/models/client_link_response.py

@@ -0,0 +1,56 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .url import URL, URLTypedDict
+from mollie.types import BaseModel
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class ClientLinkResponseLinksTypedDict(TypedDict):
+    r"""An object with several relevant URLs. Every URL object will contain an `href` and a `type` field."""
+
+    self_: NotRequired[URLTypedDict]
+    r"""In v2 endpoints, URLs are commonly represented as objects with an `href` and `type` field."""
+    client_link: NotRequired[URLTypedDict]
+    r"""In v2 endpoints, URLs are commonly represented as objects with an `href` and `type` field."""
+    documentation: NotRequired[URLTypedDict]
+    r"""In v2 endpoints, URLs are commonly represented as objects with an `href` and `type` field."""
+
+
+class ClientLinkResponseLinks(BaseModel):
+    r"""An object with several relevant URLs. Every URL object will contain an `href` and a `type` field."""
+
+    self_: Annotated[Optional[URL], pydantic.Field(alias="self")] = None
+    r"""In v2 endpoints, URLs are commonly represented as objects with an `href` and `type` field."""
+
+    client_link: Annotated[Optional[URL], pydantic.Field(alias="clientLink")] = None
+    r"""In v2 endpoints, URLs are commonly represented as objects with an `href` and `type` field."""
+
+    documentation: Optional[URL] = None
+    r"""In v2 endpoints, URLs are commonly represented as objects with an `href` and `type` field."""
+
+
+class ClientLinkResponseTypedDict(TypedDict):
+    resource: str
+    r"""Indicates the response contains a client link object. Will always contain the string `client-link` for this
+    endpoint.
+    """
+    id: str
+    r"""The identifier uniquely referring to this client link. Example: `cl_vZCnNQsV2UtfXxYifWKWH`."""
+    links: ClientLinkResponseLinksTypedDict
+    r"""An object with several relevant URLs. Every URL object will contain an `href` and a `type` field."""
+
+
+class ClientLinkResponse(BaseModel):
+    resource: str
+    r"""Indicates the response contains a client link object. Will always contain the string `client-link` for this
+    endpoint.
+    """
+
+    id: str
+    r"""The identifier uniquely referring to this client link. Example: `cl_vZCnNQsV2UtfXxYifWKWH`."""
+
+    links: Annotated[ClientLinkResponseLinks, pydantic.Field(alias="_links")]
+    r"""An object with several relevant URLs. Every URL object will contain an `href` and a `type` field."""

mollie/models/clienterror.py

@@ -0,0 +1,30 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import httpx
+from typing import Optional
+from dataclasses import dataclass, field
+
+
+@dataclass(unsafe_hash=True)
+class ClientError(Exception):
+    """The base class for all HTTP error responses."""
+
+    message: str
+    status_code: int
+    body: str
+    headers: httpx.Headers = field(hash=False)
+    raw_response: httpx.Response = field(hash=False)
+
+    def __init__(
+        self, message: str, raw_response: httpx.Response, body: Optional[str] = None
+    ):
+        object.__setattr__(self, "message", message)
+        object.__setattr__(self, "status_code", raw_response.status_code)
+        object.__setattr__(
+            self, "body", body if body is not None else raw_response.text
+        )
+        object.__setattr__(self, "headers", raw_response.headers)
+        object.__setattr__(self, "raw_response", raw_response)
+
+    def __str__(self):
+        return self.message

mollie/models/components_sub_totals.py

@@ -0,0 +1,127 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .balance_card_audience import BalanceCardAudience
+from .balance_card_issuer import BalanceCardIssuer
+from .balance_card_region import BalanceCardRegion
+from .balance_fee_type import BalanceFeeType
+from .balance_prepayment_part_type import BalancePrepaymentPartType
+from .balance_transaction_type import BalanceTransactionType
+from .payment_method import PaymentMethod
+from .sub_totals import SubTotals, SubTotalsTypedDict
+from mollie.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from mollie.utils import validate_open_enum
+import pydantic
+from pydantic import model_serializer
+from pydantic.functional_validators import PlainValidator
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class ComponentsSubTotalsTypedDict(TypedDict):
+    sub_totals: NotRequired[Nullable[List[SubTotalsTypedDict]]]
+    count: NotRequired[int]
+    r"""Number of transactions of this type"""
+    method: NotRequired[Nullable[PaymentMethod]]
+    r"""The payment method, if applicable"""
+    card_issuer: NotRequired[BalanceCardIssuer]
+    card_audience: NotRequired[BalanceCardAudience]
+    card_region: NotRequired[BalanceCardRegion]
+    fee_type: NotRequired[BalanceFeeType]
+    prepayment_part_type: NotRequired[BalancePrepaymentPartType]
+    transaction_type: NotRequired[BalanceTransactionType]
+
+
+class ComponentsSubTotals(BaseModel):
+    sub_totals: Annotated[
+        OptionalNullable[List[SubTotals]], pydantic.Field(alias="sub-totals")
+    ] = UNSET
+
+    count: Optional[int] = None
+    r"""Number of transactions of this type"""
+
+    method: Annotated[
+        OptionalNullable[PaymentMethod], PlainValidator(validate_open_enum(False))
+    ] = UNSET
+    r"""The payment method, if applicable"""
+
+    card_issuer: Annotated[
+        Annotated[
+            Optional[BalanceCardIssuer], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="cardIssuer"),
+    ] = None
+
+    card_audience: Annotated[
+        Annotated[
+            Optional[BalanceCardAudience], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="cardAudience"),
+    ] = None
+
+    card_region: Annotated[
+        Annotated[
+            Optional[BalanceCardRegion], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="cardRegion"),
+    ] = None
+
+    fee_type: Annotated[
+        Annotated[Optional[BalanceFeeType], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="feeType"),
+    ] = None
+
+    prepayment_part_type: Annotated[
+        Annotated[
+            Optional[BalancePrepaymentPartType],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="prepaymentPartType"),
+    ] = None
+
+    transaction_type: Annotated[
+        Annotated[
+            Optional[BalanceTransactionType], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="transactionType"),
+    ] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "sub-totals",
+            "count",
+            "method",
+            "cardIssuer",
+            "cardAudience",
+            "cardRegion",
+            "feeType",
+            "prepaymentPartType",
+            "transactionType",
+        ]
+        nullable_fields = ["sub-totals", "method"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

mollie/models/create_captureop.py

@@ -0,0 +1,43 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .entity_capture import EntityCapture, EntityCaptureTypedDict
+from mollie.types import BaseModel
+from mollie.utils import (
+    FieldMetadata,
+    HeaderMetadata,
+    PathParamMetadata,
+    RequestMetadata,
+)
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class CreateCaptureRequestTypedDict(TypedDict):
+    payment_id: str
+    r"""Provide the ID of the related payment."""
+    idempotency_key: NotRequired[str]
+    r"""A unique key to ensure idempotent requests. This key should be a UUID v4 string."""
+    entity_capture: NotRequired[EntityCaptureTypedDict]
+
+
+class CreateCaptureRequest(BaseModel):
+    payment_id: Annotated[
+        str,
+        pydantic.Field(alias="paymentId"),
+        FieldMetadata(path=PathParamMetadata(style="simple", explode=False)),
+    ]
+    r"""Provide the ID of the related payment."""
+
+    idempotency_key: Annotated[
+        Optional[str],
+        pydantic.Field(alias="idempotency-key"),
+        FieldMetadata(header=HeaderMetadata(style="simple", explode=False)),
+    ] = None
+    r"""A unique key to ensure idempotent requests. This key should be a UUID v4 string."""
+
+    entity_capture: Annotated[
+        Optional[EntityCapture],
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ] = None

mollie/models/create_client_linkop.py

@@ -0,0 +1,29 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .client_link_request import ClientLinkRequest, ClientLinkRequestTypedDict
+from mollie.types import BaseModel
+from mollie.utils import FieldMetadata, HeaderMetadata, RequestMetadata
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class CreateClientLinkRequestTypedDict(TypedDict):
+    idempotency_key: NotRequired[str]
+    r"""A unique key to ensure idempotent requests. This key should be a UUID v4 string."""
+    client_link_request: NotRequired[ClientLinkRequestTypedDict]
+
+
+class CreateClientLinkRequest(BaseModel):
+    idempotency_key: Annotated[
+        Optional[str],
+        pydantic.Field(alias="idempotency-key"),
+        FieldMetadata(header=HeaderMetadata(style="simple", explode=False)),
+    ] = None
+    r"""A unique key to ensure idempotent requests. This key should be a UUID v4 string."""
+
+    client_link_request: Annotated[
+        Optional[ClientLinkRequest],
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ] = None

mollie/models/create_connect_balance_transferop.py

@@ -0,0 +1,32 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .entity_balance_transfer import (
+    EntityBalanceTransfer,
+    EntityBalanceTransferTypedDict,
+)
+from mollie.types import BaseModel
+from mollie.utils import FieldMetadata, HeaderMetadata, RequestMetadata
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class CreateConnectBalanceTransferRequestTypedDict(TypedDict):
+    idempotency_key: NotRequired[str]
+    r"""A unique key to ensure idempotent requests. This key should be a UUID v4 string."""
+    entity_balance_transfer: NotRequired[EntityBalanceTransferTypedDict]
+
+
+class CreateConnectBalanceTransferRequest(BaseModel):
+    idempotency_key: Annotated[
+        Optional[str],
+        pydantic.Field(alias="idempotency-key"),
+        FieldMetadata(header=HeaderMetadata(style="simple", explode=False)),
+    ] = None
+    r"""A unique key to ensure idempotent requests. This key should be a UUID v4 string."""
+
+    entity_balance_transfer: Annotated[
+        Optional[EntityBalanceTransfer],
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ] = None

mollie/models/create_customer_paymentop.py

@@ -0,0 +1,43 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .payment_request import PaymentRequest, PaymentRequestTypedDict
+from mollie.types import BaseModel
+from mollie.utils import (
+    FieldMetadata,
+    HeaderMetadata,
+    PathParamMetadata,
+    RequestMetadata,
+)
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class CreateCustomerPaymentRequestTypedDict(TypedDict):
+    customer_id: str
+    r"""Provide the ID of the related customer."""
+    idempotency_key: NotRequired[str]
+    r"""A unique key to ensure idempotent requests. This key should be a UUID v4 string."""
+    payment_request: NotRequired[PaymentRequestTypedDict]
+
+
+class CreateCustomerPaymentRequest(BaseModel):
+    customer_id: Annotated[
+        str,
+        pydantic.Field(alias="customerId"),
+        FieldMetadata(path=PathParamMetadata(style="simple", explode=False)),
+    ]
+    r"""Provide the ID of the related customer."""
+
+    idempotency_key: Annotated[
+        Optional[str],
+        pydantic.Field(alias="idempotency-key"),
+        FieldMetadata(header=HeaderMetadata(style="simple", explode=False)),
+    ] = None
+    r"""A unique key to ensure idempotent requests. This key should be a UUID v4 string."""
+
+    payment_request: Annotated[
+        Optional[PaymentRequest],
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ] = None

mollie/models/create_customerop.py

@@ -0,0 +1,29 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .entity_customer import EntityCustomer, EntityCustomerTypedDict
+from mollie.types import BaseModel
+from mollie.utils import FieldMetadata, HeaderMetadata, RequestMetadata
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class CreateCustomerRequestTypedDict(TypedDict):
+    idempotency_key: NotRequired[str]
+    r"""A unique key to ensure idempotent requests. This key should be a UUID v4 string."""
+    entity_customer: NotRequired[EntityCustomerTypedDict]
+
+
+class CreateCustomerRequest(BaseModel):
+    idempotency_key: Annotated[
+        Optional[str],
+        pydantic.Field(alias="idempotency-key"),
+        FieldMetadata(header=HeaderMetadata(style="simple", explode=False)),
+    ] = None
+    r"""A unique key to ensure idempotent requests. This key should be a UUID v4 string."""
+
+    entity_customer: Annotated[
+        Optional[EntityCustomer],
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ] = None

mollie/models/create_mandateop.py

@@ -0,0 +1,43 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .mandate_request import MandateRequest, MandateRequestTypedDict
+from mollie.types import BaseModel
+from mollie.utils import (
+    FieldMetadata,
+    HeaderMetadata,
+    PathParamMetadata,
+    RequestMetadata,
+)
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class CreateMandateRequestTypedDict(TypedDict):
+    customer_id: str
+    r"""Provide the ID of the related customer."""
+    idempotency_key: NotRequired[str]
+    r"""A unique key to ensure idempotent requests. This key should be a UUID v4 string."""
+    mandate_request: NotRequired[MandateRequestTypedDict]
+
+
+class CreateMandateRequest(BaseModel):
+    customer_id: Annotated[
+        str,
+        pydantic.Field(alias="customerId"),
+        FieldMetadata(path=PathParamMetadata(style="simple", explode=False)),
+    ]
+    r"""Provide the ID of the related customer."""
+
+    idempotency_key: Annotated[
+        Optional[str],
+        pydantic.Field(alias="idempotency-key"),
+        FieldMetadata(header=HeaderMetadata(style="simple", explode=False)),
+    ] = None
+    r"""A unique key to ensure idempotent requests. This key should be a UUID v4 string."""
+
+    mandate_request: Annotated[
+        Optional[MandateRequest],
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ] = None