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

onlinepayments/sdk/domain/submit_batch_response.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class SubmitBatchResponse(DataObject):
+
+    __merchant_batch_reference: Optional[str] = None
+    __total_count: Optional[int] = None
+
+    @property
+    def merchant_batch_reference(self) -> Optional[str]:
+        """
+        | Unique batch reference submitted by the merchant.
+
+        Type: str
+        """
+        return self.__merchant_batch_reference
+
+    @merchant_batch_reference.setter
+    def merchant_batch_reference(self, value: Optional[str]) -> None:
+        self.__merchant_batch_reference = value
+
+    @property
+    def total_count(self) -> Optional[int]:
+        """
+        | The total number of batch items that were included in the submitted batch.
+
+        Type: int
+        """
+        return self.__total_count
+
+    @total_count.setter
+    def total_count(self, value: Optional[int]) -> None:
+        self.__total_count = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SubmitBatchResponse, self).to_dictionary()
+        if self.merchant_batch_reference is not None:
+            dictionary['merchantBatchReference'] = self.merchant_batch_reference
+        if self.total_count is not None:
+            dictionary['totalCount'] = self.total_count
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SubmitBatchResponse':
+        super(SubmitBatchResponse, self).from_dictionary(dictionary)
+        if 'merchantBatchReference' in dictionary:
+            self.merchant_batch_reference = dictionary['merchantBatchReference']
+        if 'totalCount' in dictionary:
+            self.total_count = dictionary['totalCount']
+        return self

onlinepayments/sdk/domain/subsequent_card_payment_method_specific_input.py

