connect-sdk-python2 3.45.0__zip → 3.47.0__zip

connect-sdk-python2-3.47.0/ingenico/connect/sdk/domain/payment/definitions/payment.py

@@ -0,0 +1,126 @@
+# -*- 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_order_status import AbstractOrderStatus
+from ingenico.connect.sdk.domain.payment.definitions.hosted_checkout_specific_output import HostedCheckoutSpecificOutput
+from ingenico.connect.sdk.domain.payment.definitions.payment_output import PaymentOutput
+from ingenico.connect.sdk.domain.payment.definitions.payment_status_output import PaymentStatusOutput
+
+
+class Payment(AbstractOrderStatus):
+
+    __hosted_checkout_specific_output = None
+    __payment_output = None
+    __status = None
+    __status_output = None
+
+    @property
+    def hosted_checkout_specific_output(self):
+        """
+        | Hosted Checkout specific information. Populated if the payment was created on the GlobalCollect platform through a Hosted Checkout.
+        
+        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.hosted_checkout_specific_output.HostedCheckoutSpecificOutput`
+        """
+        return self.__hosted_checkout_specific_output
+
+    @hosted_checkout_specific_output.setter
+    def hosted_checkout_specific_output(self, value):
+        self.__hosted_checkout_specific_output = value
+
+    @property
+    def payment_output(self):
+        """
+        | Object containing payment details
+        
+        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.payment_output.PaymentOutput`
+        """
+        return self.__payment_output
+
+    @payment_output.setter
+    def payment_output(self, value):
+        self.__payment_output = value
+
+    @property
+    def status(self):
+        """
+        | Current high-level status of the payment in a human-readable form. Possible values are :
+        
+        * ACCOUNT_VERIFIED - The account has been verified using a validation services like 0$ auth
+        * CREATED - The transaction has been created. This is the initial state once a new payment is created.
+        * REDIRECTED - The customer has been redirected to a 3rd party to complete the authentication/payment
+        * PENDING_PAYMENT - Instructions have been provided and we are now waiting for the money to come in
+        * PENDING_FRAUD_APPROVAL - The transaction has been marked for manual review after an automatic fraud screening
+        * PENDING_APPROVAL - The transaction is awaiting approval from you to proceed with the capturing of the funds
+        * PENDING_COMPLETION - The transaction needs to be completed.
+        * PENDING_CAPTURE - The transaction is waiting for you to request one or more captures of the funds.
+        * REJECTED - The transaction has been rejected
+        * AUTHORIZATION_REQUESTED - we have requested an authorization against an asynchronous system and is awaiting its response
+        * CAPTURE_REQUESTED - The transaction is in the queue to be captured
+        * CAPTURED - The transaction has been captured and we have received online confirmation
+        * PAID - We have matched the incoming funds to the transaction
+        * CANCELLED - You have cancelled the transaction
+        * REJECTED_CAPTURE - We or one of our downstream acquirers/providers have rejected the capture request
+        * REVERSED - The transaction has been reversed
+        * CHARGEBACK_NOTIFICATION - We have received a notification of chargeback and this status informs you that your account will be debited for a particular transaction
+        * CHARGEBACKED - The transaction has been chargebacked
+        * REFUNDED - The transaction has been refunded
+        
+        
+        | Please see Statuses <https://epayments-api.developer-ingenico.com/s2sapi/v1/en_US/python/statuses.html> for a full overview of possible values.
+        
+        Type: str
+        """
+        return self.__status
+
+    @status.setter
+    def status(self, value):
+        self.__status = value
+
+    @property
+    def status_output(self):
+        """
+        | This object has the numeric representation of the current payment status, timestamp of last status change and performable action on the current payment resource.
+        | In case of failed payments and negative scenarios, detailed error information is listed.
+        
+        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.payment_status_output.PaymentStatusOutput`
+        """
+        return self.__status_output
+
+    @status_output.setter
+    def status_output(self, value):
+        self.__status_output = value
+
+    def to_dictionary(self):
+        dictionary = super(Payment, self).to_dictionary()
+        if self.hosted_checkout_specific_output is not None:
+            dictionary['hostedCheckoutSpecificOutput'] = self.hosted_checkout_specific_output.to_dictionary()
+        if self.payment_output is not None:
+            dictionary['paymentOutput'] = self.payment_output.to_dictionary()
+        if self.status is not None:
+            dictionary['status'] = self.status
+        if self.status_output is not None:
+            dictionary['statusOutput'] = self.status_output.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(Payment, self).from_dictionary(dictionary)
+        if 'hostedCheckoutSpecificOutput' in dictionary:
+            if not isinstance(dictionary['hostedCheckoutSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['hostedCheckoutSpecificOutput']))
+            value = HostedCheckoutSpecificOutput()
+            self.hosted_checkout_specific_output = value.from_dictionary(dictionary['hostedCheckoutSpecificOutput'])
+        if 'paymentOutput' in dictionary:
+            if not isinstance(dictionary['paymentOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentOutput']))
+            value = PaymentOutput()
+            self.payment_output = value.from_dictionary(dictionary['paymentOutput'])
+        if 'status' in dictionary:
+            self.status = dictionary['status']
+        if 'statusOutput' in dictionary:
+            if not isinstance(dictionary['statusOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['statusOutput']))
+            value = PaymentStatusOutput()
+            self.status_output = value.from_dictionary(dictionary['statusOutput'])
+        return self

connect-sdk-python2-3.47.0/ingenico/connect/sdk/domain/payment/definitions/payment_account_on_file.py

@@ -0,0 +1,59 @@
+# -*- 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 PaymentAccountOnFile(DataObject):
+    """
+    | Object containing information on the payment account data on file (tokens)
+    """
+
+    __create_date = None
+    __number_of_card_on_file_creation_attempts_last24_hours = None
+
+    @property
+    def create_date(self):
+        """
+        | The date (YYYYMMDD) when the payment account on file was first created.
+        
+        | In case a token is used for the transaction we will use the creation date of the token in our system in case you leave this property empty.
+        
+        Type: str
+        """
+        return self.__create_date
+
+    @create_date.setter
+    def create_date(self, value):
+        self.__create_date = value
+
+    @property
+    def number_of_card_on_file_creation_attempts_last24_hours(self):
+        """
+        | Number of attempts made to add new card to the customer account in the last 24 hours
+        
+        Type: int
+        """
+        return self.__number_of_card_on_file_creation_attempts_last24_hours
+
+    @number_of_card_on_file_creation_attempts_last24_hours.setter
+    def number_of_card_on_file_creation_attempts_last24_hours(self, value):
+        self.__number_of_card_on_file_creation_attempts_last24_hours = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentAccountOnFile, self).to_dictionary()
+        if self.create_date is not None:
+            dictionary['createDate'] = self.create_date
+        if self.number_of_card_on_file_creation_attempts_last24_hours is not None:
+            dictionary['numberOfCardOnFileCreationAttemptsLast24Hours'] = self.number_of_card_on_file_creation_attempts_last24_hours
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentAccountOnFile, self).from_dictionary(dictionary)
+        if 'createDate' in dictionary:
+            self.create_date = dictionary['createDate']
+        if 'numberOfCardOnFileCreationAttemptsLast24Hours' in dictionary:
+            self.number_of_card_on_file_creation_attempts_last24_hours = dictionary['numberOfCardOnFileCreationAttemptsLast24Hours']
+        return self

connect-sdk-python2-3.47.0/ingenico/connect/sdk/domain/payment/definitions/payment_creation_output.py

@@ -0,0 +1,93 @@
+# -*- 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.payment.definitions.payment_creation_references import PaymentCreationReferences
+
+
+class PaymentCreationOutput(PaymentCreationReferences):
+
+    __is_checked_remember_me = None
+    __is_new_token = None
+    __token = None
+    __tokenization_succeeded = None
+
+    @property
+    def is_checked_remember_me(self):
+        """
+        | Indicates whether the customer ticked the "Remember my details for future purchases" checkbox on the MyCheckout hosted payment pages
+        
+        Type: bool
+        """
+        return self.__is_checked_remember_me
+
+    @is_checked_remember_me.setter
+    def is_checked_remember_me(self, value):
+        self.__is_checked_remember_me = value
+
+    @property
+    def is_new_token(self):
+        """
+        | Indicates if a new token was created
+        
+        * true - A new token was created
+        * false - A token with the same card number already exists and is returned. Please note that the existing token has not been updated. When you want to update other data then the card number, you need to update data stored in the token explicitly, as data is never updated during the creation of a token.
+        
+        Type: bool
+        """
+        return self.__is_new_token
+
+    @is_new_token.setter
+    def is_new_token(self, value):
+        self.__is_new_token = value
+
+    @property
+    def token(self):
+        """
+        | ID of the token
+        
+        Type: str
+        """
+        return self.__token
+
+    @token.setter
+    def token(self, value):
+        self.__token = value
+
+    @property
+    def tokenization_succeeded(self):
+        """
+        | Indicates if tokenization was successful or not. If this value is false, then the token and isNewToken properties will not be set.
+        
+        Type: bool
+        """
+        return self.__tokenization_succeeded
+
+    @tokenization_succeeded.setter
+    def tokenization_succeeded(self, value):
+        self.__tokenization_succeeded = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentCreationOutput, self).to_dictionary()
+        if self.is_checked_remember_me is not None:
+            dictionary['isCheckedRememberMe'] = self.is_checked_remember_me
+        if self.is_new_token is not None:
+            dictionary['isNewToken'] = self.is_new_token
+        if self.token is not None:
+            dictionary['token'] = self.token
+        if self.tokenization_succeeded is not None:
+            dictionary['tokenizationSucceeded'] = self.tokenization_succeeded
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentCreationOutput, self).from_dictionary(dictionary)
+        if 'isCheckedRememberMe' in dictionary:
+            self.is_checked_remember_me = dictionary['isCheckedRememberMe']
+        if 'isNewToken' in dictionary:
+            self.is_new_token = dictionary['isNewToken']
+        if 'token' in dictionary:
+            self.token = dictionary['token']
+        if 'tokenizationSucceeded' in dictionary:
+            self.tokenization_succeeded = dictionary['tokenizationSucceeded']
+        return self

