onlinepayments-sdk-python3 7.4.1__py3-none-any.whl

onlinepayments/sdk/domain/payment_product5404.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentProduct5404(DataObject):
+
+    __app_switch_link: Optional[str] = None
+    __qr_code_url: Optional[str] = None
+
+    @property
+    def app_switch_link(self) -> Optional[str]:
+        """
+        | Contains a application switch url that should open WeChat Pay application in mobile device (intended to be used by a device with the WeChat Pay app)
+
+        Type: str
+        """
+        return self.__app_switch_link
+
+    @app_switch_link.setter
+    def app_switch_link(self, value: Optional[str]) -> None:
+        self.__app_switch_link = value
+
+    @property
+    def qr_code_url(self) -> Optional[str]:
+        """
+        | Contains a QR code url that can be used to build a QR code (intended to be scanned by a device with the WeChat Pay app)
+
+        Type: str
+        """
+        return self.__qr_code_url
+
+    @qr_code_url.setter
+    def qr_code_url(self, value: Optional[str]) -> None:
+        self.__qr_code_url = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProduct5404, self).to_dictionary()
+        if self.app_switch_link is not None:
+            dictionary['appSwitchLink'] = self.app_switch_link
+        if self.qr_code_url is not None:
+            dictionary['qrCodeUrl'] = self.qr_code_url
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct5404':
+        super(PaymentProduct5404, self).from_dictionary(dictionary)
+        if 'appSwitchLink' in dictionary:
+            self.app_switch_link = dictionary['appSwitchLink']
+        if 'qrCodeUrl' in dictionary:
+            self.qr_code_url = dictionary['qrCodeUrl']
+        return self

onlinepayments/sdk/domain/payment_product5407.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentProduct5407(DataObject):
+
+    __pairing_token: Optional[str] = None
+    __qr_code: Optional[str] = None
+
+    @property
+    def pairing_token(self) -> Optional[str]:
+        """
+        | A numeric token, which the user has to copy or type into the TWINT app in order to pair it with the merchant for the payment process.
+
+        Type: str
+        """
+        return self.__pairing_token
+
+    @pairing_token.setter
+    def pairing_token(self, value: Optional[str]) -> None:
+        self.__pairing_token = value
+
+    @property
+    def qr_code(self) -> Optional[str]:
+        """
+        | Contains a base64 encoded PNG image. By prepending data:image/png;base64, this value can be used as the source of an HTML inline image on a desktop or tablet (intended to be scanned by a device with the Twint app)
+
+        Type: str
+        """
+        return self.__qr_code
+
+    @qr_code.setter
+    def qr_code(self, value: Optional[str]) -> None:
+        self.__qr_code = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProduct5407, self).to_dictionary()
+        if self.pairing_token is not None:
+            dictionary['pairingToken'] = self.pairing_token
+        if self.qr_code is not None:
+            dictionary['qrCode'] = self.qr_code
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct5407':
+        super(PaymentProduct5407, self).from_dictionary(dictionary)
+        if 'pairingToken' in dictionary:
+            self.pairing_token = dictionary['pairingToken']
+        if 'qrCode' in dictionary:
+            self.qr_code = dictionary['qrCode']
+        return self