@@ -0,0 +1,175 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .market_place import MarketPlace
+
+
+class SubsequentCardPaymentMethodSpecificInput(DataObject):
+
+    __authorization_mode: Optional[str] = None
+    __market_place: Optional[MarketPlace] = None
+    __payment_number: Optional[int] = None
+    __scheme_reference_data: Optional[str] = None
+    __subsequent_type: Optional[str] = None
+    __token: Optional[str] = None
+    __transaction_channel: Optional[str] = None
+
+    @property
+    def authorization_mode(self) -> Optional[str]:
+        """
+        | Determines the type of the authorization that will be used. Allowed values:
+        
+        * FINAL_AUTHORIZATION - The payment creation results in an authorization that is ready for capture. Final authorizations can't be reversed and need to be captured for the full amount within 7 days.
+        * PRE_AUTHORIZATION - The payment creation results in a pre-authorization that is ready for capture. Pre-authortizations can be reversed and can be captured within 30 days. The capture amount can be lower than the authorized amount.
+        * SALE - The payment creation results in an authorization that is already captured at the moment of approval.
+        
+        | Only used with some acquirers, ignored for acquirers that do not support this. In case the acquirer does not allow this to be specified the authorizationMode is 'unspecified', which behaves similar to a final authorization.
+
+        Type: str
+        """
+        return self.__authorization_mode
+
+    @authorization_mode.setter
+    def authorization_mode(self, value: Optional[str]) -> None:
+        self.__authorization_mode = value
+
+    @property
+    def market_place(self) -> Optional[MarketPlace]:
+        """
+        | Object containing marketplace-related data for additional information on sub-merchants (retailers) transacting via the marketplace’s platform. This object is required for platforms onboarding multiple sellers to ensure accurate identification and attribution of each transaction. The platform must collect and submit the retailer’s country and regional information in accordance with card scheme requirements. In some cases, Visa may treat specific regions—such as EU member states—as a single country entity for regulatory and reporting purposes.
+
+        Type: :class:`onlinepayments.sdk.domain.market_place.MarketPlace`
+        """
+        return self.__market_place
+
+    @market_place.setter
+    def market_place(self, value: Optional[MarketPlace]) -> None:
+        self.__market_place = value
+
+    @property
+    def payment_number(self) -> Optional[int]:
+        """
+        | This payment's ordinal number in the sequence of payments.  As the payments are numbered from 1 to the totalNumberOfPayments provided at initialization of the sequence in the multiplePaymentInformation container, the allowed values for this field actually depend on whether the initial call to CreatePayment or CreateHostedCheckout led to a payment or not.
+        
+        * if the initial call led to a payment, since it is implicitly numbered 1, then the allowed values for this field range from 2 to the totalNumberOfPayments.
+        * if the initial call did not lead to a payment (e.g. this was a 0 amount operation for authentication), then the allowed values for this field range from 1 to the totalNumberOfPayments.
+
+        Type: int
+        """
+        return self.__payment_number
+
+    @payment_number.setter
+    def payment_number(self, value: Optional[int]) -> None:
+        self.__payment_number = value
+
+    @property
+    def scheme_reference_data(self) -> Optional[str]:
+        """
+        | Deprecated: This is the unique Scheme Reference Data from the initial transaction that was performed with a Strong Customer Authentication. In case this value is unknown, a Scheme Reference of an earlier transaction that was part of the same sequence can be used as a fall-back. Still, it is strongly advised to submit this value for any Merchant Initiated Transaction or any recurring transaction (hereby defined as "Subsequent").
+
+        Type: str
+
+        Deprecated; Deprecated
+        """
+        return self.__scheme_reference_data
+
+    @scheme_reference_data.setter
+    def scheme_reference_data(self, value: Optional[str]) -> None:
+        self.__scheme_reference_data = value
+
+    @property
+    def subsequent_type(self) -> Optional[str]:
+        """
+        | Determines the type of the subsequent that will be used. Allowed values:
+        
+        * Recurring - Transactions processed at fixed, regular intervals not to exceed one year between Transactions, representing an agreement between a cardholder and a merchant to purchase goods or services provided over a period of time. Note that a recurring MIT transaction is initiated by the merchant (payee) not the customer (payer) and so is out of scope of PSD2. Recurring transactions that are in scope of PSD2 (and therefore may benefit from the recurring transaction exemption) are those that are customer (payer) initiates, e.g. standing orders set up from a bank account.
+        * Unscheduled - A transaction using a stored credential for a fixed or variable amount that does not occur on a scheduled or regularly occurring transaction date, where the cardholder has provided consent for the merchant to initiate one or more future transactions which are not initiated by the cardholder. This transaction type is based on an agreement with the cardholder and is not to be confused with cardholder initiated transactions performed with stored credentials (CITs are in scope of PSD2 whereas UCOF transactions are MITs and thus out of scope).
+        * Installment - Installment payments describe a single purchase of goods or services billed to a cardholder in multiple transactions over a period of time agreed by the cardholder and merchant.
+        * NoShow - A No-show is a transaction where the merchant is enabled to charge for services which the cardholder entered into an agreement to purchase but did not meet the terms of the agreement.
+        * DelayedCharge - A delayed charge is typically used in hotel, cruise lines and vehicle rental payment scenarios to perform a supplemental account charge after original services are rendered.
+        * PartialShipment - I-P e-Commerce scenario whereby credentials have been stored to enable subsequent MITs per shipment. For this type of use case, PartialShipment is expected on both the initial CIT and eventual subsequent MITs to complete the order.
+        * Resubmission - This is an event that occurs when the original purchase occurred, but the merchant was not able to get authorization at the time the goods or services were provided. This is only applicable to contactless transit transactions.
+
+        Type: str
+        """
+        return self.__subsequent_type
+
+    @subsequent_type.setter
+    def subsequent_type(self, value: Optional[str]) -> None:
+        self.__subsequent_type = value
+
+    @property
+    def token(self) -> Optional[str]:
+        """
+        | Deprecated: ID of the token to use to create the payment.
+
+        Type: str
+
+        Deprecated; ID of the token to use to create the payment.
+        """
+        return self.__token
+
+    @token.setter
+    def token(self, value: Optional[str]) -> None:
+        self.__token = value
+
+    @property
+    def transaction_channel(self) -> Optional[str]:
+        """
+        | Indicates the channel via which the payment is created. Allowed values:
+        
+        * ECOMMERCE - The transaction is a regular E-Commerce transaction.
+        * MOTO - The transaction is a Mail Order/Telephone Order.
+        
+        | Defaults to ECOMMERCE.
+
+        Type: str
+        """
+        return self.__transaction_channel
+
+    @transaction_channel.setter
+    def transaction_channel(self, value: Optional[str]) -> None:
+        self.__transaction_channel = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SubsequentCardPaymentMethodSpecificInput, self).to_dictionary()
+        if self.authorization_mode is not None:
+            dictionary['authorizationMode'] = self.authorization_mode
+        if self.market_place is not None:
+            dictionary['marketPlace'] = self.market_place.to_dictionary()
+        if self.payment_number is not None:
+            dictionary['paymentNumber'] = self.payment_number
+        if self.scheme_reference_data is not None:
+            dictionary['schemeReferenceData'] = self.scheme_reference_data
+        if self.subsequent_type is not None:
+            dictionary['subsequentType'] = self.subsequent_type
+        if self.token is not None:
+            dictionary['token'] = self.token
+        if self.transaction_channel is not None:
+            dictionary['transactionChannel'] = self.transaction_channel
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SubsequentCardPaymentMethodSpecificInput':
+        super(SubsequentCardPaymentMethodSpecificInput, self).from_dictionary(dictionary)
+        if 'authorizationMode' in dictionary:
+            self.authorization_mode = dictionary['authorizationMode']
+        if 'marketPlace' in dictionary:
+            if not isinstance(dictionary['marketPlace'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['marketPlace']))
+            value = MarketPlace()
+            self.market_place = value.from_dictionary(dictionary['marketPlace'])
+        if 'paymentNumber' in dictionary:
+            self.payment_number = dictionary['paymentNumber']
+        if 'schemeReferenceData' in dictionary:
+            self.scheme_reference_data = dictionary['schemeReferenceData']
+        if 'subsequentType' in dictionary:
+            self.subsequent_type = dictionary['subsequentType']
+        if 'token' in dictionary:
+            self.token = dictionary['token']
+        if 'transactionChannel' in dictionary:
+            self.transaction_channel = dictionary['transactionChannel']
+        return self

