onlinepayments-sdk-python3 5.1.0__zip → 6.1.0__zip

onlinepayments_sdk_python3-6.1.0/onlinepayments/sdk/domain/iin_detail.py

@@ -0,0 +1,423 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from datetime import date
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class IINDetail(DataObject):
+
+    __card_corporate_indicator: Optional[bool] = None
+    __card_effective_date: Optional[date] = None
+    __card_effective_date_indicator: Optional[bool] = None
+    __card_pan_type: Optional[str] = None
+    __card_product_code: Optional[str] = None
+    __card_product_name: 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
+    __is_allowed_in_context: Optional[bool] = None
+    __issuer_code: Optional[str] = None
+    __issuer_name: Optional[str] = None
+    __issuer_region_code: 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
+    __payment_product_id: Optional[int] = None
+    __virtual_card_indicator: Optional[bool] = None
+
+    @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_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_name(self) -> Optional[str]:
+        """
+        | Product name of the card
+
+        Type: str
+        """
+        return self.__card_product_name
+
+    @card_product_name.setter
+    def card_product_name(self, value: Optional[str]) -> None:
+        self.__card_product_name = 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 is_allowed_in_context(self) -> Optional[bool]:
+        """
+        | Populated only if you submitted a payment context.
+        
+        * true - The payment product is allowed in the submitted context.
+        * false - The payment product is not allowed in the submitted context. Note that in this case, none of the brands of the card will be allowed in the submitted context.
+
+        Type: bool
+        """
+        return self.__is_allowed_in_context
+
+    @is_allowed_in_context.setter
+    def is_allowed_in_context(self, value: Optional[bool]) -> None:
+        self.__is_allowed_in_context = 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 issuer_region_code(self) -> Optional[str]:
+        """
+        | Region code of the card issuer
+        
+        * ``1`` USA: California, Hawaii, Nevada
+        * ``2`` USA: West except California, Hawaii, Nevada
+        * ``3`` USA: Central North
+        * ``4`` USA: Central South
+        * ``5`` USA: Great Lakes states
+        * ``6`` USA: South East
+        * ``7`` USA: Extreme North East
+        * ``8`` USA: North East
+        * ``9`` USA: Florida and Georgia
+        * ``a`` Canada
+        * ``b`` South America
+        * ``c`` Oceania and Asia
+        * ``d`` Europe
+        * ``e`` Africa and Middle East
+
+        Type: str
+        """
+        return self.__issuer_region_code
+
+    @issuer_region_code.setter
+    def issuer_region_code(self, value: Optional[str]) -> None:
+        self.__issuer_region_code = 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
+
+    @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 virtual_card_indicator(self) -> Optional[bool]:
+        """
+        | Indicates whether the card is a virtual card
+
+        Type: bool
+        """
+        return self.__virtual_card_indicator
+
+    @virtual_card_indicator.setter
+    def virtual_card_indicator(self, value: Optional[bool]) -> None:
+        self.__virtual_card_indicator = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(IINDetail, self).to_dictionary()
+        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_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_name is not None:
+            dictionary['cardProductName'] = self.card_product_name
+        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.is_allowed_in_context is not None:
+            dictionary['isAllowedInContext'] = self.is_allowed_in_context
+        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.issuer_region_code is not None:
+            dictionary['issuerRegionCode'] = self.issuer_region_code
+        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
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        if self.virtual_card_indicator is not None:
+            dictionary['virtualCardIndicator'] = self.virtual_card_indicator
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'IINDetail':
+        super(IINDetail, self).from_dictionary(dictionary)
+        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 'cardPanType' in dictionary:
+            self.card_pan_type = dictionary['cardPanType']
+        if 'cardProductCode' in dictionary:
+            self.card_product_code = dictionary['cardProductCode']
+        if 'cardProductName' in dictionary:
+            self.card_product_name = dictionary['cardProductName']
+        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 'isAllowedInContext' in dictionary:
+            self.is_allowed_in_context = dictionary['isAllowedInContext']
+        if 'issuerCode' in dictionary:
+            self.issuer_code = dictionary['issuerCode']
+        if 'issuerName' in dictionary:
+            self.issuer_name = dictionary['issuerName']
+        if 'issuerRegionCode' in dictionary:
+            self.issuer_region_code = dictionary['issuerRegionCode']
+        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']
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        if 'virtualCardIndicator' in dictionary:
+            self.virtual_card_indicator = dictionary['virtualCardIndicator']
+        return self

