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

onlinepayments/sdk/domain/mobile_payment_method_specific_input.py

@@ -0,0 +1,202 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+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
+
+
+class MobilePaymentMethodSpecificInput(DataObject):
+
+    __authorization_mode: Optional[str] = None
+    __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
+    __requires_approval: Optional[bool] = 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 decrypted_payment_data(self) -> Optional[DecryptedPaymentData]:
+        """
+        | The payment data if you do the decryption of the encrypted payment data yourself.
+
+        Type: :class:`onlinepayments.sdk.domain.decrypted_payment_data.DecryptedPaymentData`
+        """
+        return self.__decrypted_payment_data
+
+    @decrypted_payment_data.setter
+    def decrypted_payment_data(self, value: Optional[DecryptedPaymentData]) -> None:
+        self.__decrypted_payment_data = value
+
+    @property
+    def encrypted_payment_data(self) -> Optional[str]:
+        """
+        | The payment data if we will do the decryption of the encrypted payment data. Typically you'd use encryptedCustomerInput in the root of the create payment request to provide the encrypted payment data instead.
+        
+        * For Apple Pay, the encrypted payment data can be found in property data of the PKPayment.token.paymentData property.
+
+        Type: str
+        """
+        return self.__encrypted_payment_data
+
+    @encrypted_payment_data.setter
+    def encrypted_payment_data(self, value: Optional[str]) -> None:
+        self.__encrypted_payment_data = value
+
+    @property
+    def ephemeral_key(self) -> Optional[str]:
+        """
+        | Ephemeral Key A unique generated key used by Apple to encrypt data.
+
+        Type: str
+        """
+        return self.__ephemeral_key
+
+    @ephemeral_key.setter
+    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]:
+        """
+        | Object containing information specific to Google Pay. Required for payments with product 320.
+
+        Type: :class:`onlinepayments.sdk.domain.mobile_payment_product320_specific_input.MobilePaymentProduct320SpecificInput`
+        """
+        return self.__payment_product320_specific_input
+
+    @payment_product320_specific_input.setter
+    def payment_product320_specific_input(self, value: Optional[MobilePaymentProduct320SpecificInput]) -> None:
+        self.__payment_product320_specific_input = 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 public_key_hash(self) -> Optional[str]:
+        """
+        | Public Key Hash A unique identifier to retrieve key used by Apple to encrypt information.
+
+        Type: str
+        """
+        return self.__public_key_hash
+
+    @public_key_hash.setter
+    def public_key_hash(self, value: Optional[str]) -> None:
+        self.__public_key_hash = value
+
+    @property
+    def requires_approval(self) -> Optional[bool]:
+        """
+        * true = the payment requires approval before the funds will be captured using the Approve payment or Capture payment API
+        * false = the payment does not require approval, and the funds will be captured automatically
+
+        Type: bool
+        """
+        return self.__requires_approval
+
+    @requires_approval.setter
+    def requires_approval(self, value: Optional[bool]) -> None:
+        self.__requires_approval = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MobilePaymentMethodSpecificInput, self).to_dictionary()
+        if self.authorization_mode is not None:
+            dictionary['authorizationMode'] = self.authorization_mode
+        if self.decrypted_payment_data is not None:
+            dictionary['decryptedPaymentData'] = self.decrypted_payment_data.to_dictionary()
+        if self.encrypted_payment_data is not None:
+            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:
+            dictionary['paymentProductId'] = self.payment_product_id
+        if self.public_key_hash is not None:
+            dictionary['publicKeyHash'] = self.public_key_hash
+        if self.requires_approval is not None:
+            dictionary['requiresApproval'] = self.requires_approval
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MobilePaymentMethodSpecificInput':
+        super(MobilePaymentMethodSpecificInput, self).from_dictionary(dictionary)
+        if 'authorizationMode' in dictionary:
+            self.authorization_mode = dictionary['authorizationMode']
+        if 'decryptedPaymentData' in dictionary:
+            if not isinstance(dictionary['decryptedPaymentData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['decryptedPaymentData']))
+            value = DecryptedPaymentData()
+            self.decrypted_payment_data = value.from_dictionary(dictionary['decryptedPaymentData'])
+        if 'encryptedPaymentData' in dictionary:
+            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']))
+            value = MobilePaymentProduct320SpecificInput()
+            self.payment_product320_specific_input = value.from_dictionary(dictionary['paymentProduct320SpecificInput'])
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        if 'publicKeyHash' in dictionary:
+            self.public_key_hash = dictionary['publicKeyHash']
+        if 'requiresApproval' in dictionary:
+            self.requires_approval = dictionary['requiresApproval']
+        return self

onlinepayments/sdk/domain/mobile_payment_method_specific_output.py

@@ -0,0 +1,139 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .card_fraud_results import CardFraudResults
+from .data_object import DataObject
+from .mobile_payment_data import MobilePaymentData
+from .three_d_secure_results import ThreeDSecureResults
+
+
+class MobilePaymentMethodSpecificOutput(DataObject):
+
+    __authorisation_code: Optional[str] = None
+    __fraud_results: Optional[CardFraudResults] = None
+    __network: Optional[str] = None
+    __payment_data: Optional[MobilePaymentData] = None
+    __payment_product_id: Optional[int] = None
+    __three_d_secure_results: Optional[ThreeDSecureResults] = None
+
+    @property
+    def authorisation_code(self) -> Optional[str]:
+        """
+        | Card Authorization code as returned by the acquirer
+
+        Type: str
+        """
+        return self.__authorisation_code
+
+    @authorisation_code.setter
+    def authorisation_code(self, value: Optional[str]) -> None:
+        self.__authorisation_code = value
+
+    @property
+    def fraud_results(self) -> Optional[CardFraudResults]:
+        """
+        | Fraud results contained in the CardFraudResults object
+
+        Type: :class:`onlinepayments.sdk.domain.card_fraud_results.CardFraudResults`
+        """
+        return self.__fraud_results
+
+    @fraud_results.setter
+    def fraud_results(self, value: Optional[CardFraudResults]) -> None:
+        self.__fraud_results = value
+
+    @property
+    def network(self) -> Optional[str]:
+        """
+        | The card network that was used for a mobile payment method operation
+
+        Type: str
+        """
+        return self.__network
+
+    @network.setter
+    def network(self, value: Optional[str]) -> None:
+        self.__network = value
+
+    @property
+    def payment_data(self) -> Optional[MobilePaymentData]:
+        """
+        | Object containing payment details
+
+        Type: :class:`onlinepayments.sdk.domain.mobile_payment_data.MobilePaymentData`
+        """
+        return self.__payment_data
+
+    @payment_data.setter
+    def payment_data(self, value: Optional[MobilePaymentData]) -> None:
+        self.__payment_data = 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 three_d_secure_results(self) -> Optional[ThreeDSecureResults]:
+        """
+        | 3D Secure results object
+
+        Type: :class:`onlinepayments.sdk.domain.three_d_secure_results.ThreeDSecureResults`
+        """
+        return self.__three_d_secure_results
+
+    @three_d_secure_results.setter
+    def three_d_secure_results(self, value: Optional[ThreeDSecureResults]) -> None:
+        self.__three_d_secure_results = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MobilePaymentMethodSpecificOutput, self).to_dictionary()
+        if self.authorisation_code is not None:
+            dictionary['authorisationCode'] = self.authorisation_code
+        if self.fraud_results is not None:
+            dictionary['fraudResults'] = self.fraud_results.to_dictionary()
+        if self.network is not None:
+            dictionary['network'] = self.network
+        if self.payment_data is not None:
+            dictionary['paymentData'] = self.payment_data.to_dictionary()
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        if self.three_d_secure_results is not None:
+            dictionary['threeDSecureResults'] = self.three_d_secure_results.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MobilePaymentMethodSpecificOutput':
+        super(MobilePaymentMethodSpecificOutput, self).from_dictionary(dictionary)
+        if 'authorisationCode' in dictionary:
+            self.authorisation_code = dictionary['authorisationCode']
+        if 'fraudResults' in dictionary:
+            if not isinstance(dictionary['fraudResults'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['fraudResults']))
+            value = CardFraudResults()
+            self.fraud_results = value.from_dictionary(dictionary['fraudResults'])
+        if 'network' in dictionary:
+            self.network = dictionary['network']
+        if 'paymentData' in dictionary:
+            if not isinstance(dictionary['paymentData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentData']))
+            value = MobilePaymentData()
+            self.payment_data = value.from_dictionary(dictionary['paymentData'])
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        if 'threeDSecureResults' in dictionary:
+            if not isinstance(dictionary['threeDSecureResults'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['threeDSecureResults']))
+            value = ThreeDSecureResults()
+            self.three_d_secure_results = value.from_dictionary(dictionary['threeDSecureResults'])
+        return self

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/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

