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

onlinepayments/sdk/domain/create_hosted_checkout_request.py

@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .card_payment_method_specific_input_base import CardPaymentMethodSpecificInputBase
+from .data_object import DataObject
+from .feedbacks import Feedbacks
+from .fraud_fields import FraudFields
+from .hosted_checkout_specific_input import HostedCheckoutSpecificInput
+from .mobile_payment_method_hosted_checkout_specific_input import MobilePaymentMethodHostedCheckoutSpecificInput
+from .order import Order
+from .redirect_payment_method_specific_input import RedirectPaymentMethodSpecificInput
+from .sepa_direct_debit_payment_method_specific_input_base import SepaDirectDebitPaymentMethodSpecificInputBase
+
+
+class CreateHostedCheckoutRequest(DataObject):
+
+    __card_payment_method_specific_input: Optional[CardPaymentMethodSpecificInputBase] = None
+    __feedbacks: Optional[Feedbacks] = None
+    __fraud_fields: Optional[FraudFields] = None
+    __hosted_checkout_specific_input: Optional[HostedCheckoutSpecificInput] = None
+    __mobile_payment_method_specific_input: Optional[MobilePaymentMethodHostedCheckoutSpecificInput] = None
+    __order: Optional[Order] = None
+    __redirect_payment_method_specific_input: Optional[RedirectPaymentMethodSpecificInput] = None
+    __sepa_direct_debit_payment_method_specific_input: Optional[SepaDirectDebitPaymentMethodSpecificInputBase] = None
+
+    @property
+    def card_payment_method_specific_input(self) -> Optional[CardPaymentMethodSpecificInputBase]:
+        """
+        | Object containing the specific input details for card payments
+
+        Type: :class:`onlinepayments.sdk.domain.card_payment_method_specific_input_base.CardPaymentMethodSpecificInputBase`
+        """
+        return self.__card_payment_method_specific_input
+
+    @card_payment_method_specific_input.setter
+    def card_payment_method_specific_input(self, value: Optional[CardPaymentMethodSpecificInputBase]) -> None:
+        self.__card_payment_method_specific_input = value
+
+    @property
+    def feedbacks(self) -> Optional[Feedbacks]:
+        """
+        | This section will contain feedback Urls to provide feedback on the payment.
+
+        Type: :class:`onlinepayments.sdk.domain.feedbacks.Feedbacks`
+        """
+        return self.__feedbacks
+
+    @feedbacks.setter
+    def feedbacks(self, value: Optional[Feedbacks]) -> None:
+        self.__feedbacks = value
+
+    @property
+    def fraud_fields(self) -> Optional[FraudFields]:
+        """
+        | Object containing additional data that will be used to assess the risk of fraud
+
+        Type: :class:`onlinepayments.sdk.domain.fraud_fields.FraudFields`
+        """
+        return self.__fraud_fields
+
+    @fraud_fields.setter
+    def fraud_fields(self, value: Optional[FraudFields]) -> None:
+        self.__fraud_fields = value
+
+    @property
+    def hosted_checkout_specific_input(self) -> Optional[HostedCheckoutSpecificInput]:
+        """
+        | Object containing hosted checkout specific data
+
+        Type: :class:`onlinepayments.sdk.domain.hosted_checkout_specific_input.HostedCheckoutSpecificInput`
+        """
+        return self.__hosted_checkout_specific_input
+
+    @hosted_checkout_specific_input.setter
+    def hosted_checkout_specific_input(self, value: Optional[HostedCheckoutSpecificInput]) -> None:
+        self.__hosted_checkout_specific_input = value
+
+    @property
+    def mobile_payment_method_specific_input(self) -> Optional[MobilePaymentMethodHostedCheckoutSpecificInput]:
+        """
+        | Object containing the specific input details for mobile payments
+
+        Type: :class:`onlinepayments.sdk.domain.mobile_payment_method_hosted_checkout_specific_input.MobilePaymentMethodHostedCheckoutSpecificInput`
+        """
+        return self.__mobile_payment_method_specific_input
+
+    @mobile_payment_method_specific_input.setter
+    def mobile_payment_method_specific_input(self, value: Optional[MobilePaymentMethodHostedCheckoutSpecificInput]) -> None:
+        self.__mobile_payment_method_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 redirect_payment_method_specific_input(self) -> Optional[RedirectPaymentMethodSpecificInput]:
+        """
+        | Object containing the specific input details for payments that involve redirects to 3rd parties to complete, like iDeal and PayPal
+
+        Type: :class:`onlinepayments.sdk.domain.redirect_payment_method_specific_input.RedirectPaymentMethodSpecificInput`
+        """
+        return self.__redirect_payment_method_specific_input
+
+    @redirect_payment_method_specific_input.setter
+    def redirect_payment_method_specific_input(self, value: Optional[RedirectPaymentMethodSpecificInput]) -> None:
+        self.__redirect_payment_method_specific_input = value
+
+    @property
+    def sepa_direct_debit_payment_method_specific_input(self) -> Optional[SepaDirectDebitPaymentMethodSpecificInputBase]:
+        """
+        | Object containing the specific input details for SEPA direct debit payments
+
+        Type: :class:`onlinepayments.sdk.domain.sepa_direct_debit_payment_method_specific_input_base.SepaDirectDebitPaymentMethodSpecificInputBase`
+        """
+        return self.__sepa_direct_debit_payment_method_specific_input
+
+    @sepa_direct_debit_payment_method_specific_input.setter
+    def sepa_direct_debit_payment_method_specific_input(self, value: Optional[SepaDirectDebitPaymentMethodSpecificInputBase]) -> None:
+        self.__sepa_direct_debit_payment_method_specific_input = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateHostedCheckoutRequest, self).to_dictionary()
+        if self.card_payment_method_specific_input is not None:
+            dictionary['cardPaymentMethodSpecificInput'] = self.card_payment_method_specific_input.to_dictionary()
+        if self.feedbacks is not None:
+            dictionary['feedbacks'] = self.feedbacks.to_dictionary()
+        if self.fraud_fields is not None:
+            dictionary['fraudFields'] = self.fraud_fields.to_dictionary()
+        if self.hosted_checkout_specific_input is not None:
+            dictionary['hostedCheckoutSpecificInput'] = self.hosted_checkout_specific_input.to_dictionary()
+        if self.mobile_payment_method_specific_input is not None:
+            dictionary['mobilePaymentMethodSpecificInput'] = self.mobile_payment_method_specific_input.to_dictionary()
+        if self.order is not None:
+            dictionary['order'] = self.order.to_dictionary()
+        if self.redirect_payment_method_specific_input is not None:
+            dictionary['redirectPaymentMethodSpecificInput'] = self.redirect_payment_method_specific_input.to_dictionary()
+        if self.sepa_direct_debit_payment_method_specific_input is not None:
+            dictionary['sepaDirectDebitPaymentMethodSpecificInput'] = self.sepa_direct_debit_payment_method_specific_input.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateHostedCheckoutRequest':
+        super(CreateHostedCheckoutRequest, self).from_dictionary(dictionary)
+        if 'cardPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['cardPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardPaymentMethodSpecificInput']))
+            value = CardPaymentMethodSpecificInputBase()
+            self.card_payment_method_specific_input = value.from_dictionary(dictionary['cardPaymentMethodSpecificInput'])
+        if 'feedbacks' in dictionary:
+            if not isinstance(dictionary['feedbacks'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['feedbacks']))
+            value = Feedbacks()
+            self.feedbacks = value.from_dictionary(dictionary['feedbacks'])
+        if 'fraudFields' in dictionary:
+            if not isinstance(dictionary['fraudFields'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['fraudFields']))
+            value = FraudFields()
+            self.fraud_fields = value.from_dictionary(dictionary['fraudFields'])
+        if 'hostedCheckoutSpecificInput' in dictionary:
+            if not isinstance(dictionary['hostedCheckoutSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['hostedCheckoutSpecificInput']))
+            value = HostedCheckoutSpecificInput()
+            self.hosted_checkout_specific_input = value.from_dictionary(dictionary['hostedCheckoutSpecificInput'])
+        if 'mobilePaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['mobilePaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mobilePaymentMethodSpecificInput']))
+            value = MobilePaymentMethodHostedCheckoutSpecificInput()
+            self.mobile_payment_method_specific_input = value.from_dictionary(dictionary['mobilePaymentMethodSpecificInput'])
+        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 'redirectPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['redirectPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['redirectPaymentMethodSpecificInput']))
+            value = RedirectPaymentMethodSpecificInput()
+            self.redirect_payment_method_specific_input = value.from_dictionary(dictionary['redirectPaymentMethodSpecificInput'])
+        if 'sepaDirectDebitPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['sepaDirectDebitPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['sepaDirectDebitPaymentMethodSpecificInput']))
+            value = SepaDirectDebitPaymentMethodSpecificInputBase()
+            self.sepa_direct_debit_payment_method_specific_input = value.from_dictionary(dictionary['sepaDirectDebitPaymentMethodSpecificInput'])
+        return self

