connect-sdk-python3 3.47.0__zip → 4.0.0__zip

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/microsoft_fraud_results.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class MicrosoftFraudResults(DataObject):
+
+    __clause_name: Optional[str] = None
+    __device_country_code: Optional[str] = None
+    __device_id: Optional[str] = None
+    __fraud_score: Optional[int] = None
+    __policy_applied: Optional[str] = None
+    __true_ip_address: Optional[str] = None
+    __user_device_type: Optional[str] = None
+
+    @property
+    def clause_name(self) -> Optional[str]:
+        """
+        | Name of the clause within the applied policy that was triggered during the evaluation of this transaction.
+        
+        Type: str
+        """
+        return self.__clause_name
+
+    @clause_name.setter
+    def clause_name(self, value: Optional[str]) -> None:
+        self.__clause_name = value
+
+    @property
+    def device_country_code(self) -> Optional[str]:
+        """
+        | The country of the customer determined by Microsoft Device Fingerprinting.
+        
+        Type: str
+        """
+        return self.__device_country_code
+
+    @device_country_code.setter
+    def device_country_code(self, value: Optional[str]) -> None:
+        self.__device_country_code = value
+
+    @property
+    def device_id(self) -> Optional[str]:
+        """
+        | This is the device fingerprint value. Based on the amount of data that the device fingerprint collector script was able to collect, this will be a proxy ID for the device used by the customer. 
+        
+        Type: str
+        """
+        return self.__device_id
+
+    @device_id.setter
+    def device_id(self, value: Optional[str]) -> None:
+        self.__device_id = value
+
+    @property
+    def fraud_score(self) -> Optional[int]:
+        """
+        | Result of the Microsoft Fraud Protection check. This contains the normalized fraud score from a scale of 0 to 100. A higher score indicates an increased risk of fraud.
+        
+        Type: int
+        """
+        return self.__fraud_score
+
+    @fraud_score.setter
+    def fraud_score(self, value: Optional[int]) -> None:
+        self.__fraud_score = value
+
+    @property
+    def policy_applied(self) -> Optional[str]:
+        """
+        | Name of the policy that was applied on during the evaluation of this transaction.
+        
+        Type: str
+        """
+        return self.__policy_applied
+
+    @policy_applied.setter
+    def policy_applied(self, value: Optional[str]) -> None:
+        self.__policy_applied = value
+
+    @property
+    def true_ip_address(self) -> Optional[str]:
+        """
+        | The true IP address as determined by Microsoft Device Fingerprinting.
+        
+        Type: str
+        """
+        return self.__true_ip_address
+
+    @true_ip_address.setter
+    def true_ip_address(self, value: Optional[str]) -> None:
+        self.__true_ip_address = value
+
+    @property
+    def user_device_type(self) -> Optional[str]:
+        """
+        | The type of device used by the customer.
+        
+        Type: str
+        """
+        return self.__user_device_type
+
+    @user_device_type.setter
+    def user_device_type(self, value: Optional[str]) -> None:
+        self.__user_device_type = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MicrosoftFraudResults, self).to_dictionary()
+        if self.clause_name is not None:
+            dictionary['clauseName'] = self.clause_name
+        if self.device_country_code is not None:
+            dictionary['deviceCountryCode'] = self.device_country_code
+        if self.device_id is not None:
+            dictionary['deviceId'] = self.device_id
+        if self.fraud_score is not None:
+            dictionary['fraudScore'] = self.fraud_score
+        if self.policy_applied is not None:
+            dictionary['policyApplied'] = self.policy_applied
+        if self.true_ip_address is not None:
+            dictionary['trueIpAddress'] = self.true_ip_address
+        if self.user_device_type is not None:
+            dictionary['userDeviceType'] = self.user_device_type
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MicrosoftFraudResults':
+        super(MicrosoftFraudResults, self).from_dictionary(dictionary)
+        if 'clauseName' in dictionary:
+            self.clause_name = dictionary['clauseName']
+        if 'deviceCountryCode' in dictionary:
+            self.device_country_code = dictionary['deviceCountryCode']
+        if 'deviceId' in dictionary:
+            self.device_id = dictionary['deviceId']
+        if 'fraudScore' in dictionary:
+            self.fraud_score = dictionary['fraudScore']
+        if 'policyApplied' in dictionary:
+            self.policy_applied = dictionary['policyApplied']
+        if 'trueIpAddress' in dictionary:
+            self.true_ip_address = dictionary['trueIpAddress']
+        if 'userDeviceType' in dictionary:
+            self.user_device_type = dictionary['userDeviceType']
+        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/mobile_payment_data.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class MobilePaymentData(DataObject):
+
+    __dpan: Optional[str] = None
+    __expiry_date: Optional[str] = None
+
+    @property
+    def dpan(self) -> Optional[str]:
+        """
+        | The obfuscated DPAN. Only the last four digits are visible.
+        
+        Type: str
+        """
+        return self.__dpan
+
+    @dpan.setter
+    def dpan(self, value: Optional[str]) -> None:
+        self.__dpan = value
+
+    @property
+    def expiry_date(self) -> Optional[str]:
+        """
+        | Expiry date of the tokenized card
+        | Format: MMYY
+        
+        Type: str
+        """
+        return self.__expiry_date
+
+    @expiry_date.setter
+    def expiry_date(self, value: Optional[str]) -> None:
+        self.__expiry_date = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MobilePaymentData, self).to_dictionary()
+        if self.dpan is not None:
+            dictionary['dpan'] = self.dpan
+        if self.expiry_date is not None:
+            dictionary['expiryDate'] = self.expiry_date
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MobilePaymentData':
+        super(MobilePaymentData, self).from_dictionary(dictionary)
+        if 'dpan' in dictionary:
+            self.dpan = dictionary['dpan']
+        if 'expiryDate' in dictionary:
+            self.expiry_date = dictionary['expiryDate']
+        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/mobile_payment_method_specific_input.py

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.v1.domain.abstract_payment_method_specific_input import AbstractPaymentMethodSpecificInput
+from worldline.connect.sdk.v1.domain.decrypted_payment_data import DecryptedPaymentData
+from worldline.connect.sdk.v1.domain.mobile_payment_product320_specific_input import MobilePaymentProduct320SpecificInput
+
+
+class MobilePaymentMethodSpecificInput(AbstractPaymentMethodSpecificInput):
+
+    __authorization_mode: Optional[str] = None
+    __customer_reference: Optional[str] = None
+    __decrypted_payment_data: Optional[DecryptedPaymentData] = None
+    __encrypted_payment_data: Optional[str] = None
+    __payment_product320_specific_input: Optional[MobilePaymentProduct320SpecificInput] = None
+    __requires_approval: Optional[bool] = None
+    __skip_fraud_service: 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, ingnored for acquirers that don't support this. In case the acquirer doesn't 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 customer_reference(self) -> Optional[str]:
+        """
+        | Reference of the customer for the payment (purchase order #, etc.). Only used with some acquirers.
+        
+        Type: str
+        """
+        return self.__customer_reference
+
+    @customer_reference.setter
+    def customer_reference(self, value: Optional[str]) -> None:
+        self.__customer_reference = 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:`worldline.connect.sdk.v1.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 is the PKPayment <https://developer.apple.com/documentation/passkit/pkpayment>.token.paymentData object passed as a string (with all quotation marks escaped).
+        * For Google Pay, the encrypted payment data can be found in property paymentMethodData.tokenizationData.token of the PaymentData <https://developers.google.com/android/reference/com/google/android/gms/wallet/PaymentData>.toJson() result.
+        
+        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 payment_product320_specific_input(self) -> Optional[MobilePaymentProduct320SpecificInput]:
+        """
+        | Object containing information specific to Google Pay
+        
+        Type: :class:`worldline.connect.sdk.v1.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 requires_approval(self) -> Optional[bool]:
+        """
+        * true = the payment requires approval before the funds will be captured using the Capture payment <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/payments/approve.html> 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
+
+    @property
+    def skip_fraud_service(self) -> Optional[bool]:
+        """
+        * true = Fraud scoring will be skipped for this transaction
+        * false = Fraud scoring will not be skipped for this transaction
+        
+        | Note: This is only possible if your account in our system is setup for Fraud scoring and if your configuration in our system allows you to override it per transaction.
+        
+        Type: bool
+        """
+        return self.__skip_fraud_service
+
+    @skip_fraud_service.setter
+    def skip_fraud_service(self, value: Optional[bool]) -> None:
+        self.__skip_fraud_service = 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.customer_reference is not None:
+            dictionary['customerReference'] = self.customer_reference
+        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.payment_product320_specific_input is not None:
+            dictionary['paymentProduct320SpecificInput'] = self.payment_product320_specific_input.to_dictionary()
+        if self.requires_approval is not None:
+            dictionary['requiresApproval'] = self.requires_approval
+        if self.skip_fraud_service is not None:
+            dictionary['skipFraudService'] = self.skip_fraud_service
+        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 'customerReference' in dictionary:
+            self.customer_reference = dictionary['customerReference']
+        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 '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 'requiresApproval' in dictionary:
+            self.requires_approval = dictionary['requiresApproval']
+        if 'skipFraudService' in dictionary:
+            self.skip_fraud_service = dictionary['skipFraudService']
+        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/mobile_payment_method_specific_input_hosted_checkout.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.v1.domain.abstract_payment_method_specific_input import AbstractPaymentMethodSpecificInput
+from worldline.connect.sdk.v1.domain.mobile_payment_product302_specific_input_hosted_checkout import MobilePaymentProduct302SpecificInputHostedCheckout
+from worldline.connect.sdk.v1.domain.mobile_payment_product320_specific_input_hosted_checkout import MobilePaymentProduct320SpecificInputHostedCheckout
+
+
+class MobilePaymentMethodSpecificInputHostedCheckout(AbstractPaymentMethodSpecificInput):
+
+    __authorization_mode: Optional[str] = None
+    __customer_reference: Optional[str] = None
+    __payment_product302_specific_input: Optional[MobilePaymentProduct302SpecificInputHostedCheckout] = None
+    __payment_product320_specific_input: Optional[MobilePaymentProduct320SpecificInputHostedCheckout] = None
+    __requires_approval: Optional[bool] = None
+    __skip_fraud_service: 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, ingnored for acquirers that don't support this. In case the acquirer doesn't 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 customer_reference(self) -> Optional[str]:
+        """
+        | Reference of the customer for the payment (purchase order #, etc.). Only used with some acquirers.
+        
+        Type: str
+        """
+        return self.__customer_reference
+
+    @customer_reference.setter
+    def customer_reference(self, value: Optional[str]) -> None:
+        self.__customer_reference = value
+
+    @property
+    def payment_product302_specific_input(self) -> Optional[MobilePaymentProduct302SpecificInputHostedCheckout]:
+        """
+        | Object containing information specific to Apple Pay
+        
+        Type: :class:`worldline.connect.sdk.v1.domain.mobile_payment_product302_specific_input_hosted_checkout.MobilePaymentProduct302SpecificInputHostedCheckout`
+        """
+        return self.__payment_product302_specific_input
+
+    @payment_product302_specific_input.setter
+    def payment_product302_specific_input(self, value: Optional[MobilePaymentProduct302SpecificInputHostedCheckout]) -> None:
+        self.__payment_product302_specific_input = value
+
+    @property
+    def payment_product320_specific_input(self) -> Optional[MobilePaymentProduct320SpecificInputHostedCheckout]:
+        """
+        | Object containing information specific to Google Pay (paymentProductId 320)
+        
+        Type: :class:`worldline.connect.sdk.v1.domain.mobile_payment_product320_specific_input_hosted_checkout.MobilePaymentProduct320SpecificInputHostedCheckout`
+        """
+        return self.__payment_product320_specific_input
+
+    @payment_product320_specific_input.setter
+    def payment_product320_specific_input(self, value: Optional[MobilePaymentProduct320SpecificInputHostedCheckout]) -> None:
+        self.__payment_product320_specific_input = value
+
+    @property
+    def requires_approval(self) -> Optional[bool]:
+        """
+        * true = the payment requires approval before the funds will be captured using the Capture payment <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/payments/approve.html> 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
+
+    @property
+    def skip_fraud_service(self) -> Optional[bool]:
+        """
+        * true = Fraud scoring will be skipped for this transaction
+        * false = Fraud scoring will not be skipped for this transaction
+        
+        | Note: This is only possible if your account in our system is setup for Fraud scoring and if your configuration in our system allows you to override it per transaction.
+        
+        Type: bool
+        """
+        return self.__skip_fraud_service
+
+    @skip_fraud_service.setter
+    def skip_fraud_service(self, value: Optional[bool]) -> None:
+        self.__skip_fraud_service = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MobilePaymentMethodSpecificInputHostedCheckout, self).to_dictionary()
+        if self.authorization_mode is not None:
+            dictionary['authorizationMode'] = self.authorization_mode
+        if self.customer_reference is not None:
+            dictionary['customerReference'] = self.customer_reference
+        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.requires_approval is not None:
+            dictionary['requiresApproval'] = self.requires_approval
+        if self.skip_fraud_service is not None:
+            dictionary['skipFraudService'] = self.skip_fraud_service
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MobilePaymentMethodSpecificInputHostedCheckout':
+        super(MobilePaymentMethodSpecificInputHostedCheckout, self).from_dictionary(dictionary)
+        if 'authorizationMode' in dictionary:
+            self.authorization_mode = dictionary['authorizationMode']
+        if 'customerReference' in dictionary:
+            self.customer_reference = dictionary['customerReference']
+        if 'paymentProduct302SpecificInput' in dictionary:
+            if not isinstance(dictionary['paymentProduct302SpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct302SpecificInput']))
+            value = MobilePaymentProduct302SpecificInputHostedCheckout()
+            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 = MobilePaymentProduct320SpecificInputHostedCheckout()
+            self.payment_product320_specific_input = value.from_dictionary(dictionary['paymentProduct320SpecificInput'])
+        if 'requiresApproval' in dictionary:
+            self.requires_approval = dictionary['requiresApproval']
+        if 'skipFraudService' in dictionary:
+            self.skip_fraud_service = dictionary['skipFraudService']
+        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/mobile_payment_method_specific_output.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.v1.domain.abstract_payment_method_specific_output import AbstractPaymentMethodSpecificOutput
+from worldline.connect.sdk.v1.domain.card_fraud_results import CardFraudResults
+from worldline.connect.sdk.v1.domain.mobile_payment_data import MobilePaymentData
+from worldline.connect.sdk.v1.domain.three_d_secure_results import ThreeDSecureResults
+
+
+class MobilePaymentMethodSpecificOutput(AbstractPaymentMethodSpecificOutput):
+
+    __authorisation_code: Optional[str] = None
+    __fraud_results: Optional[CardFraudResults] = None
+    __network: Optional[str] = None
+    __payment_data: Optional[MobilePaymentData] = 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:`worldline.connect.sdk.v1.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 network that was used for the refund
+        
+        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:`worldline.connect.sdk.v1.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 three_d_secure_results(self) -> Optional[ThreeDSecureResults]:
+        """
+        | 3D Secure results object
+        
+        Type: :class:`worldline.connect.sdk.v1.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.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 '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

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/mobile_payment_product302_specific_input_hosted_checkout.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class MobilePaymentProduct302SpecificInputHostedCheckout(DataObject):
+
+    __business_name: Optional[str] = None
+
+    @property
+    def business_name(self) -> Optional[str]:
+        """
+        | Used as an input for the Apple Pay payment button. Your default business name is configured in the Configuration Center. In case you want to use another business name than the one configured in the Configuration Center, provide your company name in a human readable form.
+        
+        Type: str
+        """
+        return self.__business_name
+
+    @business_name.setter
+    def business_name(self, value: Optional[str]) -> None:
+        self.__business_name = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MobilePaymentProduct302SpecificInputHostedCheckout, self).to_dictionary()
+        if self.business_name is not None:
+            dictionary['businessName'] = self.business_name
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MobilePaymentProduct302SpecificInputHostedCheckout':
+        super(MobilePaymentProduct302SpecificInputHostedCheckout, self).from_dictionary(dictionary)
+        if 'businessName' in dictionary:
+            self.business_name = dictionary['businessName']
+        return self