onlinepayments/sdk/domain/payment_product5500_specific_output.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentProduct5500SpecificOutput(DataObject):
+
+    __entity_id: Optional[str] = None
+    __payment_end_date: Optional[str] = None
+    __payment_reference: Optional[str] = None
+    __payment_start_date: Optional[str] = None
+
+    @property
+    def entity_id(self) -> Optional[str]:
+        """
+        | The reference to be used during Multibanco payment for reconciliation matter
+
+        Type: str
+        """
+        return self.__entity_id
+
+    @entity_id.setter
+    def entity_id(self, value: Optional[str]) -> None:
+        self.__entity_id = value
+
+    @property
+    def payment_end_date(self) -> Optional[str]:
+        """
+        | The end date of the payment validity
+
+        Type: str
+        """
+        return self.__payment_end_date
+
+    @payment_end_date.setter
+    def payment_end_date(self, value: Optional[str]) -> None:
+        self.__payment_end_date = value
+
+    @property
+    def payment_reference(self) -> Optional[str]:
+        """
+        | The reference to be used within the Multibanco network to confirm the payment
+
+        Type: str
+        """
+        return self.__payment_reference
+
+    @payment_reference.setter
+    def payment_reference(self, value: Optional[str]) -> None:
+        self.__payment_reference = value
+
+    @property
+    def payment_start_date(self) -> Optional[str]:
+        """
+        | The start date of the payment validity
+
+        Type: str
+        """
+        return self.__payment_start_date
+
+    @payment_start_date.setter
+    def payment_start_date(self, value: Optional[str]) -> None:
+        self.__payment_start_date = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProduct5500SpecificOutput, self).to_dictionary()
+        if self.entity_id is not None:
+            dictionary['entityId'] = self.entity_id
+        if self.payment_end_date is not None:
+            dictionary['paymentEndDate'] = self.payment_end_date
+        if self.payment_reference is not None:
+            dictionary['paymentReference'] = self.payment_reference
+        if self.payment_start_date is not None:
+            dictionary['paymentStartDate'] = self.payment_start_date
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct5500SpecificOutput':
+        super(PaymentProduct5500SpecificOutput, self).from_dictionary(dictionary)
+        if 'entityId' in dictionary:
+            self.entity_id = dictionary['entityId']
+        if 'paymentEndDate' in dictionary:
+            self.payment_end_date = dictionary['paymentEndDate']
+        if 'paymentReference' in dictionary:
+            self.payment_reference = dictionary['paymentReference']
+        if 'paymentStartDate' in dictionary:
+            self.payment_start_date = dictionary['paymentStartDate']
+        return self

onlinepayments/sdk/domain/payment_product771_specific_output.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentProduct771SpecificOutput(DataObject):
+
+    __mandate_reference: Optional[str] = None
+
+    @property
+    def mandate_reference(self) -> Optional[str]:
+        """
+        | Unique reference to a Mandate
+
+        Type: str
+        """
+        return self.__mandate_reference
+
+    @mandate_reference.setter
+    def mandate_reference(self, value: Optional[str]) -> None:
+        self.__mandate_reference = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProduct771SpecificOutput, self).to_dictionary()
+        if self.mandate_reference is not None:
+            dictionary['mandateReference'] = self.mandate_reference
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct771SpecificOutput':
+        super(PaymentProduct771SpecificOutput, self).from_dictionary(dictionary)
+        if 'mandateReference' in dictionary:
+            self.mandate_reference = dictionary['mandateReference']
+        return self

onlinepayments/sdk/domain/payment_product840.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentProduct840(DataObject):
+
+    __order_id: Optional[str] = None
+
+    @property
+    def order_id(self) -> Optional[str]:
+        """
+        | Contains an identifier supplied by PayPal which must be provided to the PayPal JavaScript SDK.
+
+        Type: str
+        """
+        return self.__order_id
+
+    @order_id.setter
+    def order_id(self, value: Optional[str]) -> None:
+        self.__order_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProduct840, self).to_dictionary()
+        if self.order_id is not None:
+            dictionary['orderId'] = self.order_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct840':
+        super(PaymentProduct840, self).from_dictionary(dictionary)
+        if 'orderId' in dictionary:
+            self.order_id = dictionary['orderId']
+        return self