onlinepayments/sdk/domain/create_hosted_checkout_response.py

@@ -0,0 +1,132 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+
+
+class CreateHostedCheckoutResponse(DataObject):
+
+    __returnmac: Optional[str] = None
+    __hosted_checkout_id: Optional[str] = None
+    __invalid_tokens: Optional[List[str]] = None
+    __merchant_reference: Optional[str] = None
+    __partial_redirect_url: Optional[str] = None
+    __redirect_url: Optional[str] = None
+
+    @property
+    def returnmac(self) -> Optional[str]:
+        """
+        | When the customer is returned to your site we will append this property and value to the query-string. You should store this data, so you can identify the returning customer.
+
+        Type: str
+        """
+        return self.__returnmac
+
+    @returnmac.setter
+    def returnmac(self, value: Optional[str]) -> None:
+        self.__returnmac = value
+
+    @property
+    def hosted_checkout_id(self) -> Optional[str]:
+        """
+        | The ID of the Hosted Checkout Session in which the payment was made.
+
+        Type: str
+        """
+        return self.__hosted_checkout_id
+
+    @hosted_checkout_id.setter
+    def hosted_checkout_id(self, value: Optional[str]) -> None:
+        self.__hosted_checkout_id = value
+
+    @property
+    def invalid_tokens(self) -> Optional[List[str]]:
+        """
+        Type: list[str]
+        """
+        return self.__invalid_tokens
+
+    @invalid_tokens.setter
+    def invalid_tokens(self, value: Optional[List[str]]) -> None:
+        self.__invalid_tokens = value
+
+    @property
+    def merchant_reference(self) -> Optional[str]:
+        """
+        | Your unique reference of the transaction that is also returned in our report files. This is almost always used for your reconciliation of our report files. It is highly recommended to provide a single MerchantReference per unique order on your side
+
+        Type: str
+        """
+        return self.__merchant_reference
+
+    @merchant_reference.setter
+    def merchant_reference(self, value: Optional[str]) -> None:
+        self.__merchant_reference = value
+
+    @property
+    def partial_redirect_url(self) -> Optional[str]:
+        """
+        | The partial URL as generated by our system. You will need to add the protocol and the relevant subdomain to this URL, before redirecting your customer to this URL. A special 'payment' subdomain will always work so you can always add 'https://payment.' at the beginning of this response value to view your hosted pages.
+
+        Type: str
+        """
+        return self.__partial_redirect_url
+
+    @partial_redirect_url.setter
+    def partial_redirect_url(self, value: Optional[str]) -> None:
+        self.__partial_redirect_url = value
+
+    @property
+    def redirect_url(self) -> Optional[str]:
+        """
+        | The full hosted checkout URL as generated by our system. Use this URL to redirect your customer to the hosted checkout page.
+
+        Type: str
+        """
+        return self.__redirect_url
+
+    @redirect_url.setter
+    def redirect_url(self, value: Optional[str]) -> None:
+        self.__redirect_url = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateHostedCheckoutResponse, self).to_dictionary()
+        if self.returnmac is not None:
+            dictionary['RETURNMAC'] = self.returnmac
+        if self.hosted_checkout_id is not None:
+            dictionary['hostedCheckoutId'] = self.hosted_checkout_id
+        if self.invalid_tokens is not None:
+            dictionary['invalidTokens'] = []
+            for element in self.invalid_tokens:
+                if element is not None:
+                    dictionary['invalidTokens'].append(element)
+        if self.merchant_reference is not None:
+            dictionary['merchantReference'] = self.merchant_reference
+        if self.partial_redirect_url is not None:
+            dictionary['partialRedirectUrl'] = self.partial_redirect_url
+        if self.redirect_url is not None:
+            dictionary['redirectUrl'] = self.redirect_url
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateHostedCheckoutResponse':
+        super(CreateHostedCheckoutResponse, self).from_dictionary(dictionary)
+        if 'RETURNMAC' in dictionary:
+            self.returnmac = dictionary['RETURNMAC']
+        if 'hostedCheckoutId' in dictionary:
+            self.hosted_checkout_id = dictionary['hostedCheckoutId']
+        if 'invalidTokens' in dictionary:
+            if not isinstance(dictionary['invalidTokens'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['invalidTokens']))
+            self.invalid_tokens = []
+            for element in dictionary['invalidTokens']:
+                self.invalid_tokens.append(element)
+        if 'merchantReference' in dictionary:
+            self.merchant_reference = dictionary['merchantReference']
+        if 'partialRedirectUrl' in dictionary:
+            self.partial_redirect_url = dictionary['partialRedirectUrl']
+        if 'redirectUrl' in dictionary:
+            self.redirect_url = dictionary['redirectUrl']
+        return self

