connect-sdk-python2 4.0.0__zip → 4.1.0__zip

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/create_payment_request.py

@@ -0,0 +1,307 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.bank_transfer_payment_method_specific_input import BankTransferPaymentMethodSpecificInput
+from worldline.connect.sdk.v1.domain.card_payment_method_specific_input import CardPaymentMethodSpecificInput
+from worldline.connect.sdk.v1.domain.cash_payment_method_specific_input import CashPaymentMethodSpecificInput
+from worldline.connect.sdk.v1.domain.e_invoice_payment_method_specific_input import EInvoicePaymentMethodSpecificInput
+from worldline.connect.sdk.v1.domain.fraud_fields import FraudFields
+from worldline.connect.sdk.v1.domain.invoice_payment_method_specific_input import InvoicePaymentMethodSpecificInput
+from worldline.connect.sdk.v1.domain.merchant import Merchant
+from worldline.connect.sdk.v1.domain.mobile_payment_method_specific_input import MobilePaymentMethodSpecificInput
+from worldline.connect.sdk.v1.domain.non_sepa_direct_debit_payment_method_specific_input import NonSepaDirectDebitPaymentMethodSpecificInput
+from worldline.connect.sdk.v1.domain.order import Order
+from worldline.connect.sdk.v1.domain.redirect_payment_method_specific_input import RedirectPaymentMethodSpecificInput
+from worldline.connect.sdk.v1.domain.sepa_direct_debit_payment_method_specific_input import SepaDirectDebitPaymentMethodSpecificInput
+
+
+class CreatePaymentRequest(DataObject):
+
+    __bank_transfer_payment_method_specific_input = None
+    __card_payment_method_specific_input = None
+    __cash_payment_method_specific_input = None
+    __direct_debit_payment_method_specific_input = None
+    __e_invoice_payment_method_specific_input = None
+    __encrypted_customer_input = None
+    __fraud_fields = None
+    __invoice_payment_method_specific_input = None
+    __merchant = None
+    __mobile_payment_method_specific_input = None
+    __order = None
+    __redirect_payment_method_specific_input = None
+    __sepa_direct_debit_payment_method_specific_input = None
+
+    @property
+    def bank_transfer_payment_method_specific_input(self):
+        """
+        | Object containing the specific input details for bank transfer payments
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_transfer_payment_method_specific_input.BankTransferPaymentMethodSpecificInput`
+        """
+        return self.__bank_transfer_payment_method_specific_input
+
+    @bank_transfer_payment_method_specific_input.setter
+    def bank_transfer_payment_method_specific_input(self, value):
+        self.__bank_transfer_payment_method_specific_input = value
+
+    @property
+    def card_payment_method_specific_input(self):
+        """
+        | Object containing the specific input details for card payments
+
+        Type: :class:`worldline.connect.sdk.v1.domain.card_payment_method_specific_input.CardPaymentMethodSpecificInput`
+        """
+        return self.__card_payment_method_specific_input
+
+    @card_payment_method_specific_input.setter
+    def card_payment_method_specific_input(self, value):
+        self.__card_payment_method_specific_input = value
+
+    @property
+    def cash_payment_method_specific_input(self):
+        """
+        | Object containing the specific input details for cash payments
+
+        Type: :class:`worldline.connect.sdk.v1.domain.cash_payment_method_specific_input.CashPaymentMethodSpecificInput`
+        """
+        return self.__cash_payment_method_specific_input
+
+    @cash_payment_method_specific_input.setter
+    def cash_payment_method_specific_input(self, value):
+        self.__cash_payment_method_specific_input = value
+
+    @property
+    def direct_debit_payment_method_specific_input(self):
+        """
+        | Object containing the specific input details for direct debit payments
+
+        Type: :class:`worldline.connect.sdk.v1.domain.non_sepa_direct_debit_payment_method_specific_input.NonSepaDirectDebitPaymentMethodSpecificInput`
+        """
+        return self.__direct_debit_payment_method_specific_input
+
+    @direct_debit_payment_method_specific_input.setter
+    def direct_debit_payment_method_specific_input(self, value):
+        self.__direct_debit_payment_method_specific_input = value
+
+    @property
+    def e_invoice_payment_method_specific_input(self):
+        """
+        | Object containing the specific input details for e-invoice payments.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.e_invoice_payment_method_specific_input.EInvoicePaymentMethodSpecificInput`
+        """
+        return self.__e_invoice_payment_method_specific_input
+
+    @e_invoice_payment_method_specific_input.setter
+    def e_invoice_payment_method_specific_input(self, value):
+        self.__e_invoice_payment_method_specific_input = value
+
+    @property
+    def encrypted_customer_input(self):
+        """
+        | Data that was encrypted client side containing all customer entered data elements like card data.
+        | Note: Because this data can only be submitted once to our system and contains encrypted card data you should not store it. As the data was captured within the context of a client session you also need to submit it to us before the session has expired.
+
+        Type: str
+        """
+        return self.__encrypted_customer_input
+
+    @encrypted_customer_input.setter
+    def encrypted_customer_input(self, value):
+        self.__encrypted_customer_input = value
+
+    @property
+    def fraud_fields(self):
+        """
+        | Object containing additional data that will be used to assess the risk of fraud
+
+        Type: :class:`worldline.connect.sdk.v1.domain.fraud_fields.FraudFields`
+        """
+        return self.__fraud_fields
+
+    @fraud_fields.setter
+    def fraud_fields(self, value):
+        self.__fraud_fields = value
+
+    @property
+    def invoice_payment_method_specific_input(self):
+        """
+        | Object containing the specific input details for invoice payments
+
+        Type: :class:`worldline.connect.sdk.v1.domain.invoice_payment_method_specific_input.InvoicePaymentMethodSpecificInput`
+        """
+        return self.__invoice_payment_method_specific_input
+
+    @invoice_payment_method_specific_input.setter
+    def invoice_payment_method_specific_input(self, value):
+        self.__invoice_payment_method_specific_input = value
+
+    @property
+    def merchant(self):
+        """
+        | Object containing information on you, the merchant
+
+        Type: :class:`worldline.connect.sdk.v1.domain.merchant.Merchant`
+        """
+        return self.__merchant
+
+    @merchant.setter
+    def merchant(self, value):
+        self.__merchant = value
+
+    @property
+    def mobile_payment_method_specific_input(self):
+        """
+        | Object containing the specific input details for mobile payments.
+        
+        | Mobile payments produce the required payment data in encrypted form.
+        
+        * 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: :class:`worldline.connect.sdk.v1.domain.mobile_payment_method_specific_input.MobilePaymentMethodSpecificInput`
+        """
+        return self.__mobile_payment_method_specific_input
+
+    @mobile_payment_method_specific_input.setter
+    def mobile_payment_method_specific_input(self, value):
+        self.__mobile_payment_method_specific_input = value
+
+    @property
+    def order(self):
+        """
+        | Order object containing order related data
+        | Please note that this object is required to be able to submit the amount.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.order.Order`
+        """
+        return self.__order
+
+    @order.setter
+    def order(self, value):
+        self.__order = value
+
+    @property
+    def redirect_payment_method_specific_input(self):
+        """
+        | Object containing the specific input details for payments that involve redirects to 3rd parties to complete, like iDeal and PayPal
+
+        Type: :class:`worldline.connect.sdk.v1.domain.redirect_payment_method_specific_input.RedirectPaymentMethodSpecificInput`
+        """
+        return self.__redirect_payment_method_specific_input
+
+    @redirect_payment_method_specific_input.setter
+    def redirect_payment_method_specific_input(self, value):
+        self.__redirect_payment_method_specific_input = value
+
+    @property
+    def sepa_direct_debit_payment_method_specific_input(self):
+        """
+        | Object containing the specific input details for SEPA direct debit payments
+
+        Type: :class:`worldline.connect.sdk.v1.domain.sepa_direct_debit_payment_method_specific_input.SepaDirectDebitPaymentMethodSpecificInput`
+        """
+        return self.__sepa_direct_debit_payment_method_specific_input
+
+    @sepa_direct_debit_payment_method_specific_input.setter
+    def sepa_direct_debit_payment_method_specific_input(self, value):
+        self.__sepa_direct_debit_payment_method_specific_input = value
+
+    def to_dictionary(self):
+        dictionary = super(CreatePaymentRequest, self).to_dictionary()
+        if self.bank_transfer_payment_method_specific_input is not None:
+            dictionary['bankTransferPaymentMethodSpecificInput'] = self.bank_transfer_payment_method_specific_input.to_dictionary()
+        if self.card_payment_method_specific_input is not None:
+            dictionary['cardPaymentMethodSpecificInput'] = self.card_payment_method_specific_input.to_dictionary()
+        if self.cash_payment_method_specific_input is not None:
+            dictionary['cashPaymentMethodSpecificInput'] = self.cash_payment_method_specific_input.to_dictionary()
+        if self.direct_debit_payment_method_specific_input is not None:
+            dictionary['directDebitPaymentMethodSpecificInput'] = self.direct_debit_payment_method_specific_input.to_dictionary()
+        if self.e_invoice_payment_method_specific_input is not None:
+            dictionary['eInvoicePaymentMethodSpecificInput'] = self.e_invoice_payment_method_specific_input.to_dictionary()
+        if self.encrypted_customer_input is not None:
+            dictionary['encryptedCustomerInput'] = self.encrypted_customer_input
+        if self.fraud_fields is not None:
+            dictionary['fraudFields'] = self.fraud_fields.to_dictionary()
+        if self.invoice_payment_method_specific_input is not None:
+            dictionary['invoicePaymentMethodSpecificInput'] = self.invoice_payment_method_specific_input.to_dictionary()
+        if self.merchant is not None:
+            dictionary['merchant'] = self.merchant.to_dictionary()
+        if self.mobile_payment_method_specific_input is not None:
+            dictionary['mobilePaymentMethodSpecificInput'] = self.mobile_payment_method_specific_input.to_dictionary()
+        if self.order is not None:
+            dictionary['order'] = self.order.to_dictionary()
+        if self.redirect_payment_method_specific_input is not None:
+            dictionary['redirectPaymentMethodSpecificInput'] = self.redirect_payment_method_specific_input.to_dictionary()
+        if self.sepa_direct_debit_payment_method_specific_input is not None:
+            dictionary['sepaDirectDebitPaymentMethodSpecificInput'] = self.sepa_direct_debit_payment_method_specific_input.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(CreatePaymentRequest, self).from_dictionary(dictionary)
+        if 'bankTransferPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['bankTransferPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankTransferPaymentMethodSpecificInput']))
+            value = BankTransferPaymentMethodSpecificInput()
+            self.bank_transfer_payment_method_specific_input = value.from_dictionary(dictionary['bankTransferPaymentMethodSpecificInput'])
+        if 'cardPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['cardPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardPaymentMethodSpecificInput']))
+            value = CardPaymentMethodSpecificInput()
+            self.card_payment_method_specific_input = value.from_dictionary(dictionary['cardPaymentMethodSpecificInput'])
+        if 'cashPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['cashPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cashPaymentMethodSpecificInput']))
+            value = CashPaymentMethodSpecificInput()
+            self.cash_payment_method_specific_input = value.from_dictionary(dictionary['cashPaymentMethodSpecificInput'])
+        if 'directDebitPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['directDebitPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['directDebitPaymentMethodSpecificInput']))
+            value = NonSepaDirectDebitPaymentMethodSpecificInput()
+            self.direct_debit_payment_method_specific_input = value.from_dictionary(dictionary['directDebitPaymentMethodSpecificInput'])
+        if 'eInvoicePaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['eInvoicePaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['eInvoicePaymentMethodSpecificInput']))
+            value = EInvoicePaymentMethodSpecificInput()
+            self.e_invoice_payment_method_specific_input = value.from_dictionary(dictionary['eInvoicePaymentMethodSpecificInput'])
+        if 'encryptedCustomerInput' in dictionary:
+            self.encrypted_customer_input = dictionary['encryptedCustomerInput']
+        if 'fraudFields' in dictionary:
+            if not isinstance(dictionary['fraudFields'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['fraudFields']))
+            value = FraudFields()
+            self.fraud_fields = value.from_dictionary(dictionary['fraudFields'])
+        if 'invoicePaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['invoicePaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['invoicePaymentMethodSpecificInput']))
+            value = InvoicePaymentMethodSpecificInput()
+            self.invoice_payment_method_specific_input = value.from_dictionary(dictionary['invoicePaymentMethodSpecificInput'])
+        if 'merchant' in dictionary:
+            if not isinstance(dictionary['merchant'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['merchant']))
+            value = Merchant()
+            self.merchant = value.from_dictionary(dictionary['merchant'])
+        if 'mobilePaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['mobilePaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mobilePaymentMethodSpecificInput']))
+            value = MobilePaymentMethodSpecificInput()
+            self.mobile_payment_method_specific_input = value.from_dictionary(dictionary['mobilePaymentMethodSpecificInput'])
+        if 'order' in dictionary:
+            if not isinstance(dictionary['order'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['order']))
+            value = Order()
+            self.order = value.from_dictionary(dictionary['order'])
+        if 'redirectPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['redirectPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['redirectPaymentMethodSpecificInput']))
+            value = RedirectPaymentMethodSpecificInput()
+            self.redirect_payment_method_specific_input = value.from_dictionary(dictionary['redirectPaymentMethodSpecificInput'])
+        if 'sepaDirectDebitPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['sepaDirectDebitPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['sepaDirectDebitPaymentMethodSpecificInput']))
+            value = SepaDirectDebitPaymentMethodSpecificInput()
+            self.sepa_direct_debit_payment_method_specific_input = value.from_dictionary(dictionary['sepaDirectDebitPaymentMethodSpecificInput'])
+        return self

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/create_payment_result.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.merchant_action import MerchantAction
+from worldline.connect.sdk.v1.domain.payment import Payment
+from worldline.connect.sdk.v1.domain.payment_creation_output import PaymentCreationOutput
+
+
+class CreatePaymentResult(DataObject):
+
+    __creation_output = None
+    __merchant_action = None
+    __payment = None
+
+    @property
+    def creation_output(self):
+        """
+        | Object containing the details of the created payment
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment_creation_output.PaymentCreationOutput`
+        """
+        return self.__creation_output
+
+    @creation_output.setter
+    def creation_output(self, value):
+        self.__creation_output = value
+
+    @property
+    def merchant_action(self):
+        """
+        | Object that contains the action, including the needed data, that you should perform next, like showing instruction, showing the transaction results or redirect to a third party to complete the payment
+
+        Type: :class:`worldline.connect.sdk.v1.domain.merchant_action.MerchantAction`
+        """
+        return self.__merchant_action
+
+    @merchant_action.setter
+    def merchant_action(self, value):
+        self.__merchant_action = value
+
+    @property
+    def payment(self):
+        """
+        | Object that holds the payment related properties
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment.Payment`
+        """
+        return self.__payment
+
+    @payment.setter
+    def payment(self, value):
+        self.__payment = value
+
+    def to_dictionary(self):
+        dictionary = super(CreatePaymentResult, self).to_dictionary()
+        if self.creation_output is not None:
+            dictionary['creationOutput'] = self.creation_output.to_dictionary()
+        if self.merchant_action is not None:
+            dictionary['merchantAction'] = self.merchant_action.to_dictionary()
+        if self.payment is not None:
+            dictionary['payment'] = self.payment.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(CreatePaymentResult, self).from_dictionary(dictionary)
+        if 'creationOutput' in dictionary:
+            if not isinstance(dictionary['creationOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['creationOutput']))
+            value = PaymentCreationOutput()
+            self.creation_output = value.from_dictionary(dictionary['creationOutput'])
+        if 'merchantAction' in dictionary:
+            if not isinstance(dictionary['merchantAction'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['merchantAction']))
+            value = MerchantAction()
+            self.merchant_action = value.from_dictionary(dictionary['merchantAction'])
+        if 'payment' in dictionary:
+            if not isinstance(dictionary['payment'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payment']))
+            value = Payment()
+            self.payment = value.from_dictionary(dictionary['payment'])
+        return self

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/create_payout_request.py

@@ -0,0 +1,287 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.amount_of_money import AmountOfMoney
+from worldline.connect.sdk.v1.domain.bank_account_bban import BankAccountBban
+from worldline.connect.sdk.v1.domain.bank_account_iban import BankAccountIban
+from worldline.connect.sdk.v1.domain.bank_transfer_payout_method_specific_input import BankTransferPayoutMethodSpecificInput
+from worldline.connect.sdk.v1.domain.card_payout_method_specific_input import CardPayoutMethodSpecificInput
+from worldline.connect.sdk.v1.domain.payout_customer import PayoutCustomer
+from worldline.connect.sdk.v1.domain.payout_details import PayoutDetails
+from worldline.connect.sdk.v1.domain.payout_merchant import PayoutMerchant
+from worldline.connect.sdk.v1.domain.payout_references import PayoutReferences
+
+
+class CreatePayoutRequest(DataObject):
+
+    __amount_of_money = None
+    __bank_account_bban = None
+    __bank_account_iban = None
+    __bank_transfer_payout_method_specific_input = None
+    __card_payout_method_specific_input = None
+    __customer = None
+    __merchant = None
+    __payout_date = None
+    __payout_details = None
+    __payout_text = None
+    __references = None
+    __swift_code = None
+
+    @property
+    def amount_of_money(self):
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`worldline.connect.sdk.v1.domain.amount_of_money.AmountOfMoney`
+
+        Deprecated; Moved to PayoutDetails
+        """
+        return self.__amount_of_money
+
+    @amount_of_money.setter
+    def amount_of_money(self, value):
+        self.__amount_of_money = value
+
+    @property
+    def bank_account_bban(self):
+        """
+        | Object containing account holder name and bank account information. This property can only be used for payouts in the UK.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_account_bban.BankAccountBban`
+
+        Deprecated; Moved to BankTransferPayoutMethodSpecificInput
+        """
+        return self.__bank_account_bban
+
+    @bank_account_bban.setter
+    def bank_account_bban(self, value):
+        self.__bank_account_bban = value
+
+    @property
+    def bank_account_iban(self):
+        """
+        | Object containing account holder and IBAN information.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_account_iban.BankAccountIban`
+
+        Deprecated; Moved to BankTransferPayoutMethodSpecificInput
+        """
+        return self.__bank_account_iban
+
+    @bank_account_iban.setter
+    def bank_account_iban(self, value):
+        self.__bank_account_iban = value
+
+    @property
+    def bank_transfer_payout_method_specific_input(self):
+        """
+        | Object containing the specific input details for bank transfer payouts.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_transfer_payout_method_specific_input.BankTransferPayoutMethodSpecificInput`
+        """
+        return self.__bank_transfer_payout_method_specific_input
+
+    @bank_transfer_payout_method_specific_input.setter
+    def bank_transfer_payout_method_specific_input(self, value):
+        self.__bank_transfer_payout_method_specific_input = value
+
+    @property
+    def card_payout_method_specific_input(self):
+        """
+        | Object containing the specific input details for card payouts.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.card_payout_method_specific_input.CardPayoutMethodSpecificInput`
+        """
+        return self.__card_payout_method_specific_input
+
+    @card_payout_method_specific_input.setter
+    def card_payout_method_specific_input(self, value):
+        self.__card_payout_method_specific_input = value
+
+    @property
+    def customer(self):
+        """
+        | Object containing the details of the customer.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payout_customer.PayoutCustomer`
+
+        Deprecated; Moved to PayoutDetails
+        """
+        return self.__customer
+
+    @customer.setter
+    def customer(self, value):
+        self.__customer = value
+
+    @property
+    def merchant(self):
+        """
+        | Object containing information on you, the merchant
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payout_merchant.PayoutMerchant`
+        """
+        return self.__merchant
+
+    @merchant.setter
+    def merchant(self, value):
+        self.__merchant = value
+
+    @property
+    def payout_date(self):
+        """
+        | Date of the payout sent to the bank by us
+        | Format: YYYYMMDD
+
+        Type: str
+
+        Deprecated; Moved to BankTransferPayoutMethodSpecificInput
+        """
+        return self.__payout_date
+
+    @payout_date.setter
+    def payout_date(self, value):
+        self.__payout_date = value
+
+    @property
+    def payout_details(self):
+        """
+        | Object containing the details for Create Payout Request
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payout_details.PayoutDetails`
+        """
+        return self.__payout_details
+
+    @payout_details.setter
+    def payout_details(self, value):
+        self.__payout_details = value
+
+    @property
+    def payout_text(self):
+        """
+        | Text to be printed on the bank account statement of the beneficiary. The maximum allowed length might differ per country. The data will be automatically truncated to the maximum allowed length.
+
+        Type: str
+
+        Deprecated; Moved to BankTransferPayoutMethodSpecificInput
+        """
+        return self.__payout_text
+
+    @payout_text.setter
+    def payout_text(self, value):
+        self.__payout_text = value
+
+    @property
+    def references(self):
+        """
+        | Object that holds all reference properties that are linked to this transaction
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payout_references.PayoutReferences`
+
+        Deprecated; Moved to PayoutDetails
+        """
+        return self.__references
+
+    @references.setter
+    def references(self, value):
+        self.__references = value
+
+    @property
+    def swift_code(self):
+        """
+        | The BIC is the Business Identifier Code, also known as SWIFT or Bank Identifier code. It is a code with an internationally agreed format to Identify a specific bank. The BIC contains 8 or 11 positions: the first 4 contain the bank code, followed by the country code and location code.
+
+        Type: str
+
+        Deprecated; Moved to BankTransferPayoutMethodSpecificInput
+        """
+        return self.__swift_code
+
+    @swift_code.setter
+    def swift_code(self, value):
+        self.__swift_code = value
+
+    def to_dictionary(self):
+        dictionary = super(CreatePayoutRequest, self).to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.bank_account_bban is not None:
+            dictionary['bankAccountBban'] = self.bank_account_bban.to_dictionary()
+        if self.bank_account_iban is not None:
+            dictionary['bankAccountIban'] = self.bank_account_iban.to_dictionary()
+        if self.bank_transfer_payout_method_specific_input is not None:
+            dictionary['bankTransferPayoutMethodSpecificInput'] = self.bank_transfer_payout_method_specific_input.to_dictionary()
+        if self.card_payout_method_specific_input is not None:
+            dictionary['cardPayoutMethodSpecificInput'] = self.card_payout_method_specific_input.to_dictionary()
+        if self.customer is not None:
+            dictionary['customer'] = self.customer.to_dictionary()
+        if self.merchant is not None:
+            dictionary['merchant'] = self.merchant.to_dictionary()
+        if self.payout_date is not None:
+            dictionary['payoutDate'] = self.payout_date
+        if self.payout_details is not None:
+            dictionary['payoutDetails'] = self.payout_details.to_dictionary()
+        if self.payout_text is not None:
+            dictionary['payoutText'] = self.payout_text
+        if self.references is not None:
+            dictionary['references'] = self.references.to_dictionary()
+        if self.swift_code is not None:
+            dictionary['swiftCode'] = self.swift_code
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(CreatePayoutRequest, self).from_dictionary(dictionary)
+        if 'amountOfMoney' in dictionary:
+            if not isinstance(dictionary['amountOfMoney'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['amountOfMoney']))
+            value = AmountOfMoney()
+            self.amount_of_money = value.from_dictionary(dictionary['amountOfMoney'])
+        if 'bankAccountBban' in dictionary:
+            if not isinstance(dictionary['bankAccountBban'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankAccountBban']))
+            value = BankAccountBban()
+            self.bank_account_bban = value.from_dictionary(dictionary['bankAccountBban'])
+        if 'bankAccountIban' in dictionary:
+            if not isinstance(dictionary['bankAccountIban'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankAccountIban']))
+            value = BankAccountIban()
+            self.bank_account_iban = value.from_dictionary(dictionary['bankAccountIban'])
+        if 'bankTransferPayoutMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['bankTransferPayoutMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankTransferPayoutMethodSpecificInput']))
+            value = BankTransferPayoutMethodSpecificInput()
+            self.bank_transfer_payout_method_specific_input = value.from_dictionary(dictionary['bankTransferPayoutMethodSpecificInput'])
+        if 'cardPayoutMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['cardPayoutMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardPayoutMethodSpecificInput']))
+            value = CardPayoutMethodSpecificInput()
+            self.card_payout_method_specific_input = value.from_dictionary(dictionary['cardPayoutMethodSpecificInput'])
+        if 'customer' in dictionary:
+            if not isinstance(dictionary['customer'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customer']))
+            value = PayoutCustomer()
+            self.customer = value.from_dictionary(dictionary['customer'])
+        if 'merchant' in dictionary:
+            if not isinstance(dictionary['merchant'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['merchant']))
+            value = PayoutMerchant()
+            self.merchant = value.from_dictionary(dictionary['merchant'])
+        if 'payoutDate' in dictionary:
+            self.payout_date = dictionary['payoutDate']
+        if 'payoutDetails' in dictionary:
+            if not isinstance(dictionary['payoutDetails'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payoutDetails']))
+            value = PayoutDetails()
+            self.payout_details = value.from_dictionary(dictionary['payoutDetails'])
+        if 'payoutText' in dictionary:
+            self.payout_text = dictionary['payoutText']
+        if 'references' in dictionary:
+            if not isinstance(dictionary['references'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['references']))
+            value = PayoutReferences()
+            self.references = value.from_dictionary(dictionary['references'])
+        if 'swiftCode' in dictionary:
+            self.swift_code = dictionary['swiftCode']
+        return self