onlinepayments/sdk/domain/payment_product840_customer_account.py

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentProduct840CustomerAccount(DataObject):
+
+    __account_id: Optional[str] = None
+    __company_name: Optional[str] = None
+    __country_code: Optional[str] = None
+    __customer_account_status: Optional[str] = None
+    __customer_address_status: Optional[str] = None
+    __first_name: Optional[str] = None
+    __payer_id: Optional[str] = None
+    __surname: Optional[str] = None
+
+    @property
+    def account_id(self) -> Optional[str]:
+        """
+        | Username with which the PayPal account holder has registered at PayPal
+
+        Type: str
+        """
+        return self.__account_id
+
+    @account_id.setter
+    def account_id(self, value: Optional[str]) -> None:
+        self.__account_id = value
+
+    @property
+    def company_name(self) -> Optional[str]:
+        """
+        | Name of the company in case the PayPal account is owned by a business
+
+        Type: str
+        """
+        return self.__company_name
+
+    @company_name.setter
+    def company_name(self, value: Optional[str]) -> None:
+        self.__company_name = value
+
+    @property
+    def country_code(self) -> Optional[str]:
+        """
+        | ISO 3166-1 alpha-2 country code
+
+        Type: str
+        """
+        return self.__country_code
+
+    @country_code.setter
+    def country_code(self, value: Optional[str]) -> None:
+        self.__country_code = value
+
+    @property
+    def customer_account_status(self) -> Optional[str]:
+        """
+        | Status of the PayPal account
+        
+        * verified - PayPal has verified the funding means for this account
+        * unverified - PayPal has not verified the funding means for this account
+
+        Type: str
+        """
+        return self.__customer_account_status
+
+    @customer_account_status.setter
+    def customer_account_status(self, value: Optional[str]) -> None:
+        self.__customer_account_status = value
+
+    @property
+    def customer_address_status(self) -> Optional[str]:
+        """
+        | Status of the customer's shipping address as registered by PayPal
+        
+        * none - Status is unknown at PayPal
+        * confirmed - The address has been confirmed
+        * unconfirmed - The address has not been confirmed
+
+        Type: str
+        """
+        return self.__customer_address_status
+
+    @customer_address_status.setter
+    def customer_address_status(self, value: Optional[str]) -> None:
+        self.__customer_address_status = value
+
+    @property
+    def first_name(self) -> Optional[str]:
+        """
+        | First name of the PayPal account holder
+
+        Type: str
+        """
+        return self.__first_name
+
+    @first_name.setter
+    def first_name(self, value: Optional[str]) -> None:
+        self.__first_name = value
+
+    @property
+    def payer_id(self) -> Optional[str]:
+        """
+        | The unique identifier of a PayPal account and will never change in the life cycle of a PayPal account
+
+        Type: str
+        """
+        return self.__payer_id
+
+    @payer_id.setter
+    def payer_id(self, value: Optional[str]) -> None:
+        self.__payer_id = value
+
+    @property
+    def surname(self) -> Optional[str]:
+        """
+        | Surname of the PayPal account holder
+
+        Type: str
+        """
+        return self.__surname
+
+    @surname.setter
+    def surname(self, value: Optional[str]) -> None:
+        self.__surname = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProduct840CustomerAccount, self).to_dictionary()
+        if self.account_id is not None:
+            dictionary['accountId'] = self.account_id
+        if self.company_name is not None:
+            dictionary['companyName'] = self.company_name
+        if self.country_code is not None:
+            dictionary['countryCode'] = self.country_code
+        if self.customer_account_status is not None:
+            dictionary['customerAccountStatus'] = self.customer_account_status
+        if self.customer_address_status is not None:
+            dictionary['customerAddressStatus'] = self.customer_address_status
+        if self.first_name is not None:
+            dictionary['firstName'] = self.first_name
+        if self.payer_id is not None:
+            dictionary['payerId'] = self.payer_id
+        if self.surname is not None:
+            dictionary['surname'] = self.surname
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct840CustomerAccount':
+        super(PaymentProduct840CustomerAccount, self).from_dictionary(dictionary)
+        if 'accountId' in dictionary:
+            self.account_id = dictionary['accountId']
+        if 'companyName' in dictionary:
+            self.company_name = dictionary['companyName']
+        if 'countryCode' in dictionary:
+            self.country_code = dictionary['countryCode']
+        if 'customerAccountStatus' in dictionary:
+            self.customer_account_status = dictionary['customerAccountStatus']
+        if 'customerAddressStatus' in dictionary:
+            self.customer_address_status = dictionary['customerAddressStatus']
+        if 'firstName' in dictionary:
+            self.first_name = dictionary['firstName']
+        if 'payerId' in dictionary:
+            self.payer_id = dictionary['payerId']
+        if 'surname' in dictionary:
+            self.surname = dictionary['surname']
+        return self