onlinepayments/sdk/domain/create_hosted_fields_session_request.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CreateHostedFieldsSessionRequest(DataObject):
+
+    __locale: Optional[str] = None
+
+    @property
+    def locale(self) -> Optional[str]:
+        """
+        | Locale used in the GUI towards the consumer.
+
+        Type: str
+        """
+        return self.__locale
+
+    @locale.setter
+    def locale(self, value: Optional[str]) -> None:
+        self.__locale = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateHostedFieldsSessionRequest, self).to_dictionary()
+        if self.locale is not None:
+            dictionary['locale'] = self.locale
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateHostedFieldsSessionRequest':
+        super(CreateHostedFieldsSessionRequest, self).from_dictionary(dictionary)
+        if 'locale' in dictionary:
+            self.locale = dictionary['locale']
+        return self

onlinepayments/sdk/domain/create_hosted_fields_session_response.py

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+from .session_data import SessionData
+
+
+class CreateHostedFieldsSessionResponse(DataObject):
+
+    __invalid_tokens: Optional[List[str]] = None
+    __sdk_sri: Optional[str] = None
+    __sdk_url: Optional[str] = None
+    __session_data: Optional[SessionData] = None
+
+    @property
+    def invalid_tokens(self) -> Optional[List[str]]:
+        """
+        | This is a list of tokens that failed validation.
+
+        Type: list[str]
+        """
+        return self.__invalid_tokens
+
+    @invalid_tokens.setter
+    def invalid_tokens(self, value: Optional[List[str]]) -> None:
+        self.__invalid_tokens = value
+
+    @property
+    def sdk_sri(self) -> Optional[str]:
+        """
+        | This is the cryptographic hash used for Subresource Integrity validation.
+
+        Type: str
+        """
+        return self.__sdk_sri
+
+    @sdk_sri.setter
+    def sdk_sri(self, value: Optional[str]) -> None:
+        self.__sdk_sri = value
+
+    @property
+    def sdk_url(self) -> Optional[str]:
+        """
+        | The URL points to the hosted fields SDK.
+
+        Type: str
+        """
+        return self.__sdk_url
+
+    @sdk_url.setter
+    def sdk_url(self, value: Optional[str]) -> None:
+        self.__sdk_url = value
+
+    @property
+    def session_data(self) -> Optional[SessionData]:
+        """
+        | This contains the data required to initialize the Hosted Fields SDK.
+
+        Type: :class:`onlinepayments.sdk.domain.session_data.SessionData`
+        """
+        return self.__session_data
+
+    @session_data.setter
+    def session_data(self, value: Optional[SessionData]) -> None:
+        self.__session_data = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateHostedFieldsSessionResponse, self).to_dictionary()
+        if self.invalid_tokens is not None:
+            dictionary['invalidTokens'] = []
+            for element in self.invalid_tokens:
+                if element is not None:
+                    dictionary['invalidTokens'].append(element)
+        if self.sdk_sri is not None:
+            dictionary['sdkSri'] = self.sdk_sri
+        if self.sdk_url is not None:
+            dictionary['sdkUrl'] = self.sdk_url
+        if self.session_data is not None:
+            dictionary['sessionData'] = self.session_data.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateHostedFieldsSessionResponse':
+        super(CreateHostedFieldsSessionResponse, self).from_dictionary(dictionary)
+        if 'invalidTokens' in dictionary:
+            if not isinstance(dictionary['invalidTokens'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['invalidTokens']))
+            self.invalid_tokens = []
+            for element in dictionary['invalidTokens']:
+                self.invalid_tokens.append(element)
+        if 'sdkSri' in dictionary:
+            self.sdk_sri = dictionary['sdkSri']
+        if 'sdkUrl' in dictionary:
+            self.sdk_url = dictionary['sdkUrl']
+        if 'sessionData' in dictionary:
+            if not isinstance(dictionary['sessionData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['sessionData']))
+            value = SessionData()
+            self.session_data = value.from_dictionary(dictionary['sessionData'])
+        return self

onlinepayments/sdk/domain/create_hosted_tokenization_request.py

@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .credit_card_specific_input_hosted_tokenization import CreditCardSpecificInputHostedTokenization
+from .data_object import DataObject
+from .payment_product_filters_hosted_tokenization import PaymentProductFiltersHostedTokenization
+
+
+class CreateHostedTokenizationRequest(DataObject):
+
+    __ask_consumer_consent: Optional[bool] = None
+    __credit_card_specific_input: Optional[CreditCardSpecificInputHostedTokenization] = None
+    __locale: Optional[str] = None
+    __payment_product_filters: Optional[PaymentProductFiltersHostedTokenization] = None
+    __tokens: Optional[str] = None
+    __variant: Optional[str] = None
+
+    @property
+    def ask_consumer_consent(self) -> Optional[bool]:
+        """
+        | Indicate if the tokenization form should contain a checkbox asking the user to give consent for storing their information for future payments. If this parameter is false or missing, you should ask the user yourself and provide their answer when submitting the Tokenizer in your JavaScript code. To pass this choice set the submitTokenization function's parameter storePermanently to false, if you choose not to store the token for subsequent payments, or to true otherwise.
+
+        Type: bool
+        """
+        return self.__ask_consumer_consent
+
+    @ask_consumer_consent.setter
+    def ask_consumer_consent(self, value: Optional[bool]) -> None:
+        self.__ask_consumer_consent = value
+
+    @property
+    def credit_card_specific_input(self) -> Optional[CreditCardSpecificInputHostedTokenization]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.credit_card_specific_input_hosted_tokenization.CreditCardSpecificInputHostedTokenization`
+        """
+        return self.__credit_card_specific_input
+
+    @credit_card_specific_input.setter
+    def credit_card_specific_input(self, value: Optional[CreditCardSpecificInputHostedTokenization]) -> None:
+        self.__credit_card_specific_input = value
+
+    @property
+    def locale(self) -> Optional[str]:
+        """
+        | Locale used in the GUI towards the consumer.
+
+        Type: str
+        """
+        return self.__locale
+
+    @locale.setter
+    def locale(self, value: Optional[str]) -> None:
+        self.__locale = value
+
+    @property
+    def payment_product_filters(self) -> Optional[PaymentProductFiltersHostedTokenization]:
+        """
+        | Contains the payment product ids that will be used for manipulating the payment products available for the payment to the customer.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product_filters_hosted_tokenization.PaymentProductFiltersHostedTokenization`
+        """
+        return self.__payment_product_filters
+
+    @payment_product_filters.setter
+    def payment_product_filters(self, value: Optional[PaymentProductFiltersHostedTokenization]) -> None:
+        self.__payment_product_filters = value
+
+    @property
+    def tokens(self) -> Optional[str]:
+        """
+        | String containing comma separated tokens (no spaces) associated with the customer of this hosted session. Valid tokens will be used to present the customer the option to re-use previously used payment details. This means the customer for instance does not have to re-enter their card details again, which a big plus when the customer is using their mobile phone to complete the operation.
+
+        Type: str
+        """
+        return self.__tokens
+
+    @tokens.setter
+    def tokens(self, value: Optional[str]) -> None:
+        self.__tokens = value
+
+    @property
+    def variant(self) -> Optional[str]:
+        """
+        | You can force the use of a custom template by specifying it in the variant field. This allows you to test out the effect of certain changes to your payment pages in a controlled manner. Please note that you need to specify the filename of the template or customization.
+
+        Type: str
+        """
+        return self.__variant
+
+    @variant.setter
+    def variant(self, value: Optional[str]) -> None:
+        self.__variant = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateHostedTokenizationRequest, self).to_dictionary()
+        if self.ask_consumer_consent is not None:
+            dictionary['askConsumerConsent'] = self.ask_consumer_consent
+        if self.credit_card_specific_input is not None:
+            dictionary['creditCardSpecificInput'] = self.credit_card_specific_input.to_dictionary()
+        if self.locale is not None:
+            dictionary['locale'] = self.locale
+        if self.payment_product_filters is not None:
+            dictionary['paymentProductFilters'] = self.payment_product_filters.to_dictionary()
+        if self.tokens is not None:
+            dictionary['tokens'] = self.tokens
+        if self.variant is not None:
+            dictionary['variant'] = self.variant
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateHostedTokenizationRequest':
+        super(CreateHostedTokenizationRequest, self).from_dictionary(dictionary)
+        if 'askConsumerConsent' in dictionary:
+            self.ask_consumer_consent = dictionary['askConsumerConsent']
+        if 'creditCardSpecificInput' in dictionary:
+            if not isinstance(dictionary['creditCardSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['creditCardSpecificInput']))
+            value = CreditCardSpecificInputHostedTokenization()
+            self.credit_card_specific_input = value.from_dictionary(dictionary['creditCardSpecificInput'])
+        if 'locale' in dictionary:
+            self.locale = dictionary['locale']
+        if 'paymentProductFilters' in dictionary:
+            if not isinstance(dictionary['paymentProductFilters'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProductFilters']))
+            value = PaymentProductFiltersHostedTokenization()
+            self.payment_product_filters = value.from_dictionary(dictionary['paymentProductFilters'])
+        if 'tokens' in dictionary:
+            self.tokens = dictionary['tokens']
+        if 'variant' in dictionary:
+            self.variant = dictionary['variant']
+        return self