onlinepayments-sdk-python3 5.1.0__zip → 6.0.0__zip

{onlinepayments_sdk_python3-5.1.0/onlinepayments_sdk_python3.egg-info → onlinepayments_sdk_python3-6.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onlinepayments-sdk-python3
-Version: 5.1.0
+Version: 6.0.0
 Summary: SDK to communicate with the Online Payments platform using the Online Payments Server API
 Home-page: https://github.com/wl-online-payments-direct/sdk-python3
 Author: Worldline Direct support team

{onlinepayments_sdk_python3-5.1.0 → onlinepayments_sdk_python3-6.0.0}/onlinepayments/sdk/authentication/v1hmac_authenticator.py

@@ -89,7 +89,8 @@ class V1HmacAuthenticator(Authenticator):
         string += canonicalized_resource + "\n"
         return str(string)
 
-    def __to_canonicalized_resource(self, resource_uri):
+    @staticmethod
+    def __to_canonicalized_resource(resource_uri):
         """
         Returns the encoded URI path without the HTTP method and including all
         decoded query parameters.
@@ -100,13 +101,15 @@ class V1HmacAuthenticator(Authenticator):
             string += "?" + resource_uri.query
         return str(string)
 
-    def __to_canonicalize_header_name(self, original_name):
+    @staticmethod
+    def __to_canonicalize_header_name(original_name):
         if original_name is None:
             return None
         else:
             return original_name.lower()
 
-    def to_canonicalize_header_value(self, original_value):
+    @staticmethod
+    def to_canonicalize_header_value(original_value):
         # For now V1HMAC is the only supported AuthorizationType so always use
         # the same logic.
         if original_value is None:

{onlinepayments_sdk_python3-5.1.0 → onlinepayments_sdk_python3-6.0.0}/onlinepayments/sdk/communication/default_connection.py

@@ -1,13 +1,16 @@
+from __future__ import annotations
+
 import math
 import uuid
 from datetime import datetime, timedelta
-from typing import Mapping, Optional, Sequence
+from typing import Mapping, Optional, Sequence, Any, Generator
 from urllib.parse import urlparse
 
 import requests
 from requests.adapters import HTTPAdapter
 from requests.models import PreparedRequest
 from requests.exceptions import RequestException, Timeout
+from requests.structures import CaseInsensitiveDict
 from requests_toolbelt import MultipartEncoder
 
 from .communication_exception import CommunicationException
@@ -137,7 +140,8 @@ class DefaultConnection(PooledConnection):
             return _wrapper
 
     @_ToResult()
-    def _request(self, method: str, url: URI, headers: Sequence[RequestHeader], body: RequestBody = None) -> Response:
+    def _request(self, method: str, url: URI, headers: Sequence[RequestHeader], body: RequestBody = None) -> Generator[
+        tuple[int, CaseInsensitiveDict[str]] | Any, Any, None]:
         """
         Perform a request to the server given by url
 

{onlinepayments_sdk_python3-5.1.0 → onlinepayments_sdk_python3-6.0.0}/onlinepayments/sdk/communication/metadata_provider.py

@@ -23,7 +23,7 @@ class MetadataProvider(IMetadataProvider):
     """
     Provides meta info about the server.
     """
-    __sdk_version = "5.1.0"
+    __sdk_version = "6.0.0"
     __server_meta_info_header = "X-GCS-ServerMetaInfo"
     __prohibited_headers = tuple(sorted([__server_meta_info_header, "X-GCS-Idempotence-Key", "Date", "Content-Type", "Authorization"],
                                         key=str.lower))

{onlinepayments_sdk_python3-5.1.0 → onlinepayments_sdk_python3-6.0.0}/onlinepayments/sdk/domain/account_on_file.py

@@ -13,7 +13,7 @@ class AccountOnFile(DataObject):
 
     __attributes: Optional[List[AccountOnFileAttribute]] = None
     __display_hints: Optional[AccountOnFileDisplayHints] = None
-    __id: Optional[int] = None
+    __id: Optional[str] = None
     __payment_product_id: Optional[int] = None
 
     @property
@@ -41,14 +41,16 @@ class AccountOnFile(DataObject):
         self.__display_hints = value
 
     @property
-    def id(self) -> Optional[int]:
+    def id(self) -> Optional[str]:
         """
-        Type: int
+        | ID of the token
+
+        Type: str
         """
         return self.__id
 
     @id.setter
-    def id(self, value: Optional[int]) -> None:
+    def id(self, value: Optional[str]) -> None:
         self.__id = value
 
     @property

{onlinepayments_sdk_python3-5.1.0 → onlinepayments_sdk_python3-6.0.0}/onlinepayments/sdk/domain/cancel_payment_request.py

@@ -6,12 +6,14 @@ from typing import Optional
 
 from .amount_of_money import AmountOfMoney
 from .data_object import DataObject
+from .operation_payment_references import OperationPaymentReferences
 
 
 class CancelPaymentRequest(DataObject):
 
     __amount_of_money: Optional[AmountOfMoney] = None
     __is_final: Optional[bool] = None
+    __operation_references: Optional[OperationPaymentReferences] = None
 
     @property
     def amount_of_money(self) -> Optional[AmountOfMoney]:
@@ -39,12 +41,27 @@ class CancelPaymentRequest(DataObject):
     def is_final(self, value: Optional[bool]) -> None:
         self.__is_final = value
 
+    @property
+    def operation_references(self) -> Optional[OperationPaymentReferences]:
+        """
+        | Object that holds all reference properties that are linked to this transaction
+
+        Type: :class:`onlinepayments.sdk.domain.operation_payment_references.OperationPaymentReferences`
+        """
+        return self.__operation_references
+
+    @operation_references.setter
+    def operation_references(self, value: Optional[OperationPaymentReferences]) -> None:
+        self.__operation_references = value
+
     def to_dictionary(self) -> dict:
         dictionary = super(CancelPaymentRequest, self).to_dictionary()
         if self.amount_of_money is not None:
             dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
         if self.is_final is not None:
             dictionary['isFinal'] = self.is_final
+        if self.operation_references is not None:
+            dictionary['operationReferences'] = self.operation_references.to_dictionary()
         return dictionary
 
     def from_dictionary(self, dictionary: dict) -> 'CancelPaymentRequest':
@@ -56,4 +73,9 @@ class CancelPaymentRequest(DataObject):
             self.amount_of_money = value.from_dictionary(dictionary['amountOfMoney'])
         if 'isFinal' in dictionary:
             self.is_final = dictionary['isFinal']
+        if 'operationReferences' in dictionary:
+            if not isinstance(dictionary['operationReferences'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['operationReferences']))
+            value = OperationPaymentReferences()
+            self.operation_references = value.from_dictionary(dictionary['operationReferences'])
         return self

onlinepayments_sdk_python3-6.0.0/onlinepayments/sdk/domain/card_essentials.py

@@ -0,0 +1,369 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from datetime import date
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CardEssentials(DataObject):
+
+    __bin: Optional[str] = None
+    __card_corporate_indicator: Optional[bool] = None
+    __card_effective_date: Optional[date] = None
+    __card_effective_date_indicator: Optional[bool] = None
+    __card_number: Optional[str] = None
+    __card_pan_type: Optional[str] = None
+    __card_product_code: Optional[str] = None
+    __card_product_usage_label: Optional[str] = None
+    __card_scheme: Optional[str] = None
+    __card_type: Optional[str] = None
+    __country_code: Optional[str] = None
+    __expiry_date: Optional[str] = None
+    __issuer_code: Optional[str] = None
+    __issuer_name: Optional[str] = None
+    __issuing_country_code: Optional[str] = None
+    __pan_length_max: Optional[int] = None
+    __pan_length_min: Optional[int] = None
+    __pan_luhn_check: Optional[bool] = None
+
+    @property
+    def bin(self) -> Optional[str]:
+        """
+        | The first digits of the credit card number from left to right with a minimum of 6 digits.
+
+        Type: str
+        """
+        return self.__bin
+
+    @bin.setter
+    def bin(self, value: Optional[str]) -> None:
+        self.__bin = value
+
+    @property
+    def card_corporate_indicator(self) -> Optional[bool]:
+        """
+        | Indicates whether the card is an Enterprise / Commercial card or not
+
+        Type: bool
+        """
+        return self.__card_corporate_indicator
+
+    @card_corporate_indicator.setter
+    def card_corporate_indicator(self, value: Optional[bool]) -> None:
+        self.__card_corporate_indicator = value
+
+    @property
+    def card_effective_date(self) -> Optional[date]:
+        """
+        | The card effective date (YYYY-MM-DD)
+
+        Type: date
+        """
+        return self.__card_effective_date
+
+    @card_effective_date.setter
+    def card_effective_date(self, value: Optional[date]) -> None:
+        self.__card_effective_date = value
+
+    @property
+    def card_effective_date_indicator(self) -> Optional[bool]:
+        """
+        | Indicator of existence of a card effective date
+
+        Type: bool
+        """
+        return self.__card_effective_date_indicator
+
+    @card_effective_date_indicator.setter
+    def card_effective_date_indicator(self, value: Optional[bool]) -> None:
+        self.__card_effective_date_indicator = value
+
+    @property
+    def card_number(self) -> Optional[str]:
+        """
+        | The masked credit/debit card number
+
+        Type: str
+        """
+        return self.__card_number
+
+    @card_number.setter
+    def card_number(self, value: Optional[str]) -> None:
+        self.__card_number = value
+
+    @property
+    def card_pan_type(self) -> Optional[str]:
+        """
+        | PAN type sent
+        
+        * ``dpan`` Digital PAN
+        * ``pan`` Real PAN
+
+        Type: str
+        """
+        return self.__card_pan_type
+
+    @card_pan_type.setter
+    def card_pan_type(self, value: Optional[str]) -> None:
+        self.__card_pan_type = value
+
+    @property
+    def card_product_code(self) -> Optional[str]:
+        """
+        | Product code of the card
+
+        Type: str
+        """
+        return self.__card_product_code
+
+    @card_product_code.setter
+    def card_product_code(self, value: Optional[str]) -> None:
+        self.__card_product_code = value
+
+    @property
+    def card_product_usage_label(self) -> Optional[str]:
+        """
+        | Profile name of the card which is displayed on payment electronic ticket in accordance with MPADS requirements
+        
+        * ``commercial`` Business card
+        * ``credit`` Credit card
+        * ``debit`` Debit card
+        * ``prepaid`` Prepaid card
+
+        Type: str
+        """
+        return self.__card_product_usage_label
+
+    @card_product_usage_label.setter
+    def card_product_usage_label(self, value: Optional[str]) -> None:
+        self.__card_product_usage_label = value
+
+    @property
+    def card_scheme(self) -> Optional[str]:
+        """
+        | Network name associated with the card that is informational only and not to be coded against
+        
+        * ``AmericanExpress`` American Express scheme
+        * ``Bancontact`` Bancontact scheme
+        * ``Cb`` Cartes Bancaires scheme
+        * ``Cup`` China UnionPay scheme
+        * ``Dankort`` Dankort scheme
+        * ``DinersDiscover`` Diners Discover scheme
+        * ``Eftpos`` eftpos scheme
+        * ``Jcb`` Japan Credit Bureau scheme
+        * ``Mastercard`` Mastercard scheme
+        * ``Oney`` Oney scheme
+        * ``Uatp`` Universal Air Travel Plan scheme
+        * ``Visa`` Visa scheme
+
+        Type: str
+        """
+        return self.__card_scheme
+
+    @card_scheme.setter
+    def card_scheme(self, value: Optional[str]) -> None:
+        self.__card_scheme = value
+
+    @property
+    def card_type(self) -> Optional[str]:
+        """
+        | The card's type as categorised by the payment method. Possible values are:
+        
+        * Credit
+        * Debit
+        * Prepaid
+
+        Type: str
+        """
+        return self.__card_type
+
+    @card_type.setter
+    def card_type(self, value: Optional[str]) -> None:
+        self.__card_type = 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 expiry_date(self) -> Optional[str]:
+        """
+        | Expiry date of the card Format: MMYY
+
+        Type: str
+        """
+        return self.__expiry_date
+
+    @expiry_date.setter
+    def expiry_date(self, value: Optional[str]) -> None:
+        self.__expiry_date = value
+
+    @property
+    def issuer_code(self) -> Optional[str]:
+        """
+        | Issuer code of the card
+
+        Type: str
+        """
+        return self.__issuer_code
+
+    @issuer_code.setter
+    def issuer_code(self, value: Optional[str]) -> None:
+        self.__issuer_code = value
+
+    @property
+    def issuer_name(self) -> Optional[str]:
+        """
+        | Issuer name of the card
+
+        Type: str
+        """
+        return self.__issuer_name
+
+    @issuer_name.setter
+    def issuer_name(self, value: Optional[str]) -> None:
+        self.__issuer_name = value
+
+    @property
+    def issuing_country_code(self) -> Optional[str]:
+        """
+        | ISO 3166-1 alpha-2 country code in which the card has been issued
+
+        Type: str
+        """
+        return self.__issuing_country_code
+
+    @issuing_country_code.setter
+    def issuing_country_code(self, value: Optional[str]) -> None:
+        self.__issuing_country_code = value
+
+    @property
+    def pan_length_max(self) -> Optional[int]:
+        """
+        | Maximum length of the PAN
+
+        Type: int
+        """
+        return self.__pan_length_max
+
+    @pan_length_max.setter
+    def pan_length_max(self, value: Optional[int]) -> None:
+        self.__pan_length_max = value
+
+    @property
+    def pan_length_min(self) -> Optional[int]:
+        """
+        | Minimal length of the PAN
+
+        Type: int
+        """
+        return self.__pan_length_min
+
+    @pan_length_min.setter
+    def pan_length_min(self, value: Optional[int]) -> None:
+        self.__pan_length_min = value
+
+    @property
+    def pan_luhn_check(self) -> Optional[bool]:
+        """
+        | Indicates whether the PAN is controlled with Lühn Key algorithm
+
+        Type: bool
+        """
+        return self.__pan_luhn_check
+
+    @pan_luhn_check.setter
+    def pan_luhn_check(self, value: Optional[bool]) -> None:
+        self.__pan_luhn_check = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CardEssentials, self).to_dictionary()
+        if self.bin is not None:
+            dictionary['bin'] = self.bin
+        if self.card_corporate_indicator is not None:
+            dictionary['cardCorporateIndicator'] = self.card_corporate_indicator
+        if self.card_effective_date is not None:
+            dictionary['cardEffectiveDate'] = DataObject.format_date(self.card_effective_date)
+        if self.card_effective_date_indicator is not None:
+            dictionary['cardEffectiveDateIndicator'] = self.card_effective_date_indicator
+        if self.card_number is not None:
+            dictionary['cardNumber'] = self.card_number
+        if self.card_pan_type is not None:
+            dictionary['cardPanType'] = self.card_pan_type
+        if self.card_product_code is not None:
+            dictionary['cardProductCode'] = self.card_product_code
+        if self.card_product_usage_label is not None:
+            dictionary['cardProductUsageLabel'] = self.card_product_usage_label
+        if self.card_scheme is not None:
+            dictionary['cardScheme'] = self.card_scheme
+        if self.card_type is not None:
+            dictionary['cardType'] = self.card_type
+        if self.country_code is not None:
+            dictionary['countryCode'] = self.country_code
+        if self.expiry_date is not None:
+            dictionary['expiryDate'] = self.expiry_date
+        if self.issuer_code is not None:
+            dictionary['issuerCode'] = self.issuer_code
+        if self.issuer_name is not None:
+            dictionary['issuerName'] = self.issuer_name
+        if self.issuing_country_code is not None:
+            dictionary['issuingCountryCode'] = self.issuing_country_code
+        if self.pan_length_max is not None:
+            dictionary['panLengthMax'] = self.pan_length_max
+        if self.pan_length_min is not None:
+            dictionary['panLengthMin'] = self.pan_length_min
+        if self.pan_luhn_check is not None:
+            dictionary['panLuhnCheck'] = self.pan_luhn_check
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CardEssentials':
+        super(CardEssentials, self).from_dictionary(dictionary)
+        if 'bin' in dictionary:
+            self.bin = dictionary['bin']
+        if 'cardCorporateIndicator' in dictionary:
+            self.card_corporate_indicator = dictionary['cardCorporateIndicator']
+        if 'cardEffectiveDate' in dictionary:
+            self.card_effective_date = DataObject.parse_date(dictionary['cardEffectiveDate'])
+        if 'cardEffectiveDateIndicator' in dictionary:
+            self.card_effective_date_indicator = dictionary['cardEffectiveDateIndicator']
+        if 'cardNumber' in dictionary:
+            self.card_number = dictionary['cardNumber']
+        if 'cardPanType' in dictionary:
+            self.card_pan_type = dictionary['cardPanType']
+        if 'cardProductCode' in dictionary:
+            self.card_product_code = dictionary['cardProductCode']
+        if 'cardProductUsageLabel' in dictionary:
+            self.card_product_usage_label = dictionary['cardProductUsageLabel']
+        if 'cardScheme' in dictionary:
+            self.card_scheme = dictionary['cardScheme']
+        if 'cardType' in dictionary:
+            self.card_type = dictionary['cardType']
+        if 'countryCode' in dictionary:
+            self.country_code = dictionary['countryCode']
+        if 'expiryDate' in dictionary:
+            self.expiry_date = dictionary['expiryDate']
+        if 'issuerCode' in dictionary:
+            self.issuer_code = dictionary['issuerCode']
+        if 'issuerName' in dictionary:
+            self.issuer_name = dictionary['issuerName']
+        if 'issuingCountryCode' in dictionary:
+            self.issuing_country_code = dictionary['issuingCountryCode']
+        if 'panLengthMax' in dictionary:
+            self.pan_length_max = dictionary['panLengthMax']
+        if 'panLengthMin' in dictionary:
+            self.pan_length_min = dictionary['panLengthMin']
+        if 'panLuhnCheck' in dictionary:
+            self.pan_luhn_check = dictionary['panLuhnCheck']
+        return self