connect-sdk-python2-3.47.0/ingenico/connect/sdk/domain/payment/definitions/payment_creation_references.py

@@ -0,0 +1,54 @@
+# -*- 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 PaymentCreationReferences(DataObject):
+
+    __additional_reference = None
+    __external_reference = None
+
+    @property
+    def additional_reference(self):
+        """
+        | The additional reference identifier for this transaction. Data in this property will also be returned in our report files, allowing you to reconcile them.
+        
+        Type: str
+        """
+        return self.__additional_reference
+
+    @additional_reference.setter
+    def additional_reference(self, value):
+        self.__additional_reference = value
+
+    @property
+    def external_reference(self):
+        """
+        | The external reference identifier for this transaction. Data in this property will also be returned in our report files, allowing you to reconcile them.
+        
+        Type: str
+        """
+        return self.__external_reference
+
+    @external_reference.setter
+    def external_reference(self, value):
+        self.__external_reference = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentCreationReferences, self).to_dictionary()
+        if self.additional_reference is not None:
+            dictionary['additionalReference'] = self.additional_reference
+        if self.external_reference is not None:
+            dictionary['externalReference'] = self.external_reference
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentCreationReferences, self).from_dictionary(dictionary)
+        if 'additionalReference' in dictionary:
+            self.additional_reference = dictionary['additionalReference']
+        if 'externalReference' in dictionary:
+            self.external_reference = dictionary['externalReference']
+        return self

