connect-sdk-python3 3.47.0__zip → 4.0.1__zip

connect-sdk-python3-3.47.0/ingenico/connect/sdk/domain/payment/definitions/mobile_payment_method_specific_input.py

@@ -1,168 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://epayments-api.developer-ingenico.com/
-#
-from ingenico.connect.sdk.domain.definitions.abstract_payment_method_specific_input import AbstractPaymentMethodSpecificInput
-from ingenico.connect.sdk.domain.payment.definitions.decrypted_payment_data import DecryptedPaymentData
-from ingenico.connect.sdk.domain.payment.definitions.mobile_payment_product320_specific_input import MobilePaymentProduct320SpecificInput
-
-
-class MobilePaymentMethodSpecificInput(AbstractPaymentMethodSpecificInput):
-
-    __authorization_mode = None
-    __customer_reference = None
-    __decrypted_payment_data = None
-    __encrypted_payment_data = None
-    __payment_product320_specific_input = None
-    __requires_approval = None
-    __skip_fraud_service = None
-
-    @property
-    def authorization_mode(self):
-        """
-        | 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):
-        self.__authorization_mode = value
-
-    @property
-    def customer_reference(self):
-        """
-        | 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):
-        self.__customer_reference = value
-
-    @property
-    def decrypted_payment_data(self):
-        """
-        | The payment data if you do the decryption of the encrypted payment data yourself.
-        
-        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.decrypted_payment_data.DecryptedPaymentData`
-        """
-        return self.__decrypted_payment_data
-
-    @decrypted_payment_data.setter
-    def decrypted_payment_data(self, value):
-        self.__decrypted_payment_data = value
-
-    @property
-    def encrypted_payment_data(self):
-        """
-        | 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):
-        self.__encrypted_payment_data = value
-
-    @property
-    def payment_product320_specific_input(self):
-        """
-        | Object containing information specific to Google Pay
-        
-        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.mobile_payment_product320_specific_input.MobilePaymentProduct320SpecificInput`
-        """
-        return self.__payment_product320_specific_input
-
-    @payment_product320_specific_input.setter
-    def payment_product320_specific_input(self, value):
-        self.__payment_product320_specific_input = value
-
-    @property
-    def requires_approval(self):
-        """
-        * true = the payment requires approval before the funds will be captured using the Capture payment <https://epayments-api.developer-ingenico.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):
-        self.__requires_approval = value
-
-    @property
-    def skip_fraud_service(self):
-        """
-        * 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):
-        self.__skip_fraud_service = value
-
-    def to_dictionary(self):
-        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):
-        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-3.47.0/ingenico/connect/sdk/domain/payment/definitions/mobile_payment_method_specific_output.py

@@ -1,120 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://epayments-api.developer-ingenico.com/
-#
-from ingenico.connect.sdk.domain.definitions.card_fraud_results import CardFraudResults
-from ingenico.connect.sdk.domain.payment.definitions.abstract_payment_method_specific_output import AbstractPaymentMethodSpecificOutput
-from ingenico.connect.sdk.domain.payment.definitions.mobile_payment_data import MobilePaymentData
-from ingenico.connect.sdk.domain.payment.definitions.three_d_secure_results import ThreeDSecureResults
-
-
-class MobilePaymentMethodSpecificOutput(AbstractPaymentMethodSpecificOutput):
-
-    __authorisation_code = None
-    __fraud_results = None
-    __network = None
-    __payment_data = None
-    __three_d_secure_results = None
-
-    @property
-    def authorisation_code(self):
-        """
-        | Card Authorization code as returned by the acquirer
-        
-        Type: str
-        """
-        return self.__authorisation_code
-
-    @authorisation_code.setter
-    def authorisation_code(self, value):
-        self.__authorisation_code = value
-
-    @property
-    def fraud_results(self):
-        """
-        | Fraud results contained in the CardFraudResults object
-        
-        Type: :class:`ingenico.connect.sdk.domain.definitions.card_fraud_results.CardFraudResults`
-        """
-        return self.__fraud_results
-
-    @fraud_results.setter
-    def fraud_results(self, value):
-        self.__fraud_results = value
-
-    @property
-    def network(self):
-        """
-        | The network that was used for the refund
-        
-        Type: str
-        """
-        return self.__network
-
-    @network.setter
-    def network(self, value):
-        self.__network = value
-
-    @property
-    def payment_data(self):
-        """
-        | Object containing payment details
-        
-        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.mobile_payment_data.MobilePaymentData`
-        """
-        return self.__payment_data
-
-    @payment_data.setter
-    def payment_data(self, value):
-        self.__payment_data = value
-
-    @property
-    def three_d_secure_results(self):
-        """
-        | 3D Secure results object
-        
-        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.three_d_secure_results.ThreeDSecureResults`
-        """
-        return self.__three_d_secure_results
-
-    @three_d_secure_results.setter
-    def three_d_secure_results(self, value):
-        self.__three_d_secure_results = value
-
-    def to_dictionary(self):
-        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):
-        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-3.47.0/ingenico/connect/sdk/domain/payment/definitions/mobile_payment_product320_specific_input.py

@@ -1,59 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://epayments-api.developer-ingenico.com/
-#
-from ingenico.connect.sdk.data_object import DataObject
-from ingenico.connect.sdk.domain.payment.definitions.g_pay_three_d_secure import GPayThreeDSecure
-
-
-class MobilePaymentProduct320SpecificInput(DataObject):
-
-    __cardholder_name = None
-    __three_d_secure = None
-
-    @property
-    def cardholder_name(self):
-        """
-        | The card holder's name on the card.
-        | The encrypted payment data can be found in property paymentMethodData.tokenizationData.info.billingAddress.name of the PaymentData <https://developers.google.com/android/reference/com/google/android/gms/wallet/PaymentData>.toJson() result.
-        
-        Type: str
-        """
-        return self.__cardholder_name
-
-    @cardholder_name.setter
-    def cardholder_name(self, value):
-        self.__cardholder_name = value
-
-    @property
-    def three_d_secure(self):
-        """
-        | Object containing specific data regarding 3-D Secure
-        
-        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.g_pay_three_d_secure.GPayThreeDSecure`
-        """
-        return self.__three_d_secure
-
-    @three_d_secure.setter
-    def three_d_secure(self, value):
-        self.__three_d_secure = value
-
-    def to_dictionary(self):
-        dictionary = super(MobilePaymentProduct320SpecificInput, self).to_dictionary()
-        if self.cardholder_name is not None:
-            dictionary['cardholderName'] = self.cardholder_name
-        if self.three_d_secure is not None:
-            dictionary['threeDSecure'] = self.three_d_secure.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(MobilePaymentProduct320SpecificInput, self).from_dictionary(dictionary)
-        if 'cardholderName' in dictionary:
-            self.cardholder_name = dictionary['cardholderName']
-        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'])
-        return self

connect-sdk-python3-3.47.0/ingenico/connect/sdk/domain/payment/definitions/mobile_three_d_secure_challenge_parameters.py

@@ -1,90 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://epayments-api.developer-ingenico.com/
-#
-from ingenico.connect.sdk.data_object import DataObject
-
-
-class MobileThreeDSecureChallengeParameters(DataObject):
-
-    __acs_reference_number = None
-    __acs_signed_content = None
-    __acs_transaction_id = None
-    __three_d_server_transaction_id = None
-
-    @property
-    def acs_reference_number(self):
-        """
-        | 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):
-        self.__acs_reference_number = value
-
-    @property
-    def acs_signed_content(self):
-        """
-        | 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):
-        self.__acs_signed_content = value
-
-    @property
-    def acs_transaction_id(self):
-        """
-        | 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):
-        self.__acs_transaction_id = value
-
-    @property
-    def three_d_server_transaction_id(self):
-        """
-        | 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):
-        self.__three_d_server_transaction_id = value
-
-    def to_dictionary(self):
-        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):
-        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

connect-sdk-python3-3.47.0/ingenico/connect/sdk/domain/payment/definitions/non_sepa_direct_debit_payment_method_specific_input.py

@@ -1,198 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://epayments-api.developer-ingenico.com/
-#
-from ingenico.connect.sdk.domain.definitions.abstract_payment_method_specific_input import AbstractPaymentMethodSpecificInput
-from ingenico.connect.sdk.domain.payment.definitions.non_sepa_direct_debit_payment_product705_specific_input import NonSepaDirectDebitPaymentProduct705SpecificInput
-from ingenico.connect.sdk.domain.payment.definitions.non_sepa_direct_debit_payment_product730_specific_input import NonSepaDirectDebitPaymentProduct730SpecificInput
-
-
-class NonSepaDirectDebitPaymentMethodSpecificInput(AbstractPaymentMethodSpecificInput):
-
-    __date_collect = None
-    __direct_debit_text = None
-    __is_recurring = None
-    __payment_product705_specific_input = None
-    __payment_product730_specific_input = None
-    __recurring_payment_sequence_indicator = None
-    __requires_approval = None
-    __token = None
-    __tokenize = None
-
-    @property
-    def date_collect(self):
-        """
-        | Direct Debit payment collection date
-        | Format: YYYYMMDD
-        
-        Type: str
-        """
-        return self.__date_collect
-
-    @date_collect.setter
-    def date_collect(self, value):
-        self.__date_collect = value
-
-    @property
-    def direct_debit_text(self):
-        """
-        | Descriptor intended to identify the transaction on the customer's bank statement
-        
-        Type: str
-        """
-        return self.__direct_debit_text
-
-    @direct_debit_text.setter
-    def direct_debit_text(self, value):
-        self.__direct_debit_text = value
-
-    @property
-    def is_recurring(self):
-        """
-        | Indicates if this transaction is of a one-off or a recurring type
-        
-        * true - This is recurring
-        * false - This is one-off
-        
-        Type: bool
-        """
-        return self.__is_recurring
-
-    @is_recurring.setter
-    def is_recurring(self, value):
-        self.__is_recurring = value
-
-    @property
-    def payment_product705_specific_input(self):
-        """
-        | Object containing UK Direct Debit specific details
-        
-        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.non_sepa_direct_debit_payment_product705_specific_input.NonSepaDirectDebitPaymentProduct705SpecificInput`
-        """
-        return self.__payment_product705_specific_input
-
-    @payment_product705_specific_input.setter
-    def payment_product705_specific_input(self, value):
-        self.__payment_product705_specific_input = value
-
-    @property
-    def payment_product730_specific_input(self):
-        """
-        | Object containing ACH specific details
-        
-        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.non_sepa_direct_debit_payment_product730_specific_input.NonSepaDirectDebitPaymentProduct730SpecificInput`
-        """
-        return self.__payment_product730_specific_input
-
-    @payment_product730_specific_input.setter
-    def payment_product730_specific_input(self, value):
-        self.__payment_product730_specific_input = value
-
-    @property
-    def recurring_payment_sequence_indicator(self):
-        """
-        * first = This transaction is the first of a series of recurring transactions
-        * recurring = This transaction is a subsequent transaction in a series of recurring transactions
-        * last = This transaction is the last transaction of a series of recurring transactions
-        
-        Type: str
-        """
-        return self.__recurring_payment_sequence_indicator
-
-    @recurring_payment_sequence_indicator.setter
-    def recurring_payment_sequence_indicator(self, value):
-        self.__recurring_payment_sequence_indicator = value
-
-    @property
-    def requires_approval(self):
-        """
-        * 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):
-        self.__requires_approval = value
-
-    @property
-    def token(self):
-        """
-        | ID of the stored token that contains the bank account details to be debited
-        
-        Type: str
-        """
-        return self.__token
-
-    @token.setter
-    def token(self, value):
-        self.__token = value
-
-    @property
-    def tokenize(self):
-        """
-        | Indicates if this transaction should be tokenized
-        
-        * true - Tokenize the transaction
-        * 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):
-        self.__tokenize = value
-
-    def to_dictionary(self):
-        dictionary = super(NonSepaDirectDebitPaymentMethodSpecificInput, self).to_dictionary()
-        if self.date_collect is not None:
-            dictionary['dateCollect'] = self.date_collect
-        if self.direct_debit_text is not None:
-            dictionary['directDebitText'] = self.direct_debit_text
-        if self.is_recurring is not None:
-            dictionary['isRecurring'] = self.is_recurring
-        if self.payment_product705_specific_input is not None:
-            dictionary['paymentProduct705SpecificInput'] = self.payment_product705_specific_input.to_dictionary()
-        if self.payment_product730_specific_input is not None:
-            dictionary['paymentProduct730SpecificInput'] = self.payment_product730_specific_input.to_dictionary()
-        if self.recurring_payment_sequence_indicator is not None:
-            dictionary['recurringPaymentSequenceIndicator'] = self.recurring_payment_sequence_indicator
-        if self.requires_approval is not None:
-            dictionary['requiresApproval'] = self.requires_approval
-        if self.token is not None:
-            dictionary['token'] = self.token
-        if self.tokenize is not None:
-            dictionary['tokenize'] = self.tokenize
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(NonSepaDirectDebitPaymentMethodSpecificInput, self).from_dictionary(dictionary)
-        if 'dateCollect' in dictionary:
-            self.date_collect = dictionary['dateCollect']
-        if 'directDebitText' in dictionary:
-            self.direct_debit_text = dictionary['directDebitText']
-        if 'isRecurring' in dictionary:
-            self.is_recurring = dictionary['isRecurring']
-        if 'paymentProduct705SpecificInput' in dictionary:
-            if not isinstance(dictionary['paymentProduct705SpecificInput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct705SpecificInput']))
-            value = NonSepaDirectDebitPaymentProduct705SpecificInput()
-            self.payment_product705_specific_input = value.from_dictionary(dictionary['paymentProduct705SpecificInput'])
-        if 'paymentProduct730SpecificInput' in dictionary:
-            if not isinstance(dictionary['paymentProduct730SpecificInput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct730SpecificInput']))
-            value = NonSepaDirectDebitPaymentProduct730SpecificInput()
-            self.payment_product730_specific_input = value.from_dictionary(dictionary['paymentProduct730SpecificInput'])
-        if 'recurringPaymentSequenceIndicator' in dictionary:
-            self.recurring_payment_sequence_indicator = dictionary['recurringPaymentSequenceIndicator']
-        if 'requiresApproval' in dictionary:
-            self.requires_approval = dictionary['requiresApproval']
-        if 'token' in dictionary:
-            self.token = dictionary['token']
-        if 'tokenize' in dictionary:
-            self.tokenize = dictionary['tokenize']
-        return self

connect-sdk-python3-3.47.0/ingenico/connect/sdk/domain/payment/definitions/non_sepa_direct_debit_payment_method_specific_output.py

@@ -1,40 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://epayments-api.developer-ingenico.com/
-#
-from ingenico.connect.sdk.domain.definitions.fraud_results import FraudResults
-from ingenico.connect.sdk.domain.payment.definitions.abstract_payment_method_specific_output import AbstractPaymentMethodSpecificOutput
-
-
-class NonSepaDirectDebitPaymentMethodSpecificOutput(AbstractPaymentMethodSpecificOutput):
-
-    __fraud_results = None
-
-    @property
-    def fraud_results(self):
-        """
-        | Object containing the results of the fraud screening
-        
-        Type: :class:`ingenico.connect.sdk.domain.definitions.fraud_results.FraudResults`
-        """
-        return self.__fraud_results
-
-    @fraud_results.setter
-    def fraud_results(self, value):
-        self.__fraud_results = value
-
-    def to_dictionary(self):
-        dictionary = super(NonSepaDirectDebitPaymentMethodSpecificOutput, self).to_dictionary()
-        if self.fraud_results is not None:
-            dictionary['fraudResults'] = self.fraud_results.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(NonSepaDirectDebitPaymentMethodSpecificOutput, self).from_dictionary(dictionary)
-        if 'fraudResults' in dictionary:
-            if not isinstance(dictionary['fraudResults'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['fraudResults']))
-            value = FraudResults()
-            self.fraud_results = value.from_dictionary(dictionary['fraudResults'])
-        return self