connect-sdk-python3 3.47.0__zip → 4.0.1__zip

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

@@ -0,0 +1,197 @@
+# -*- 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.1/worldline/connect/sdk/v1/domain/refund_payment_product840_customer_account.py

@@ -0,0 +1,86 @@
+# -*- 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.1/worldline/connect/sdk/v1/domain/refund_payment_product840_specific_output.py

@@ -0,0 +1,45 @@
+# -*- 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.1/worldline/connect/sdk/v1/domain/refund_references.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class 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

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/refund_request.py

@@ -0,0 +1,127 @@
+# -*- 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.amount_of_money import AmountOfMoney
+from worldline.connect.sdk.v1.domain.bank_refund_method_specific_input import BankRefundMethodSpecificInput
+from worldline.connect.sdk.v1.domain.refund_customer import RefundCustomer
+from worldline.connect.sdk.v1.domain.refund_references import RefundReferences
+
+
+class RefundRequest(DataObject):
+
+    __amount_of_money: Optional[AmountOfMoney] = None
+    __bank_refund_method_specific_input: Optional[BankRefundMethodSpecificInput] = None
+    __customer: Optional[RefundCustomer] = None
+    __refund_date: Optional[str] = None
+    __refund_references: Optional[RefundReferences] = None
+
+    @property
+    def amount_of_money(self) -> Optional[AmountOfMoney]:
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`worldline.connect.sdk.v1.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__amount_of_money
+
+    @amount_of_money.setter
+    def amount_of_money(self, value: Optional[AmountOfMoney]) -> None:
+        self.__amount_of_money = value
+
+    @property
+    def bank_refund_method_specific_input(self) -> Optional[BankRefundMethodSpecificInput]:
+        """
+        | Object containing the specific input details for a bank refund
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_refund_method_specific_input.BankRefundMethodSpecificInput`
+        """
+        return self.__bank_refund_method_specific_input
+
+    @bank_refund_method_specific_input.setter
+    def bank_refund_method_specific_input(self, value: Optional[BankRefundMethodSpecificInput]) -> None:
+        self.__bank_refund_method_specific_input = value
+
+    @property
+    def customer(self) -> Optional[RefundCustomer]:
+        """
+        | Object containing the details of the customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.refund_customer.RefundCustomer`
+        """
+        return self.__customer
+
+    @customer.setter
+    def customer(self, value: Optional[RefundCustomer]) -> None:
+        self.__customer = value
+
+    @property
+    def refund_date(self) -> Optional[str]:
+        """
+        | Refund date
+        | Format: YYYYMMDD
+
+        Type: str
+        """
+        return self.__refund_date
+
+    @refund_date.setter
+    def refund_date(self, value: Optional[str]) -> None:
+        self.__refund_date = value
+
+    @property
+    def refund_references(self) -> Optional[RefundReferences]:
+        """
+        | Object that holds all reference properties that are linked to this refund
+
+        Type: :class:`worldline.connect.sdk.v1.domain.refund_references.RefundReferences`
+        """
+        return self.__refund_references
+
+    @refund_references.setter
+    def refund_references(self, value: Optional[RefundReferences]) -> None:
+        self.__refund_references = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundRequest, self).to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.bank_refund_method_specific_input is not None:
+            dictionary['bankRefundMethodSpecificInput'] = self.bank_refund_method_specific_input.to_dictionary()
+        if self.customer is not None:
+            dictionary['customer'] = self.customer.to_dictionary()
+        if self.refund_date is not None:
+            dictionary['refundDate'] = self.refund_date
+        if self.refund_references is not None:
+            dictionary['refundReferences'] = self.refund_references.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundRequest':
+        super(RefundRequest, 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 'bankRefundMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['bankRefundMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankRefundMethodSpecificInput']))
+            value = BankRefundMethodSpecificInput()
+            self.bank_refund_method_specific_input = value.from_dictionary(dictionary['bankRefundMethodSpecificInput'])
+        if 'customer' in dictionary:
+            if not isinstance(dictionary['customer'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customer']))
+            value = RefundCustomer()
+            self.customer = value.from_dictionary(dictionary['customer'])
+        if 'refundDate' in dictionary:
+            self.refund_date = dictionary['refundDate']
+        if 'refundReferences' in dictionary:
+            if not isinstance(dictionary['refundReferences'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['refundReferences']))
+            value = RefundReferences()
+            self.refund_references = value.from_dictionary(dictionary['refundReferences'])
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/refund_response.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.v1.domain.refund_result import RefundResult
+
+
+class RefundResponse(RefundResult):
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundResponse, self).to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundResponse':
+        super(RefundResponse, self).from_dictionary(dictionary)
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/refund_result.py

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.v1.domain.abstract_order_status import AbstractOrderStatus
+from worldline.connect.sdk.v1.domain.order_status_output import OrderStatusOutput
+from worldline.connect.sdk.v1.domain.refund_output import RefundOutput
+
+
+class RefundResult(AbstractOrderStatus):
+
+    __refund_output: Optional[RefundOutput] = None
+    __status: Optional[str] = None
+    __status_output: Optional[OrderStatusOutput] = None
+
+    @property
+    def refund_output(self) -> Optional[RefundOutput]:
+        """
+        | Object containing refund details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.refund_output.RefundOutput`
+        """
+        return self.__refund_output
+
+    @refund_output.setter
+    def refund_output(self, value: Optional[RefundOutput]) -> None:
+        self.__refund_output = value
+
+    @property
+    def status(self) -> Optional[str]:
+        """
+        | Current high-level status of the refund in a human-readable form. Possible values are:
+        
+        * CREATED - The transaction has been created. This is the initial state once a new refund is created.
+        * PENDING_APPROVAL - The transaction is awaiting approval from you to proceed with the processing of the refund
+        * REJECTED - The refund has been rejected
+        * REFUND_REQUESTED - The transaction is in the queue to be refunded
+        * REFUNDED - We have successfully refunded the customer
+        * REJECTED_CAPTURE - The refund was rejected by the bank or us during processing
+        * CANCELLED - You have cancelled the transaction
+        
+        
+        | Please see Statuses <https://apireference.connect.worldline-solutions.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: Optional[str]) -> None:
+        self.__status = value
+
+    @property
+    def status_output(self) -> Optional[OrderStatusOutput]:
+        """
+        | This object has the numeric representation of the current refund status, timestamp of last status change and performable action on the current refund resource.
+        | In case of a rejected refund, detailed error information is listed.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.order_status_output.OrderStatusOutput`
+        """
+        return self.__status_output
+
+    @status_output.setter
+    def status_output(self, value: Optional[OrderStatusOutput]) -> None:
+        self.__status_output = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundResult, self).to_dictionary()
+        if self.refund_output is not None:
+            dictionary['refundOutput'] = self.refund_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: dict) -> 'RefundResult':
+        super(RefundResult, self).from_dictionary(dictionary)
+        if 'refundOutput' in dictionary:
+            if not isinstance(dictionary['refundOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['refundOutput']))
+            value = RefundOutput()
+            self.refund_output = value.from_dictionary(dictionary['refundOutput'])
+        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 = OrderStatusOutput()
+            self.status_output = value.from_dictionary(dictionary['statusOutput'])
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/refunds_response.py

@@ -0,0 +1,47 @@
+# -*- 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.refund_result import RefundResult
+
+
+class RefundsResponse(DataObject):
+
+    __refunds: Optional[List[RefundResult]] = None
+
+    @property
+    def refunds(self) -> Optional[List[RefundResult]]:
+        """
+        | The list of all refunds performed on the requested payment.
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.refund_result.RefundResult`]
+        """
+        return self.__refunds
+
+    @refunds.setter
+    def refunds(self, value: Optional[List[RefundResult]]) -> None:
+        self.__refunds = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundsResponse, self).to_dictionary()
+        if self.refunds is not None:
+            dictionary['refunds'] = []
+            for element in self.refunds:
+                if element is not None:
+                    dictionary['refunds'].append(element.to_dictionary())
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundsResponse':
+        super(RefundsResponse, self).from_dictionary(dictionary)
+        if 'refunds' in dictionary:
+            if not isinstance(dictionary['refunds'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['refunds']))
+            self.refunds = []
+            for element in dictionary['refunds']:
+                value = RefundResult()
+                self.refunds.append(value.from_dictionary(element))
+        return self