connect-sdk-python3 4.0.0__zip → 4.0.1__zip

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

@@ -1,42 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.v1.domain.refund_method_specific_output import RefundMethodSpecificOutput
-from worldline.connect.sdk.v1.domain.refund_payment_product840_specific_output import RefundPaymentProduct840SpecificOutput
-
-
-class RefundEWalletMethodSpecificOutput(RefundMethodSpecificOutput):
-
-    __payment_product840_specific_output: Optional[RefundPaymentProduct840SpecificOutput] = None
-
-    @property
-    def payment_product840_specific_output(self) -> Optional[RefundPaymentProduct840SpecificOutput]:
-        """
-        | PayPal (payment product 840) specific details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.refund_payment_product840_specific_output.RefundPaymentProduct840SpecificOutput`
-        """
-        return self.__payment_product840_specific_output
-
-    @payment_product840_specific_output.setter
-    def payment_product840_specific_output(self, value: Optional[RefundPaymentProduct840SpecificOutput]) -> None:
-        self.__payment_product840_specific_output = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RefundEWalletMethodSpecificOutput, self).to_dictionary()
-        if self.payment_product840_specific_output is not None:
-            dictionary['paymentProduct840SpecificOutput'] = self.payment_product840_specific_output.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RefundEWalletMethodSpecificOutput':
-        super(RefundEWalletMethodSpecificOutput, self).from_dictionary(dictionary)
-        if 'paymentProduct840SpecificOutput' in dictionary:
-            if not isinstance(dictionary['paymentProduct840SpecificOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct840SpecificOutput']))
-            value = RefundPaymentProduct840SpecificOutput()
-            self.payment_product840_specific_output = value.from_dictionary(dictionary['paymentProduct840SpecificOutput'])
-        return self

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

@@ -1,87 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import List, Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.api_error import APIError
-from worldline.connect.sdk.v1.domain.refund_result import RefundResult
-
-
-class RefundErrorResponse(DataObject):
-
-    __error_id: Optional[str] = None
-    __errors: Optional[List[APIError]] = None
-    __refund_result: Optional[RefundResult] = None
-
-    @property
-    def error_id(self) -> Optional[str]:
-        """
-        | Unique reference, for debugging purposes, of this error response
-        
-        Type: str
-        """
-        return self.__error_id
-
-    @error_id.setter
-    def error_id(self, value: Optional[str]) -> None:
-        self.__error_id = value
-
-    @property
-    def errors(self) -> Optional[List[APIError]]:
-        """
-        | List of one or more errors
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.api_error.APIError`]
-        """
-        return self.__errors
-
-    @errors.setter
-    def errors(self, value: Optional[List[APIError]]) -> None:
-        self.__errors = value
-
-    @property
-    def refund_result(self) -> Optional[RefundResult]:
-        """
-        | Object that contains details on the created refund in case one has been created
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.refund_result.RefundResult`
-        """
-        return self.__refund_result
-
-    @refund_result.setter
-    def refund_result(self, value: Optional[RefundResult]) -> None:
-        self.__refund_result = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RefundErrorResponse, self).to_dictionary()
-        if self.error_id is not None:
-            dictionary['errorId'] = self.error_id
-        if self.errors is not None:
-            dictionary['errors'] = []
-            for element in self.errors:
-                if element is not None:
-                    dictionary['errors'].append(element.to_dictionary())
-        if self.refund_result is not None:
-            dictionary['refundResult'] = self.refund_result.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RefundErrorResponse':
-        super(RefundErrorResponse, self).from_dictionary(dictionary)
-        if 'errorId' in dictionary:
-            self.error_id = dictionary['errorId']
-        if 'errors' in dictionary:
-            if not isinstance(dictionary['errors'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['errors']))
-            self.errors = []
-            for element in dictionary['errors']:
-                value = APIError()
-                self.errors.append(value.from_dictionary(element))
-        if 'refundResult' in dictionary:
-            if not isinstance(dictionary['refundResult'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['refundResult']))
-            value = RefundResult()
-            self.refund_result = value.from_dictionary(dictionary['refundResult'])
-        return self

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