onlinepayments/sdk/domain/mobile_three_d_secure_challenge_parameters.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class MobileThreeDSecureChallengeParameters(DataObject):
+
+    __acs_reference_number: Optional[str] = None
+    __acs_signed_content: Optional[str] = None
+    __acs_transaction_id: Optional[str] = None
+    __three_d_server_transaction_id: Optional[str] = None
+
+    @property
+    def acs_reference_number(self) -> Optional[str]:
+        """
+        | The unique identifier assigned by the EMVCo Secretariat upon testing and approval.
+
+        Type: str
+        """
+        return self.__acs_reference_number
+
+    @acs_reference_number.setter
+    def acs_reference_number(self, value: Optional[str]) -> None:
+        self.__acs_reference_number = value
+
+    @property
+    def acs_signed_content(self) -> Optional[str]:
+        """
+        | Contains the JWS object created by the ACS for the challenge (ARes).
+
+        Type: str
+        """
+        return self.__acs_signed_content
+
+    @acs_signed_content.setter
+    def acs_signed_content(self, value: Optional[str]) -> None:
+        self.__acs_signed_content = value
+
+    @property
+    def acs_transaction_id(self) -> Optional[str]:
+        """
+        | The ACS Transaction ID for a prior 3-D Secure authenticated transaction (for example, the first recurring transaction that was authenticated with the customer).
+
+        Type: str
+        """
+        return self.__acs_transaction_id
+
+    @acs_transaction_id.setter
+    def acs_transaction_id(self, value: Optional[str]) -> None:
+        self.__acs_transaction_id = value
+
+    @property
+    def three_d_server_transaction_id(self) -> Optional[str]:
+        """
+        | The 3-D Secure version 2 transaction ID that is used for the 3D Authentication
+
+        Type: str
+        """
+        return self.__three_d_server_transaction_id
+
+    @three_d_server_transaction_id.setter
+    def three_d_server_transaction_id(self, value: Optional[str]) -> None:
+        self.__three_d_server_transaction_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MobileThreeDSecureChallengeParameters, self).to_dictionary()
+        if self.acs_reference_number is not None:
+            dictionary['acsReferenceNumber'] = self.acs_reference_number
+        if self.acs_signed_content is not None:
+            dictionary['acsSignedContent'] = self.acs_signed_content
+        if self.acs_transaction_id is not None:
+            dictionary['acsTransactionId'] = self.acs_transaction_id
+        if self.three_d_server_transaction_id is not None:
+            dictionary['threeDServerTransactionId'] = self.three_d_server_transaction_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MobileThreeDSecureChallengeParameters':
+        super(MobileThreeDSecureChallengeParameters, self).from_dictionary(dictionary)
+        if 'acsReferenceNumber' in dictionary:
+            self.acs_reference_number = dictionary['acsReferenceNumber']
+        if 'acsSignedContent' in dictionary:
+            self.acs_signed_content = dictionary['acsSignedContent']
+        if 'acsTransactionId' in dictionary:
+            self.acs_transaction_id = dictionary['acsTransactionId']
+        if 'threeDServerTransactionId' in dictionary:
+            self.three_d_server_transaction_id = dictionary['threeDServerTransactionId']
+        return self