onlinepayments/sdk/domain/subsequent_payment_batch_request.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .subsequent_payment_request import SubsequentPaymentRequest
+
+
+class SubsequentPaymentBatchRequest(DataObject):
+
+    __payment_id: Optional[str] = None
+    __subsequent: Optional[SubsequentPaymentRequest] = None
+
+    @property
+    def payment_id(self) -> Optional[str]:
+        """
+        | This is our unique payment transaction identifier.
+
+        Type: str
+        """
+        return self.__payment_id
+
+    @payment_id.setter
+    def payment_id(self, value: Optional[str]) -> None:
+        self.__payment_id = value
+
+    @property
+    def subsequent(self) -> Optional[SubsequentPaymentRequest]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.subsequent_payment_request.SubsequentPaymentRequest`
+        """
+        return self.__subsequent
+
+    @subsequent.setter
+    def subsequent(self, value: Optional[SubsequentPaymentRequest]) -> None:
+        self.__subsequent = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SubsequentPaymentBatchRequest, self).to_dictionary()
+        if self.payment_id is not None:
+            dictionary['paymentId'] = self.payment_id
+        if self.subsequent is not None:
+            dictionary['subsequent'] = self.subsequent.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SubsequentPaymentBatchRequest':
+        super(SubsequentPaymentBatchRequest, self).from_dictionary(dictionary)
+        if 'paymentId' in dictionary:
+            self.payment_id = dictionary['paymentId']
+        if 'subsequent' in dictionary:
+            if not isinstance(dictionary['subsequent'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['subsequent']))
+            value = SubsequentPaymentRequest()
+            self.subsequent = value.from_dictionary(dictionary['subsequent'])
+        return self

onlinepayments/sdk/domain/subsequent_payment_product5001_specific_input.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class SubsequentPaymentProduct5001SpecificInput(DataObject):
+
+    __subsequent_type: Optional[str] = None
+
+    @property
+    def subsequent_type(self) -> Optional[str]:
+        """
+        | Determines the type of the subsequent that will be used. Allowed values:
+        
+        * recurring - Transactions processed at fixed, regular intervals not to exceed one year between Transactions, representing an agreement between a consumer and a merchant to purchase goods or services provided over a period of time. Note that a recurring MIT transaction is initiated by the merchant (payee) not the customer (payer) and so is out of scope of PSD2. Recurring transactions that are in scope of PSD2 (and therefore may benefit from the recurring transaction exemption) are those that are customer (payer) initiates, e.g. standing orders set up from a bank account.
+        * installment - Installment payments describe a single purchase of goods or services billed to a consumer in multiple transactions over a period of time agreed by the consumer and merchant.
+        * other - other cases
+
+        Type: str
+        """
+        return self.__subsequent_type
+
+    @subsequent_type.setter
+    def subsequent_type(self, value: Optional[str]) -> None:
+        self.__subsequent_type = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SubsequentPaymentProduct5001SpecificInput, self).to_dictionary()
+        if self.subsequent_type is not None:
+            dictionary['subsequentType'] = self.subsequent_type
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SubsequentPaymentProduct5001SpecificInput':
+        super(SubsequentPaymentProduct5001SpecificInput, self).from_dictionary(dictionary)
+        if 'subsequentType' in dictionary:
+            self.subsequent_type = dictionary['subsequentType']
+        return self

onlinepayments/sdk/domain/subsequent_payment_request.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .omnichannel_subsequent_specific_input import OmnichannelSubsequentSpecificInput
+from .order import Order
+from .subsequent_card_payment_method_specific_input import SubsequentCardPaymentMethodSpecificInput
+from .subsequent_payment_product5001_specific_input import SubsequentPaymentProduct5001SpecificInput
+
+
+class SubsequentPaymentRequest(DataObject):
+
+    __omnichannel_subsequent_specific_input: Optional[OmnichannelSubsequentSpecificInput] = None
+    __order: Optional[Order] = None
+    __subsequent_payment_product5001_specific_input: Optional[SubsequentPaymentProduct5001SpecificInput] = None
+    __subsequentcard_payment_method_specific_input: Optional[SubsequentCardPaymentMethodSpecificInput] = None
+
+    @property
+    def omnichannel_subsequent_specific_input(self) -> Optional[OmnichannelSubsequentSpecificInput]:
+        """
+        | This object contains additional subsequent details for omnichannel merchants.
+
+        Type: :class:`onlinepayments.sdk.domain.omnichannel_subsequent_specific_input.OmnichannelSubsequentSpecificInput`
+        """
+        return self.__omnichannel_subsequent_specific_input
+
+    @omnichannel_subsequent_specific_input.setter
+    def omnichannel_subsequent_specific_input(self, value: Optional[OmnichannelSubsequentSpecificInput]) -> None:
+        self.__omnichannel_subsequent_specific_input = value
+
+    @property
+    def order(self) -> Optional[Order]:
+        """
+        | The order object contains order-related data; Please note that this object is required to submit the amount.
+
+        Type: :class:`onlinepayments.sdk.domain.order.Order`
+        """
+        return self.__order
+
+    @order.setter
+    def order(self, value: Optional[Order]) -> None:
+        self.__order = value
+
+    @property
+    def subsequent_payment_product5001_specific_input(self) -> Optional[SubsequentPaymentProduct5001SpecificInput]:
+        """
+        | Specific data is required for Bizum subsequent payment.
+
+        Type: :class:`onlinepayments.sdk.domain.subsequent_payment_product5001_specific_input.SubsequentPaymentProduct5001SpecificInput`
+        """
+        return self.__subsequent_payment_product5001_specific_input
+
+    @subsequent_payment_product5001_specific_input.setter
+    def subsequent_payment_product5001_specific_input(self, value: Optional[SubsequentPaymentProduct5001SpecificInput]) -> None:
+        self.__subsequent_payment_product5001_specific_input = value
+
+    @property
+    def subsequentcard_payment_method_specific_input(self) -> Optional[SubsequentCardPaymentMethodSpecificInput]:
+        """
+        | Object containing the specific input details for subsequent card payments
+
+        Type: :class:`onlinepayments.sdk.domain.subsequent_card_payment_method_specific_input.SubsequentCardPaymentMethodSpecificInput`
+        """
+        return self.__subsequentcard_payment_method_specific_input
+
+    @subsequentcard_payment_method_specific_input.setter
+    def subsequentcard_payment_method_specific_input(self, value: Optional[SubsequentCardPaymentMethodSpecificInput]) -> None:
+        self.__subsequentcard_payment_method_specific_input = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SubsequentPaymentRequest, self).to_dictionary()
+        if self.omnichannel_subsequent_specific_input is not None:
+            dictionary['omnichannelSubsequentSpecificInput'] = self.omnichannel_subsequent_specific_input.to_dictionary()
+        if self.order is not None:
+            dictionary['order'] = self.order.to_dictionary()
+        if self.subsequent_payment_product5001_specific_input is not None:
+            dictionary['subsequentPaymentProduct5001SpecificInput'] = self.subsequent_payment_product5001_specific_input.to_dictionary()
+        if self.subsequentcard_payment_method_specific_input is not None:
+            dictionary['subsequentcardPaymentMethodSpecificInput'] = self.subsequentcard_payment_method_specific_input.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SubsequentPaymentRequest':
+        super(SubsequentPaymentRequest, self).from_dictionary(dictionary)
+        if 'omnichannelSubsequentSpecificInput' in dictionary:
+            if not isinstance(dictionary['omnichannelSubsequentSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['omnichannelSubsequentSpecificInput']))
+            value = OmnichannelSubsequentSpecificInput()
+            self.omnichannel_subsequent_specific_input = value.from_dictionary(dictionary['omnichannelSubsequentSpecificInput'])
+        if 'order' in dictionary:
+            if not isinstance(dictionary['order'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['order']))
+            value = Order()
+            self.order = value.from_dictionary(dictionary['order'])
+        if 'subsequentPaymentProduct5001SpecificInput' in dictionary:
+            if not isinstance(dictionary['subsequentPaymentProduct5001SpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['subsequentPaymentProduct5001SpecificInput']))
+            value = SubsequentPaymentProduct5001SpecificInput()
+            self.subsequent_payment_product5001_specific_input = value.from_dictionary(dictionary['subsequentPaymentProduct5001SpecificInput'])
+        if 'subsequentcardPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['subsequentcardPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['subsequentcardPaymentMethodSpecificInput']))
+            value = SubsequentCardPaymentMethodSpecificInput()
+            self.subsequentcard_payment_method_specific_input = value.from_dictionary(dictionary['subsequentcardPaymentMethodSpecificInput'])
+        return self

onlinepayments/sdk/domain/subsequent_payment_response.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .payment_response import PaymentResponse
+
+
+class SubsequentPaymentResponse(DataObject):
+
+    __payment: Optional[PaymentResponse] = None
+
+    @property
+    def payment(self) -> Optional[PaymentResponse]:
+        """
+        | This object holds the properties related to the payment.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_response.PaymentResponse`
+        """
+        return self.__payment
+
+    @payment.setter
+    def payment(self, value: Optional[PaymentResponse]) -> None:
+        self.__payment = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SubsequentPaymentResponse, self).to_dictionary()
+        if self.payment is not None:
+            dictionary['payment'] = self.payment.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SubsequentPaymentResponse':
+        super(SubsequentPaymentResponse, self).from_dictionary(dictionary)
+        if 'payment' in dictionary:
+            if not isinstance(dictionary['payment'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payment']))
+            value = PaymentResponse()
+            self.payment = value.from_dictionary(dictionary['payment'])
+        return self

onlinepayments/sdk/domain/surcharge.py

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .amount_of_money import AmountOfMoney
+from .data_object import DataObject
+from .surcharge_rate import SurchargeRate
+
+
+class Surcharge(DataObject):
+
+    __net_amount: Optional[AmountOfMoney] = None
+    __payment_product_id: Optional[int] = None
+    __result: Optional[str] = None
+    __surcharge_amount: Optional[AmountOfMoney] = None
+    __surcharge_rate: Optional[SurchargeRate] = None
+    __total_amount: Optional[AmountOfMoney] = None
+
+    @property
+    def net_amount(self) -> Optional[AmountOfMoney]:
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`onlinepayments.sdk.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__net_amount
+
+    @net_amount.setter
+    def net_amount(self, value: Optional[AmountOfMoney]) -> None:
+        self.__net_amount = value
+
+    @property
+    def payment_product_id(self) -> Optional[int]:
+        """
+        | Payment product identifier - Please see Products documentation for a full overview of possible values.
+
+        Type: int
+        """
+        return self.__payment_product_id
+
+    @payment_product_id.setter
+    def payment_product_id(self, value: Optional[int]) -> None:
+        self.__payment_product_id = value
+
+    @property
+    def result(self) -> Optional[str]:
+        """
+        | Token describing result. OK - A Surcharge Amount was successfully calculated, NO_SURCHARGE - A configured surcharge rate could not be found for the payment product
+
+        Type: str
+        """
+        return self.__result
+
+    @result.setter
+    def result(self, value: Optional[str]) -> None:
+        self.__result = value
+
+    @property
+    def surcharge_amount(self) -> Optional[AmountOfMoney]:
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`onlinepayments.sdk.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__surcharge_amount
+
+    @surcharge_amount.setter
+    def surcharge_amount(self, value: Optional[AmountOfMoney]) -> None:
+        self.__surcharge_amount = value
+
+    @property
+    def surcharge_rate(self) -> Optional[SurchargeRate]:
+        """
+        | A summary of surcharge details used in the calculation of the surcharge amount. null if result = NO_SURCHARGE
+
+        Type: :class:`onlinepayments.sdk.domain.surcharge_rate.SurchargeRate`
+        """
+        return self.__surcharge_rate
+
+    @surcharge_rate.setter
+    def surcharge_rate(self, value: Optional[SurchargeRate]) -> None:
+        self.__surcharge_rate = value
+
+    @property
+    def total_amount(self) -> Optional[AmountOfMoney]:
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`onlinepayments.sdk.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__total_amount
+
+    @total_amount.setter
+    def total_amount(self, value: Optional[AmountOfMoney]) -> None:
+        self.__total_amount = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Surcharge, self).to_dictionary()
+        if self.net_amount is not None:
+            dictionary['netAmount'] = self.net_amount.to_dictionary()
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        if self.result is not None:
+            dictionary['result'] = self.result
+        if self.surcharge_amount is not None:
+            dictionary['surchargeAmount'] = self.surcharge_amount.to_dictionary()
+        if self.surcharge_rate is not None:
+            dictionary['surchargeRate'] = self.surcharge_rate.to_dictionary()
+        if self.total_amount is not None:
+            dictionary['totalAmount'] = self.total_amount.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Surcharge':
+        super(Surcharge, self).from_dictionary(dictionary)
+        if 'netAmount' in dictionary:
+            if not isinstance(dictionary['netAmount'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['netAmount']))
+            value = AmountOfMoney()
+            self.net_amount = value.from_dictionary(dictionary['netAmount'])
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        if 'result' in dictionary:
+            self.result = dictionary['result']
+        if 'surchargeAmount' in dictionary:
+            if not isinstance(dictionary['surchargeAmount'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['surchargeAmount']))
+            value = AmountOfMoney()
+            self.surcharge_amount = value.from_dictionary(dictionary['surchargeAmount'])
+        if 'surchargeRate' in dictionary:
+            if not isinstance(dictionary['surchargeRate'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['surchargeRate']))
+            value = SurchargeRate()
+            self.surcharge_rate = value.from_dictionary(dictionary['surchargeRate'])
+        if 'totalAmount' in dictionary:
+            if not isinstance(dictionary['totalAmount'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['totalAmount']))
+            value = AmountOfMoney()
+            self.total_amount = value.from_dictionary(dictionary['totalAmount'])
+        return self

onlinepayments/sdk/domain/surcharge_calculation_card.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class SurchargeCalculationCard(DataObject):
+
+    __card_number: Optional[str] = None
+    __payment_product_id: Optional[int] = None
+
+    @property
+    def card_number(self) -> Optional[str]:
+        """
+        | The complete credit/debit card number (also known as the PAN) is always obfuscated in any of our responses.
+
+        Type: str
+        """
+        return self.__card_number
+
+    @card_number.setter
+    def card_number(self, value: Optional[str]) -> None:
+        self.__card_number = value
+
+    @property
+    def payment_product_id(self) -> Optional[int]:
+        """
+        | Payment product identifier - Please see Products documentation for a full overview of possible values.
+
+        Type: int
+        """
+        return self.__payment_product_id
+
+    @payment_product_id.setter
+    def payment_product_id(self, value: Optional[int]) -> None:
+        self.__payment_product_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SurchargeCalculationCard, self).to_dictionary()
+        if self.card_number is not None:
+            dictionary['cardNumber'] = self.card_number
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SurchargeCalculationCard':
+        super(SurchargeCalculationCard, self).from_dictionary(dictionary)
+        if 'cardNumber' in dictionary:
+            self.card_number = dictionary['cardNumber']
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        return self