{onlinepayments_sdk_python3-5.1.0 → onlinepayments_sdk_python3-6.0.0}/onlinepayments/sdk/domain/card_payment_method_specific_input.py

@@ -9,6 +9,7 @@ from .card_recurrence_details import CardRecurrenceDetails
 from .currency_conversion_input import CurrencyConversionInput
 from .data_object import DataObject
 from .multiple_payment_information import MultiplePaymentInformation
+from .network_token_data import NetworkTokenData
 from .payment_product130_specific_input import PaymentProduct130SpecificInput
 from .payment_product3012_specific_input import PaymentProduct3012SpecificInput
 from .payment_product3208_specific_input import PaymentProduct3208SpecificInput
@@ -28,6 +29,7 @@ class CardPaymentMethodSpecificInput(DataObject):
     __initial_scheme_transaction_id: Optional[str] = None
     __is_recurring: Optional[bool] = None
     __multiple_payment_information: Optional[MultiplePaymentInformation] = None
+    __network_token_data: Optional[NetworkTokenData] = None
     __payment_product130_specific_input: Optional[PaymentProduct130SpecificInput] = None
     __payment_product3012_specific_input: Optional[PaymentProduct3012SpecificInput] = None
     __payment_product3208_specific_input: Optional[PaymentProduct3208SpecificInput] = None