connect-sdk-python2-3.47.0/ingenico/connect/sdk/domain/payment/definitions/payment_output.py

@@ -0,0 +1,297 @@
+# -*- 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.payment.definitions.bank_transfer_payment_method_specific_output import BankTransferPaymentMethodSpecificOutput
+from ingenico.connect.sdk.domain.payment.definitions.card_payment_method_specific_output import CardPaymentMethodSpecificOutput
+from ingenico.connect.sdk.domain.payment.definitions.cash_payment_method_specific_output import CashPaymentMethodSpecificOutput
+from ingenico.connect.sdk.domain.payment.definitions.e_invoice_payment_method_specific_output import EInvoicePaymentMethodSpecificOutput
+from ingenico.connect.sdk.domain.payment.definitions.invoice_payment_method_specific_output import InvoicePaymentMethodSpecificOutput
+from ingenico.connect.sdk.domain.payment.definitions.mobile_payment_method_specific_output import MobilePaymentMethodSpecificOutput
+from ingenico.connect.sdk.domain.payment.definitions.non_sepa_direct_debit_payment_method_specific_output import NonSepaDirectDebitPaymentMethodSpecificOutput
+from ingenico.connect.sdk.domain.payment.definitions.order_output import OrderOutput
+from ingenico.connect.sdk.domain.payment.definitions.redirect_payment_method_specific_output import RedirectPaymentMethodSpecificOutput
+from ingenico.connect.sdk.domain.payment.definitions.sepa_direct_debit_payment_method_specific_output import SepaDirectDebitPaymentMethodSpecificOutput
+
+
+class PaymentOutput(OrderOutput):
+
+    __amount_paid = None
+    __amount_reversed = None
+    __bank_transfer_payment_method_specific_output = None
+    __card_payment_method_specific_output = None
+    __cash_payment_method_specific_output = None
+    __direct_debit_payment_method_specific_output = None
+    __e_invoice_payment_method_specific_output = None
+    __invoice_payment_method_specific_output = None
+    __mobile_payment_method_specific_output = None
+    __payment_method = None
+    __redirect_payment_method_specific_output = None
+    __reversal_reason = None
+    __sepa_direct_debit_payment_method_specific_output = None
+
+    @property
+    def amount_paid(self):
+        """
+        | Amount that has been paid
+        
+        Type: long
+        """
+        return self.__amount_paid
+
+    @amount_paid.setter
+    def amount_paid(self, value):
+        self.__amount_paid = value
+
+    @property
+    def amount_reversed(self):
+        """
+        | Amount that has been reversed
+        
+        Type: long
+        """
+        return self.__amount_reversed
+
+    @amount_reversed.setter
+    def amount_reversed(self, value):
+        self.__amount_reversed = value
+
+    @property
+    def bank_transfer_payment_method_specific_output(self):
+        """
+        | Object containing the bank transfer payment method details
+        
+        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.bank_transfer_payment_method_specific_output.BankTransferPaymentMethodSpecificOutput`
+        """
+        return self.__bank_transfer_payment_method_specific_output
+
+    @bank_transfer_payment_method_specific_output.setter
+    def bank_transfer_payment_method_specific_output(self, value):
+        self.__bank_transfer_payment_method_specific_output = value
+
+    @property
+    def card_payment_method_specific_output(self):
+        """
+        | Object containing the card payment method details
+        
+        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.card_payment_method_specific_output.CardPaymentMethodSpecificOutput`
+        """
+        return self.__card_payment_method_specific_output
+
+    @card_payment_method_specific_output.setter
+    def card_payment_method_specific_output(self, value):
+        self.__card_payment_method_specific_output = value
+
+    @property
+    def cash_payment_method_specific_output(self):
+        """
+        | Object containing the cash payment method details
+        
+        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.cash_payment_method_specific_output.CashPaymentMethodSpecificOutput`
+        """
+        return self.__cash_payment_method_specific_output
+
+    @cash_payment_method_specific_output.setter
+    def cash_payment_method_specific_output(self, value):
+        self.__cash_payment_method_specific_output = value
+
+    @property
+    def direct_debit_payment_method_specific_output(self):
+        """
+        | Object containing the non SEPA direct debit payment method details
+        
+        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.non_sepa_direct_debit_payment_method_specific_output.NonSepaDirectDebitPaymentMethodSpecificOutput`
+        """
+        return self.__direct_debit_payment_method_specific_output
+
+    @direct_debit_payment_method_specific_output.setter
+    def direct_debit_payment_method_specific_output(self, value):
+        self.__direct_debit_payment_method_specific_output = value
+
+    @property
+    def e_invoice_payment_method_specific_output(self):
+        """
+        | Object containing the e-invoice payment method details
+        
+        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.e_invoice_payment_method_specific_output.EInvoicePaymentMethodSpecificOutput`
+        """
+        return self.__e_invoice_payment_method_specific_output
+
+    @e_invoice_payment_method_specific_output.setter
+    def e_invoice_payment_method_specific_output(self, value):
+        self.__e_invoice_payment_method_specific_output = value
+
+    @property
+    def invoice_payment_method_specific_output(self):
+        """
+        | Object containing the invoice payment method details
+        
+        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.invoice_payment_method_specific_output.InvoicePaymentMethodSpecificOutput`
+        """
+        return self.__invoice_payment_method_specific_output
+
+    @invoice_payment_method_specific_output.setter
+    def invoice_payment_method_specific_output(self, value):
+        self.__invoice_payment_method_specific_output = value
+
+    @property
+    def mobile_payment_method_specific_output(self):
+        """
+        | Object containing the mobile payment method details
+        
+        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.mobile_payment_method_specific_output.MobilePaymentMethodSpecificOutput`
+        """
+        return self.__mobile_payment_method_specific_output
+
+    @mobile_payment_method_specific_output.setter
+    def mobile_payment_method_specific_output(self, value):
+        self.__mobile_payment_method_specific_output = value
+
+    @property
+    def payment_method(self):
+        """
+        | Payment method identifier used by the our payment engine with the following possible values:
+        
+        * bankRefund
+        * bankTransfer
+        * card
+        * cash
+        * directDebit
+        * eInvoice
+        * invoice
+        * redirect
+        
+        Type: str
+        """
+        return self.__payment_method
+
+    @payment_method.setter
+    def payment_method(self, value):
+        self.__payment_method = value
+
+    @property
+    def redirect_payment_method_specific_output(self):
+        """
+        | Object containing the redirect payment product details
+        
+        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.redirect_payment_method_specific_output.RedirectPaymentMethodSpecificOutput`
+        """
+        return self.__redirect_payment_method_specific_output
+
+    @redirect_payment_method_specific_output.setter
+    def redirect_payment_method_specific_output(self, value):
+        self.__redirect_payment_method_specific_output = value
+
+    @property
+    def reversal_reason(self):
+        """
+        | The reason description given for the reversedAmount property.
+        
+        Type: str
+        """
+        return self.__reversal_reason
+
+    @reversal_reason.setter
+    def reversal_reason(self, value):
+        self.__reversal_reason = value
+
+    @property
+    def sepa_direct_debit_payment_method_specific_output(self):
+        """
+        | Object containing the SEPA direct debit details
+        
+        Type: :class:`ingenico.connect.sdk.domain.payment.definitions.sepa_direct_debit_payment_method_specific_output.SepaDirectDebitPaymentMethodSpecificOutput`
+        """
+        return self.__sepa_direct_debit_payment_method_specific_output
+
+    @sepa_direct_debit_payment_method_specific_output.setter
+    def sepa_direct_debit_payment_method_specific_output(self, value):
+        self.__sepa_direct_debit_payment_method_specific_output = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentOutput, self).to_dictionary()
+        if self.amount_paid is not None:
+            dictionary['amountPaid'] = self.amount_paid
+        if self.amount_reversed is not None:
+            dictionary['amountReversed'] = self.amount_reversed
+        if self.bank_transfer_payment_method_specific_output is not None:
+            dictionary['bankTransferPaymentMethodSpecificOutput'] = self.bank_transfer_payment_method_specific_output.to_dictionary()
+        if self.card_payment_method_specific_output is not None:
+            dictionary['cardPaymentMethodSpecificOutput'] = self.card_payment_method_specific_output.to_dictionary()
+        if self.cash_payment_method_specific_output is not None:
+            dictionary['cashPaymentMethodSpecificOutput'] = self.cash_payment_method_specific_output.to_dictionary()
+        if self.direct_debit_payment_method_specific_output is not None:
+            dictionary['directDebitPaymentMethodSpecificOutput'] = self.direct_debit_payment_method_specific_output.to_dictionary()
+        if self.e_invoice_payment_method_specific_output is not None:
+            dictionary['eInvoicePaymentMethodSpecificOutput'] = self.e_invoice_payment_method_specific_output.to_dictionary()
+        if self.invoice_payment_method_specific_output is not None:
+            dictionary['invoicePaymentMethodSpecificOutput'] = self.invoice_payment_method_specific_output.to_dictionary()
+        if self.mobile_payment_method_specific_output is not None:
+            dictionary['mobilePaymentMethodSpecificOutput'] = self.mobile_payment_method_specific_output.to_dictionary()
+        if self.payment_method is not None:
+            dictionary['paymentMethod'] = self.payment_method
+        if self.redirect_payment_method_specific_output is not None:
+            dictionary['redirectPaymentMethodSpecificOutput'] = self.redirect_payment_method_specific_output.to_dictionary()
+        if self.reversal_reason is not None:
+            dictionary['reversalReason'] = self.reversal_reason
+        if self.sepa_direct_debit_payment_method_specific_output is not None:
+            dictionary['sepaDirectDebitPaymentMethodSpecificOutput'] = self.sepa_direct_debit_payment_method_specific_output.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentOutput, self).from_dictionary(dictionary)
+        if 'amountPaid' in dictionary:
+            self.amount_paid = dictionary['amountPaid']
+        if 'amountReversed' in dictionary:
+            self.amount_reversed = dictionary['amountReversed']
+        if 'bankTransferPaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['bankTransferPaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankTransferPaymentMethodSpecificOutput']))
+            value = BankTransferPaymentMethodSpecificOutput()
+            self.bank_transfer_payment_method_specific_output = value.from_dictionary(dictionary['bankTransferPaymentMethodSpecificOutput'])
+        if 'cardPaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['cardPaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardPaymentMethodSpecificOutput']))
+            value = CardPaymentMethodSpecificOutput()
+            self.card_payment_method_specific_output = value.from_dictionary(dictionary['cardPaymentMethodSpecificOutput'])
+        if 'cashPaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['cashPaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cashPaymentMethodSpecificOutput']))
+            value = CashPaymentMethodSpecificOutput()
+            self.cash_payment_method_specific_output = value.from_dictionary(dictionary['cashPaymentMethodSpecificOutput'])
+        if 'directDebitPaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['directDebitPaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['directDebitPaymentMethodSpecificOutput']))
+            value = NonSepaDirectDebitPaymentMethodSpecificOutput()
+            self.direct_debit_payment_method_specific_output = value.from_dictionary(dictionary['directDebitPaymentMethodSpecificOutput'])
+        if 'eInvoicePaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['eInvoicePaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['eInvoicePaymentMethodSpecificOutput']))
+            value = EInvoicePaymentMethodSpecificOutput()
+            self.e_invoice_payment_method_specific_output = value.from_dictionary(dictionary['eInvoicePaymentMethodSpecificOutput'])
+        if 'invoicePaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['invoicePaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['invoicePaymentMethodSpecificOutput']))
+            value = InvoicePaymentMethodSpecificOutput()
+            self.invoice_payment_method_specific_output = value.from_dictionary(dictionary['invoicePaymentMethodSpecificOutput'])
+        if 'mobilePaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['mobilePaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mobilePaymentMethodSpecificOutput']))
+            value = MobilePaymentMethodSpecificOutput()
+            self.mobile_payment_method_specific_output = value.from_dictionary(dictionary['mobilePaymentMethodSpecificOutput'])
+        if 'paymentMethod' in dictionary:
+            self.payment_method = dictionary['paymentMethod']
+        if 'redirectPaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['redirectPaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['redirectPaymentMethodSpecificOutput']))
+            value = RedirectPaymentMethodSpecificOutput()
+            self.redirect_payment_method_specific_output = value.from_dictionary(dictionary['redirectPaymentMethodSpecificOutput'])
+        if 'reversalReason' in dictionary:
+            self.reversal_reason = dictionary['reversalReason']
+        if 'sepaDirectDebitPaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['sepaDirectDebitPaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['sepaDirectDebitPaymentMethodSpecificOutput']))
+            value = SepaDirectDebitPaymentMethodSpecificOutput()
+            self.sepa_direct_debit_payment_method_specific_output = value.from_dictionary(dictionary['sepaDirectDebitPaymentMethodSpecificOutput'])
+        return self

connect-sdk-python2-3.47.0/ingenico/connect/sdk/domain/payment/definitions/payment_product3201_specific_output.py

@@ -0,0 +1,40 @@
+# -*- 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.definitions.card_essentials import CardEssentials
+
+
+class PaymentProduct3201SpecificOutput(DataObject):
+
+    __card = None
+
+    @property
+    def card(self):
+        """
+        | Object containing card details
+        
+        Type: :class:`ingenico.connect.sdk.domain.definitions.card_essentials.CardEssentials`
+        """
+        return self.__card
+
+    @card.setter
+    def card(self, value):
+        self.__card = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentProduct3201SpecificOutput, self).to_dictionary()
+        if self.card is not None:
+            dictionary['card'] = self.card.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentProduct3201SpecificOutput, self).from_dictionary(dictionary)
+        if 'card' in dictionary:
+            if not isinstance(dictionary['card'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['card']))
+            value = CardEssentials()
+            self.card = value.from_dictionary(dictionary['card'])
+        return self