{onlinepayments_sdk_python3-5.1.0 → onlinepayments_sdk_python3-6.1.0}/onlinepayments/sdk/domain/mobile_payment_method_specific_input.py

@@ -6,6 +6,7 @@ from typing import Optional
 
 from .data_object import DataObject
 from .decrypted_payment_data import DecryptedPaymentData
+from .mobile_payment_product302_specific_input import MobilePaymentProduct302SpecificInput
 from .mobile_payment_product320_specific_input import MobilePaymentProduct320SpecificInput
 
 
@@ -15,6 +16,7 @@ class MobilePaymentMethodSpecificInput(DataObject):
     __decrypted_payment_data: Optional[DecryptedPaymentData] = None
     __encrypted_payment_data: Optional[str] = None
     __ephemeral_key: Optional[str] = None
+    __payment_product302_specific_input: Optional[MobilePaymentProduct302SpecificInput] = None
     __payment_product320_specific_input: Optional[MobilePaymentProduct320SpecificInput] = None
     __payment_product_id: Optional[int] = None
     __public_key_hash: Optional[str] = None
@@ -80,6 +82,19 @@ class MobilePaymentMethodSpecificInput(DataObject):
     def ephemeral_key(self, value: Optional[str]) -> None:
         self.__ephemeral_key = value
 