@@ -190,6 +192,19 @@ class CardPaymentMethodSpecificInput(DataObject):
     def multiple_payment_information(self, value: Optional[MultiplePaymentInformation]) -> None:
         self.__multiple_payment_information = value
 
+    @property
+    def network_token_data(self) -> Optional[NetworkTokenData]:
+        """
+        | Object containing network token details
+
+        Type: :class:`onlinepayments.sdk.domain.network_token_data.NetworkTokenData`
+        """
+        return self.__network_token_data
+
+    @network_token_data.setter
+    def network_token_data(self, value: Optional[NetworkTokenData]) -> None:
+        self.__network_token_data = value
+
     @property
     def payment_product130_specific_input(self) -> Optional[PaymentProduct130SpecificInput]:
         """
@@ -428,6 +443,8 @@ class CardPaymentMethodSpecificInput(DataObject):
             dictionary['isRecurring'] = self.is_recurring
         if self.multiple_payment_information is not None:
             dictionary['multiplePaymentInformation'] = self.multiple_payment_information.to_dictionary()
+        if self.network_token_data is not None:
+            dictionary['networkTokenData'] = self.network_token_data.to_dictionary()
         if self.payment_product130_specific_input is not None:
             dictionary['paymentProduct130SpecificInput'] = self.payment_product130_specific_input.to_dictionary()
         if self.payment_product3012_specific_input is not None:
@@ -491,6 +508,11 @@ class CardPaymentMethodSpecificInput(DataObject):
                 raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['multiplePaymentInformation']))
             value = MultiplePaymentInformation()
             self.multiple_payment_information = value.from_dictionary(dictionary['multiplePaymentInformation'])
+        if 'networkTokenData' in dictionary:
+            if not isinstance(dictionary['networkTokenData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['networkTokenData']))
+            value = NetworkTokenData()
+            self.network_token_data = value.from_dictionary(dictionary['networkTokenData'])
         if 'paymentProduct130SpecificInput' in dictionary:
             if not isinstance(dictionary['paymentProduct130SpecificInput'], dict):
                 raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct130SpecificInput']))

{onlinepayments_sdk_python3-5.1.0 → onlinepayments_sdk_python3-6.0.0}/onlinepayments/sdk/domain/card_payment_method_specific_output.py

@@ -7,6 +7,7 @@ from typing import Optional
 from .acquirer_information import AcquirerInformation
 from .card_essentials import CardEssentials
 from .card_fraud_results import CardFraudResults
+from .click_to_pay import ClickToPay
 from .currency_conversion import CurrencyConversion
 from .data_object import DataObject
 from .external_token_linked import ExternalTokenLinked
@@ -22,6 +23,7 @@ class CardPaymentMethodSpecificOutput(DataObject):
     __authenticated_amount: Optional[int] = None
     __authorisation_code: Optional[str] = None
     __card: Optional[CardEssentials] = None
+    __click_to_pay: Optional[ClickToPay] = None
     __currency_conversion: Optional[CurrencyConversion] = None
     __external_token_linked: Optional[ExternalTokenLinked] = None
     __fraud_results: Optional[CardFraudResults] = None
@@ -88,6 +90,19 @@ class CardPaymentMethodSpecificOutput(DataObject):
     def card(self, value: Optional[CardEssentials]) -> None:
         self.__card = value
 
+    @property
+    def click_to_pay(self) -> Optional[ClickToPay]:
+        """
+        | Information about whether the payment is made using Click to Pay
+
+        Type: :class:`onlinepayments.sdk.domain.click_to_pay.ClickToPay`
+        """
+        return self.__click_to_pay
+
+    @click_to_pay.setter
+    def click_to_pay(self, value: Optional[ClickToPay]) -> None:
+        self.__click_to_pay = value
+
     @property
     def currency_conversion(self) -> Optional[CurrencyConversion]:
         """