@@ -1,73 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class RefundMethodSpecificOutput(DataObject):
-
-    __refund_product_id: Optional[int] = None
-    __total_amount_paid: Optional[int] = None
-    __total_amount_refunded: Optional[int] = None
-
-    @property
-    def refund_product_id(self) -> Optional[int]:
-        """
-        | Refund product identifier
-        | Please see refund products <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/refundproducts.html> for a full overview of possible values.
-        
-        Type: int
-        """
-        return self.__refund_product_id
-
-    @refund_product_id.setter
-    def refund_product_id(self, value: Optional[int]) -> None:
-        self.__refund_product_id = value
-
-    @property
-    def total_amount_paid(self) -> Optional[int]:
-        """
-        | Total paid amount (in cents and always with 2 decimals)
-        
-        Type: int
-        """
-        return self.__total_amount_paid
-
-    @total_amount_paid.setter
-    def total_amount_paid(self, value: Optional[int]) -> None:
-        self.__total_amount_paid = value
-
-    @property
-    def total_amount_refunded(self) -> Optional[int]:
-        """
-        Type: int
-        """
-        return self.__total_amount_refunded
-
-    @total_amount_refunded.setter
-    def total_amount_refunded(self, value: Optional[int]) -> None:
-        self.__total_amount_refunded = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RefundMethodSpecificOutput, self).to_dictionary()
-        if self.refund_product_id is not None:
-            dictionary['refundProductId'] = self.refund_product_id
-        if self.total_amount_paid is not None:
-            dictionary['totalAmountPaid'] = self.total_amount_paid
-        if self.total_amount_refunded is not None:
-            dictionary['totalAmountRefunded'] = self.total_amount_refunded
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RefundMethodSpecificOutput':
-        super(RefundMethodSpecificOutput, self).from_dictionary(dictionary)
-        if 'refundProductId' in dictionary:
-            self.refund_product_id = dictionary['refundProductId']
-        if 'totalAmountPaid' in dictionary:
-            self.total_amount_paid = dictionary['totalAmountPaid']
-        if 'totalAmountRefunded' in dictionary:
-            self.total_amount_refunded = dictionary['totalAmountRefunded']
-        return self

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

@@ -1,38 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.v1.domain.refund_method_specific_output import RefundMethodSpecificOutput
-
-
-class RefundMobileMethodSpecificOutput(RefundMethodSpecificOutput):
-
-    __network: Optional[str] = None
-
-    @property
-    def network(self) -> Optional[str]:
-        """
-        | The network that was used for the refund. The string that represents the network is identical to the strings that the payment product vendors use in their documentation.For instance: "Visa" for Google Pay <https://developer.apple.com/reference/passkit/pkpaymentnetwork>.
-        
-        Type: str
-        """
-        return self.__network
-
-    @network.setter
-    def network(self, value: Optional[str]) -> None:
-        self.__network = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RefundMobileMethodSpecificOutput, self).to_dictionary()
-        if self.network is not None:
-            dictionary['network'] = self.network
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RefundMobileMethodSpecificOutput':
-        super(RefundMobileMethodSpecificOutput, self).from_dictionary(dictionary)
-        if 'network' in dictionary:
-            self.network = dictionary['network']
-        return self

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