onlinepayments/sdk/domain/payment_product840_specific_output.py

@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .address import Address
+from .address_personal import AddressPersonal
+from .data_object import DataObject
+from .payment_product840_customer_account import PaymentProduct840CustomerAccount
+from .protection_eligibility import ProtectionEligibility
+
+
+class PaymentProduct840SpecificOutput(DataObject):
+
+    __billing_address: Optional[Address] = None
+    __billing_personal_address: Optional[AddressPersonal] = None
+    __customer_account: Optional[PaymentProduct840CustomerAccount] = None
+    __customer_address: Optional[Address] = None
+    __pay_pal_transaction_id: Optional[str] = None
+    __protection_eligibility: Optional[ProtectionEligibility] = None
+    __shipping_address: Optional[AddressPersonal] = None
+
+    @property
+    def billing_address(self) -> Optional[Address]:
+        """
+        | Object containing billing address details.
+
+        Type: :class:`onlinepayments.sdk.domain.address.Address`
+        """
+        return self.__billing_address
+
+    @billing_address.setter
+    def billing_address(self, value: Optional[Address]) -> None:
+        self.__billing_address = value
+
+    @property
+    def billing_personal_address(self) -> Optional[AddressPersonal]:
+        """
+        | Object containing address information
+
+        Type: :class:`onlinepayments.sdk.domain.address_personal.AddressPersonal`
+        """
+        return self.__billing_personal_address
+
+    @billing_personal_address.setter
+    def billing_personal_address(self, value: Optional[AddressPersonal]) -> None:
+        self.__billing_personal_address = value
+
+    @property
+    def customer_account(self) -> Optional[PaymentProduct840CustomerAccount]:
+        """
+        | Object containing the details of the PayPal account
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product840_customer_account.PaymentProduct840CustomerAccount`
+        """
+        return self.__customer_account
+
+    @customer_account.setter
+    def customer_account(self, value: Optional[PaymentProduct840CustomerAccount]) -> None:
+        self.__customer_account = value
+
+    @property
+    def customer_address(self) -> Optional[Address]:
+        """
+        | Object containing billing address details.
+
+        Type: :class:`onlinepayments.sdk.domain.address.Address`
+        """
+        return self.__customer_address
+
+    @customer_address.setter
+    def customer_address(self, value: Optional[Address]) -> None:
+        self.__customer_address = value
+
+    @property
+    def pay_pal_transaction_id(self) -> Optional[str]:
+        """
+        | Id of a transaction given by PayPal
+
+        Type: str
+        """
+        return self.__pay_pal_transaction_id
+
+    @pay_pal_transaction_id.setter
+    def pay_pal_transaction_id(self, value: Optional[str]) -> None:
+        self.__pay_pal_transaction_id = value
+
+    @property
+    def protection_eligibility(self) -> Optional[ProtectionEligibility]:
+        """
+        | Kind of seller protection in force for the PayPal transaction
+
+        Type: :class:`onlinepayments.sdk.domain.protection_eligibility.ProtectionEligibility`
+        """
+        return self.__protection_eligibility
+
+    @protection_eligibility.setter
+    def protection_eligibility(self, value: Optional[ProtectionEligibility]) -> None:
+        self.__protection_eligibility = value
+
+    @property
+    def shipping_address(self) -> Optional[AddressPersonal]:
+        """
+        | Object containing address information
+
+        Type: :class:`onlinepayments.sdk.domain.address_personal.AddressPersonal`
+        """
+        return self.__shipping_address
+
+    @shipping_address.setter
+    def shipping_address(self, value: Optional[AddressPersonal]) -> None:
+        self.__shipping_address = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProduct840SpecificOutput, self).to_dictionary()
+        if self.billing_address is not None:
+            dictionary['billingAddress'] = self.billing_address.to_dictionary()
+        if self.billing_personal_address is not None:
+            dictionary['billingPersonalAddress'] = self.billing_personal_address.to_dictionary()
+        if self.customer_account is not None:
+            dictionary['customerAccount'] = self.customer_account.to_dictionary()
+        if self.customer_address is not None:
+            dictionary['customerAddress'] = self.customer_address.to_dictionary()
+        if self.pay_pal_transaction_id is not None:
+            dictionary['payPalTransactionId'] = self.pay_pal_transaction_id
+        if self.protection_eligibility is not None:
+            dictionary['protectionEligibility'] = self.protection_eligibility.to_dictionary()
+        if self.shipping_address is not None:
+            dictionary['shippingAddress'] = self.shipping_address.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct840SpecificOutput':
+        super(PaymentProduct840SpecificOutput, self).from_dictionary(dictionary)
+        if 'billingAddress' in dictionary:
+            if not isinstance(dictionary['billingAddress'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['billingAddress']))
+            value = Address()
+            self.billing_address = value.from_dictionary(dictionary['billingAddress'])
+        if 'billingPersonalAddress' in dictionary:
+            if not isinstance(dictionary['billingPersonalAddress'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['billingPersonalAddress']))
+            value = AddressPersonal()
+            self.billing_personal_address = value.from_dictionary(dictionary['billingPersonalAddress'])
+        if 'customerAccount' in dictionary:
+            if not isinstance(dictionary['customerAccount'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customerAccount']))
+            value = PaymentProduct840CustomerAccount()
+            self.customer_account = value.from_dictionary(dictionary['customerAccount'])
+        if 'customerAddress' in dictionary:
+            if not isinstance(dictionary['customerAddress'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customerAddress']))
+            value = Address()
+            self.customer_address = value.from_dictionary(dictionary['customerAddress'])
+        if 'payPalTransactionId' in dictionary:
+            self.pay_pal_transaction_id = dictionary['payPalTransactionId']
+        if 'protectionEligibility' in dictionary:
+            if not isinstance(dictionary['protectionEligibility'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['protectionEligibility']))
+            value = ProtectionEligibility()
+            self.protection_eligibility = value.from_dictionary(dictionary['protectionEligibility'])
+        if 'shippingAddress' in dictionary:
+            if not isinstance(dictionary['shippingAddress'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['shippingAddress']))
+            value = AddressPersonal()
+            self.shipping_address = value.from_dictionary(dictionary['shippingAddress'])
+        return self

onlinepayments/sdk/domain/payment_product_display_hints.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentProductDisplayHints(DataObject):
+
+    __display_order: Optional[int] = None
+    __label: Optional[str] = None
+    __logo: Optional[str] = None
+
+    @property
+    def display_order(self) -> Optional[int]:
+        """
+        | Determines the order in which the payment products and groups should be shown (sorted ascending)
+
+        Type: int
+        """
+        return self.__display_order
+
+    @display_order.setter
+    def display_order(self, value: Optional[int]) -> None:
+        self.__display_order = value
+
+    @property
+    def label(self) -> Optional[str]:
+        """
+        | Name of the payment product or group based on the locale that was included in the request
+
+        Type: str
+        """
+        return self.__label
+
+    @label.setter
+    def label(self, value: Optional[str]) -> None:
+        self.__label = value
+
+    @property
+    def logo(self) -> Optional[str]:
+        """
+        | Partial URL that you can reference for the image of this payment product. You can use our server-side resize functionality by appending '?size={{width}}x{{height}}' to the full URL, where width and height are specified in pixels. The resized image will always keep its correct aspect ratio.
+
+        Type: str
+        """
+        return self.__logo
+
+    @logo.setter
+    def logo(self, value: Optional[str]) -> None:
+        self.__logo = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProductDisplayHints, self).to_dictionary()
+        if self.display_order is not None:
+            dictionary['displayOrder'] = self.display_order
+        if self.label is not None:
+            dictionary['label'] = self.label
+        if self.logo is not None:
+            dictionary['logo'] = self.logo
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductDisplayHints':
+        super(PaymentProductDisplayHints, self).from_dictionary(dictionary)
+        if 'displayOrder' in dictionary:
+            self.display_order = dictionary['displayOrder']
+        if 'label' in dictionary:
+            self.label = dictionary['label']
+        if 'logo' in dictionary:
+            self.logo = dictionary['logo']
+        return self