@@ -263,6 +278,8 @@ class CardPaymentMethodSpecificOutput(DataObject):
             dictionary['authorisationCode'] = self.authorisation_code
         if self.card is not None:
             dictionary['card'] = self.card.to_dictionary()
+        if self.click_to_pay is not None:
+            dictionary['clickToPay'] = self.click_to_pay.to_dictionary()
         if self.currency_conversion is not None:
             dictionary['currencyConversion'] = self.currency_conversion.to_dictionary()
         if self.external_token_linked is not None:
@@ -307,6 +324,11 @@ class CardPaymentMethodSpecificOutput(DataObject):
                 raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['card']))
             value = CardEssentials()
             self.card = value.from_dictionary(dictionary['card'])
+        if 'clickToPay' in dictionary:
+            if not isinstance(dictionary['clickToPay'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['clickToPay']))
+            value = ClickToPay()
+            self.click_to_pay = value.from_dictionary(dictionary['clickToPay'])
         if 'currencyConversion' in dictionary:
             if not isinstance(dictionary['currencyConversion'], dict):
                 raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['currencyConversion']))

onlinepayments_sdk_python3-6.0.0/onlinepayments/sdk/domain/click_to_pay.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class ClickToPay(DataObject):
+
+    __is_click_to_pay_payment: Optional[bool] = None
+
+    @property
+    def is_click_to_pay_payment(self) -> Optional[bool]:
+        """
+        | A flag indicating whether the payment is made using Click to Pay
+
+        Type: bool
+        """
+        return self.__is_click_to_pay_payment
+
+    @is_click_to_pay_payment.setter
+    def is_click_to_pay_payment(self, value: Optional[bool]) -> None:
+        self.__is_click_to_pay_payment = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ClickToPay, self).to_dictionary()
+        if self.is_click_to_pay_payment is not None:
+            dictionary['IsClickToPayPayment'] = self.is_click_to_pay_payment
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ClickToPay':
+        super(ClickToPay, self).from_dictionary(dictionary)
+        if 'IsClickToPayPayment' in dictionary:
+            self.is_click_to_pay_payment = dictionary['IsClickToPayPayment']
+        return self