@@ -1,197 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.v1.domain.order_output import OrderOutput
-from worldline.connect.sdk.v1.domain.refund_bank_method_specific_output import RefundBankMethodSpecificOutput
-from worldline.connect.sdk.v1.domain.refund_card_method_specific_output import RefundCardMethodSpecificOutput
-from worldline.connect.sdk.v1.domain.refund_cash_method_specific_output import RefundCashMethodSpecificOutput
-from worldline.connect.sdk.v1.domain.refund_e_invoice_method_specific_output import RefundEInvoiceMethodSpecificOutput
-from worldline.connect.sdk.v1.domain.refund_e_wallet_method_specific_output import RefundEWalletMethodSpecificOutput
-from worldline.connect.sdk.v1.domain.refund_mobile_method_specific_output import RefundMobileMethodSpecificOutput
-
-
-class RefundOutput(OrderOutput):
-
-    __amount_paid: Optional[int] = None
-    __bank_refund_method_specific_output: Optional[RefundBankMethodSpecificOutput] = None
-    __card_refund_method_specific_output: Optional[RefundCardMethodSpecificOutput] = None
-    __cash_refund_method_specific_output: Optional[RefundCashMethodSpecificOutput] = None
-    __e_invoice_refund_method_specific_output: Optional[RefundEInvoiceMethodSpecificOutput] = None
-    __e_wallet_refund_method_specific_output: Optional[RefundEWalletMethodSpecificOutput] = None
-    __mobile_refund_method_specific_output: Optional[RefundMobileMethodSpecificOutput] = None
-    __payment_method: Optional[str] = None
-
-    @property
-    def amount_paid(self) -> Optional[int]:
-        """
-        | Amount paid
-        
-        Type: int
-        """
-        return self.__amount_paid
-
-    @amount_paid.setter
-    def amount_paid(self, value: Optional[int]) -> None:
-        self.__amount_paid = value
-
-    @property
-    def bank_refund_method_specific_output(self) -> Optional[RefundBankMethodSpecificOutput]:
-        """
-        | Object containing specific bank refund details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.refund_bank_method_specific_output.RefundBankMethodSpecificOutput`
-        """
-        return self.__bank_refund_method_specific_output
-
-    @bank_refund_method_specific_output.setter
-    def bank_refund_method_specific_output(self, value: Optional[RefundBankMethodSpecificOutput]) -> None:
-        self.__bank_refund_method_specific_output = value
-
-    @property
-    def card_refund_method_specific_output(self) -> Optional[RefundCardMethodSpecificOutput]:
-        """
-        | Object containing specific card refund details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.refund_card_method_specific_output.RefundCardMethodSpecificOutput`
-        """
-        return self.__card_refund_method_specific_output
-
-    @card_refund_method_specific_output.setter
-    def card_refund_method_specific_output(self, value: Optional[RefundCardMethodSpecificOutput]) -> None:
-        self.__card_refund_method_specific_output = value
-
-    @property
-    def cash_refund_method_specific_output(self) -> Optional[RefundCashMethodSpecificOutput]:
-        """
-        | Object containing specific cash refund details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.refund_cash_method_specific_output.RefundCashMethodSpecificOutput`
-        """
-        return self.__cash_refund_method_specific_output
-
-    @cash_refund_method_specific_output.setter
-    def cash_refund_method_specific_output(self, value: Optional[RefundCashMethodSpecificOutput]) -> None:
-        self.__cash_refund_method_specific_output = value
-
-    @property
-    def e_invoice_refund_method_specific_output(self) -> Optional[RefundEInvoiceMethodSpecificOutput]:
-        """
-        | Object containing specific e-invoice refund details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.refund_e_invoice_method_specific_output.RefundEInvoiceMethodSpecificOutput`
-        """
-        return self.__e_invoice_refund_method_specific_output
-
-    @e_invoice_refund_method_specific_output.setter
-    def e_invoice_refund_method_specific_output(self, value: Optional[RefundEInvoiceMethodSpecificOutput]) -> None:
-        self.__e_invoice_refund_method_specific_output = value
-
-    @property
-    def e_wallet_refund_method_specific_output(self) -> Optional[RefundEWalletMethodSpecificOutput]:
-        """
-        | Object containing specific eWallet refund details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.refund_e_wallet_method_specific_output.RefundEWalletMethodSpecificOutput`
-        """
-        return self.__e_wallet_refund_method_specific_output
-
-    @e_wallet_refund_method_specific_output.setter
-    def e_wallet_refund_method_specific_output(self, value: Optional[RefundEWalletMethodSpecificOutput]) -> None:
-        self.__e_wallet_refund_method_specific_output = value
-
-    @property
-    def mobile_refund_method_specific_output(self) -> Optional[RefundMobileMethodSpecificOutput]:
-        """
-        | Object containing specific mobile refund details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.refund_mobile_method_specific_output.RefundMobileMethodSpecificOutput`
-        """
-        return self.__mobile_refund_method_specific_output
-
-    @mobile_refund_method_specific_output.setter
-    def mobile_refund_method_specific_output(self, value: Optional[RefundMobileMethodSpecificOutput]) -> None:
-        self.__mobile_refund_method_specific_output = value
-
-    @property
-    def payment_method(self) -> Optional[str]:
-        """
-        | 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: Optional[str]) -> None:
-        self.__payment_method = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RefundOutput, self).to_dictionary()
-        if self.amount_paid is not None:
-            dictionary['amountPaid'] = self.amount_paid
-        if self.bank_refund_method_specific_output is not None:
-            dictionary['bankRefundMethodSpecificOutput'] = self.bank_refund_method_specific_output.to_dictionary()
-        if self.card_refund_method_specific_output is not None:
-            dictionary['cardRefundMethodSpecificOutput'] = self.card_refund_method_specific_output.to_dictionary()
-        if self.cash_refund_method_specific_output is not None:
-            dictionary['cashRefundMethodSpecificOutput'] = self.cash_refund_method_specific_output.to_dictionary()
-        if self.e_invoice_refund_method_specific_output is not None:
-            dictionary['eInvoiceRefundMethodSpecificOutput'] = self.e_invoice_refund_method_specific_output.to_dictionary()
-        if self.e_wallet_refund_method_specific_output is not None:
-            dictionary['eWalletRefundMethodSpecificOutput'] = self.e_wallet_refund_method_specific_output.to_dictionary()
-        if self.mobile_refund_method_specific_output is not None:
-            dictionary['mobileRefundMethodSpecificOutput'] = self.mobile_refund_method_specific_output.to_dictionary()
-        if self.payment_method is not None:
-            dictionary['paymentMethod'] = self.payment_method
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RefundOutput':
-        super(RefundOutput, self).from_dictionary(dictionary)
-        if 'amountPaid' in dictionary:
-            self.amount_paid = dictionary['amountPaid']
-        if 'bankRefundMethodSpecificOutput' in dictionary:
-            if not isinstance(dictionary['bankRefundMethodSpecificOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankRefundMethodSpecificOutput']))
-            value = RefundBankMethodSpecificOutput()
-            self.bank_refund_method_specific_output = value.from_dictionary(dictionary['bankRefundMethodSpecificOutput'])
-        if 'cardRefundMethodSpecificOutput' in dictionary:
-            if not isinstance(dictionary['cardRefundMethodSpecificOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardRefundMethodSpecificOutput']))
-            value = RefundCardMethodSpecificOutput()
-            self.card_refund_method_specific_output = value.from_dictionary(dictionary['cardRefundMethodSpecificOutput'])
-        if 'cashRefundMethodSpecificOutput' in dictionary:
-            if not isinstance(dictionary['cashRefundMethodSpecificOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cashRefundMethodSpecificOutput']))
-            value = RefundCashMethodSpecificOutput()
-            self.cash_refund_method_specific_output = value.from_dictionary(dictionary['cashRefundMethodSpecificOutput'])
-        if 'eInvoiceRefundMethodSpecificOutput' in dictionary:
-            if not isinstance(dictionary['eInvoiceRefundMethodSpecificOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['eInvoiceRefundMethodSpecificOutput']))
-            value = RefundEInvoiceMethodSpecificOutput()
-            self.e_invoice_refund_method_specific_output = value.from_dictionary(dictionary['eInvoiceRefundMethodSpecificOutput'])
-        if 'eWalletRefundMethodSpecificOutput' in dictionary:
-            if not isinstance(dictionary['eWalletRefundMethodSpecificOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['eWalletRefundMethodSpecificOutput']))
-            value = RefundEWalletMethodSpecificOutput()
-            self.e_wallet_refund_method_specific_output = value.from_dictionary(dictionary['eWalletRefundMethodSpecificOutput'])
-        if 'mobileRefundMethodSpecificOutput' in dictionary:
-            if not isinstance(dictionary['mobileRefundMethodSpecificOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mobileRefundMethodSpecificOutput']))
-            value = RefundMobileMethodSpecificOutput()
-            self.mobile_refund_method_specific_output = value.from_dictionary(dictionary['mobileRefundMethodSpecificOutput'])
-        if 'paymentMethod' in dictionary:
-            self.payment_method = dictionary['paymentMethod']
-        return self

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

@@ -1,86 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class RefundPaymentProduct840CustomerAccount(DataObject):
-    """
-    | PayPal account details
-    """
-
-    __customer_account_status: Optional[str] = None
-    __customer_address_status: Optional[str] = None
-    __payer_id: Optional[str] = None
-
-    @property
-    def customer_account_status(self) -> Optional[str]:
-        """
-        | Status of the PayPal account.
-        | Possible values are:
-        
-        * verified - PayPal has verified the funding means for this account
-        * unverified - PayPal has not verified the funding means for this account
-        
-        Type: str
-        """
-        return self.__customer_account_status
-
-    @customer_account_status.setter
-    def customer_account_status(self, value: Optional[str]) -> None:
-        self.__customer_account_status = value
-
-    @property
-    def customer_address_status(self) -> Optional[str]:
-        """
-        | Status of the customer's shipping address as registered by PayPal
-        | Possible values are:
-        
-        * none - Status is unknown at PayPal
-        * confirmed - The address has been confirmed
-        * unconfirmed - The address has not been confirmed
-        
-        Type: str
-        """
-        return self.__customer_address_status
-
-    @customer_address_status.setter
-    def customer_address_status(self, value: Optional[str]) -> None:
-        self.__customer_address_status = value
-
-    @property
-    def payer_id(self) -> Optional[str]:
-        """
-        | The unique identifier of a PayPal account and will never change in the life cycle of a PayPal account
-        
-        Type: str
-        """
-        return self.__payer_id
-
-    @payer_id.setter
-    def payer_id(self, value: Optional[str]) -> None:
-        self.__payer_id = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RefundPaymentProduct840CustomerAccount, self).to_dictionary()
-        if self.customer_account_status is not None:
-            dictionary['customerAccountStatus'] = self.customer_account_status
-        if self.customer_address_status is not None:
-            dictionary['customerAddressStatus'] = self.customer_address_status
-        if self.payer_id is not None:
-            dictionary['payerId'] = self.payer_id
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RefundPaymentProduct840CustomerAccount':
-        super(RefundPaymentProduct840CustomerAccount, self).from_dictionary(dictionary)
-        if 'customerAccountStatus' in dictionary:
-            self.customer_account_status = dictionary['customerAccountStatus']
-        if 'customerAddressStatus' in dictionary:
-            self.customer_address_status = dictionary['customerAddressStatus']
-        if 'payerId' in dictionary:
-            self.payer_id = dictionary['payerId']
-        return self

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

@@ -1,45 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.refund_payment_product840_customer_account import RefundPaymentProduct840CustomerAccount
-
-
-class RefundPaymentProduct840SpecificOutput(DataObject):
-    """
-    | PayPal refund details
-    """
-
-    __customer_account: Optional[RefundPaymentProduct840CustomerAccount] = None
-
-    @property
-    def customer_account(self) -> Optional[RefundPaymentProduct840CustomerAccount]:
-        """
-        | Object containing the PayPal account details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.refund_payment_product840_customer_account.RefundPaymentProduct840CustomerAccount`
-        """
-        return self.__customer_account
-
-    @customer_account.setter
-    def customer_account(self, value: Optional[RefundPaymentProduct840CustomerAccount]) -> None:
-        self.__customer_account = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RefundPaymentProduct840SpecificOutput, self).to_dictionary()
-        if self.customer_account is not None:
-            dictionary['customerAccount'] = self.customer_account.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RefundPaymentProduct840SpecificOutput':
-        super(RefundPaymentProduct840SpecificOutput, self).from_dictionary(dictionary)
-        if 'customerAccount' in dictionary:
-            if not isinstance(dictionary['customerAccount'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customerAccount']))
-            value = RefundPaymentProduct840CustomerAccount()
-            self.customer_account = value.from_dictionary(dictionary['customerAccount'])
-        return self

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

@@ -1,38 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class RefundReferences(DataObject):
-
-    __merchant_reference: Optional[str] = None
-
-    @property
-    def merchant_reference(self) -> Optional[str]:
-        """
-        | Note that the maximum length of this field for transactions processed on the GlobalCollect platform is 30. Your unique reference of the transaction that is also returned in our report files. This is almost always used for your reconciliation of our report files.
-        
-        Type: str
-        """
-        return self.__merchant_reference
-
-    @merchant_reference.setter
-    def merchant_reference(self, value: Optional[str]) -> None:
-        self.__merchant_reference = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RefundReferences, self).to_dictionary()
-        if self.merchant_reference is not None:
-            dictionary['merchantReference'] = self.merchant_reference
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RefundReferences':
-        super(RefundReferences, self).from_dictionary(dictionary)
-        if 'merchantReference' in dictionary:
-            self.merchant_reference = dictionary['merchantReference']
-        return self