+    @property
+    def payment_product302_specific_input(self) -> Optional[MobilePaymentProduct302SpecificInput]:
+        """
+        | Object containing information specific to Apple Pay.
+
+        Type: :class:`onlinepayments.sdk.domain.mobile_payment_product302_specific_input.MobilePaymentProduct302SpecificInput`
+        """
+        return self.__payment_product302_specific_input
+
+    @payment_product302_specific_input.setter
+    def payment_product302_specific_input(self, value: Optional[MobilePaymentProduct302SpecificInput]) -> None:
+        self.__payment_product302_specific_input = value
+
     @property
     def payment_product320_specific_input(self) -> Optional[MobilePaymentProduct320SpecificInput]:
         """
@@ -143,6 +158,8 @@ class MobilePaymentMethodSpecificInput(DataObject):
             dictionary['encryptedPaymentData'] = self.encrypted_payment_data
         if self.ephemeral_key is not None:
             dictionary['ephemeralKey'] = self.ephemeral_key
+        if self.payment_product302_specific_input is not None:
+            dictionary['paymentProduct302SpecificInput'] = self.payment_product302_specific_input.to_dictionary()
         if self.payment_product320_specific_input is not None:
             dictionary['paymentProduct320SpecificInput'] = self.payment_product320_specific_input.to_dictionary()
         if self.payment_product_id is not None:
@@ -166,6 +183,11 @@ class MobilePaymentMethodSpecificInput(DataObject):
             self.encrypted_payment_data = dictionary['encryptedPaymentData']
         if 'ephemeralKey' in dictionary:
             self.ephemeral_key = dictionary['ephemeralKey']
+        if 'paymentProduct302SpecificInput' in dictionary:
+            if not isinstance(dictionary['paymentProduct302SpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct302SpecificInput']))
+            value = MobilePaymentProduct302SpecificInput()
+            self.payment_product302_specific_input = value.from_dictionary(dictionary['paymentProduct302SpecificInput'])
         if 'paymentProduct320SpecificInput' in dictionary:
             if not isinstance(dictionary['paymentProduct320SpecificInput'], dict):
                 raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct320SpecificInput']))

onlinepayments_sdk_python3-6.1.0/onlinepayments/sdk/domain/mobile_payment_product302_specific_input.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .apple_pay_recurring_payment_request import ApplePayRecurringPaymentRequest
+from .data_object import DataObject
+from .product302_recurring import Product302Recurring
+
+
+class MobilePaymentProduct302SpecificInput(DataObject):
+
+    __apple_pay_recurring_payment_request: Optional[ApplePayRecurringPaymentRequest] = None
+    __is_recurring: Optional[bool] = None
+    __recurring: Optional[Product302Recurring] = None
+    __tokenize: Optional[bool] = None
+
+    @property
+    def apple_pay_recurring_payment_request(self) -> Optional[ApplePayRecurringPaymentRequest]:
+        """
+        | Object containing information specific to Apple Pay recurring request.
+
+        Type: :class:`onlinepayments.sdk.domain.apple_pay_recurring_payment_request.ApplePayRecurringPaymentRequest`
+        """
+        return self.__apple_pay_recurring_payment_request
+
+    @apple_pay_recurring_payment_request.setter
+    def apple_pay_recurring_payment_request(self, value: Optional[ApplePayRecurringPaymentRequest]) -> None:
+        self.__apple_pay_recurring_payment_request = value
+
+    @property
+    def is_recurring(self) -> Optional[bool]:
+        """
+        * true - Indicates that the transaction is part of a scheduled recurring sequence. In addition, recurringPaymentSequenceIndicator indicates if the transaction is the first or subsequent in a recurring sequence.
+        * false - Indicates that the transaction is not part of a scheduled recurring sequence. The default value for this property is false. For HostedCheckout use the hostedCheckoutSpecificInput.isRecurring property instead.
+
+        Type: bool
+        """
+        return self.__is_recurring
+
+    @is_recurring.setter
+    def is_recurring(self, value: Optional[bool]) -> None:
+        self.__is_recurring = value
+
+    @property
+    def recurring(self) -> Optional[Product302Recurring]:
+        """
+        | Object containing information specific to Apple Pay and recurring.
+
+        Type: :class:`onlinepayments.sdk.domain.product302_recurring.Product302Recurring`
+        """
+        return self.__recurring
+
+    @recurring.setter
+    def recurring(self, value: Optional[Product302Recurring]) -> None:
+        self.__recurring = value
+
+    @property
+    def tokenize(self) -> Optional[bool]:
+        """
+        | Indicates if this transaction should be tokenized
+        
+        * true - Tokenize the transaction. Note that a payment on the payment platform that results in a status REDIRECTED cannot be tokenized in this way.
+        * false - Do not tokenize the transaction, unless it would be tokenized by other means such as auto-tokenization of recurring payments.
+
+        Type: bool
+        """
+        return self.__tokenize
+
+    @tokenize.setter
+    def tokenize(self, value: Optional[bool]) -> None:
+        self.__tokenize = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MobilePaymentProduct302SpecificInput, self).to_dictionary()
+        if self.apple_pay_recurring_payment_request is not None:
+            dictionary['applePayRecurringPaymentRequest'] = self.apple_pay_recurring_payment_request.to_dictionary()
+        if self.is_recurring is not None:
+            dictionary['isRecurring'] = self.is_recurring
+        if self.recurring is not None:
+            dictionary['recurring'] = self.recurring.to_dictionary()
+        if self.tokenize is not None:
+            dictionary['tokenize'] = self.tokenize
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MobilePaymentProduct302SpecificInput':
+        super(MobilePaymentProduct302SpecificInput, self).from_dictionary(dictionary)
+        if 'applePayRecurringPaymentRequest' in dictionary:
+            if not isinstance(dictionary['applePayRecurringPaymentRequest'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['applePayRecurringPaymentRequest']))
+            value = ApplePayRecurringPaymentRequest()
+            self.apple_pay_recurring_payment_request = value.from_dictionary(dictionary['applePayRecurringPaymentRequest'])
+        if 'isRecurring' in dictionary:
+            self.is_recurring = dictionary['isRecurring']
+        if 'recurring' in dictionary:
+            if not isinstance(dictionary['recurring'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['recurring']))
+            value = Product302Recurring()
+            self.recurring = value.from_dictionary(dictionary['recurring'])
+        if 'tokenize' in dictionary:
+            self.tokenize = dictionary['tokenize']
+        return self

onlinepayments_sdk_python3-6.1.0/onlinepayments/sdk/domain/mobile_payment_product320_specific_input.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .g_pay_three_d_secure import GPayThreeDSecure
+from .product320_recurring import Product320Recurring
+
+
+class MobilePaymentProduct320SpecificInput(DataObject):
+
+    __is_recurring: Optional[bool] = None
+    __recurring: Optional[Product320Recurring] = None
+    __three_d_secure: Optional[GPayThreeDSecure] = None
+    __tokenize: Optional[bool] = None
+
+    @property
+    def is_recurring(self) -> Optional[bool]:
+        """
+        * true - Indicates that the transaction is part of a scheduled recurring sequence. In addition, recurringPaymentSequenceIndicator indicates if the transaction is the first or subsequent in a recurring sequence.
+        * false - Indicates that the transaction is not part of a scheduled recurring sequence. The default value for this property is false. For HostedCheckout use the hostedCheckoutSpecificInput.isRecurring property instead.
+
+        Type: bool
+        """
+        return self.__is_recurring
+
+    @is_recurring.setter
+    def is_recurring(self, value: Optional[bool]) -> None:
+        self.__is_recurring = value
+
+    @property
+    def recurring(self) -> Optional[Product320Recurring]:
+        """
+        | Object containing information specific to Google Pay and recurring.
+
+        Type: :class:`onlinepayments.sdk.domain.product320_recurring.Product320Recurring`
+        """
+        return self.__recurring
+
+    @recurring.setter
+    def recurring(self, value: Optional[Product320Recurring]) -> None:
+        self.__recurring = value
+
+    @property
+    def three_d_secure(self) -> Optional[GPayThreeDSecure]:
+        """
+        | Object containing specific data regarding 3-D Secure
+
+        Type: :class:`onlinepayments.sdk.domain.g_pay_three_d_secure.GPayThreeDSecure`
+        """
+        return self.__three_d_secure
+
+    @three_d_secure.setter
+    def three_d_secure(self, value: Optional[GPayThreeDSecure]) -> None:
+        self.__three_d_secure = value
+
+    @property
+    def tokenize(self) -> Optional[bool]:
+        """
+        | Indicates if this transaction should be tokenized
+        
+        * true - Tokenize the transaction. Note that a payment on the payment platform that results in a status REDIRECTED cannot be tokenized in this way.
+        * false - Do not tokenize the transaction, unless it would be tokenized by other means such as auto-tokenization of recurring payments.
+
+        Type: bool
+        """
+        return self.__tokenize
+
+    @tokenize.setter
+    def tokenize(self, value: Optional[bool]) -> None:
+        self.__tokenize = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MobilePaymentProduct320SpecificInput, self).to_dictionary()
+        if self.is_recurring is not None:
+            dictionary['isRecurring'] = self.is_recurring
+        if self.recurring is not None:
+            dictionary['recurring'] = self.recurring.to_dictionary()
+        if self.three_d_secure is not None:
+            dictionary['threeDSecure'] = self.three_d_secure.to_dictionary()
+        if self.tokenize is not None:
+            dictionary['tokenize'] = self.tokenize
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MobilePaymentProduct320SpecificInput':
+        super(MobilePaymentProduct320SpecificInput, self).from_dictionary(dictionary)
+        if 'isRecurring' in dictionary:
+            self.is_recurring = dictionary['isRecurring']
+        if 'recurring' in dictionary:
+            if not isinstance(dictionary['recurring'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['recurring']))
+            value = Product320Recurring()
+            self.recurring = value.from_dictionary(dictionary['recurring'])
+        if 'threeDSecure' in dictionary:
+            if not isinstance(dictionary['threeDSecure'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['threeDSecure']))
+            value = GPayThreeDSecure()
+            self.three_d_secure = value.from_dictionary(dictionary['threeDSecure'])
+        if 'tokenize' in dictionary:
+            self.tokenize = dictionary['tokenize']
+        return self