onlinepayments-sdk-python3 7.4.1__py3-none-any.whl

onlinepayments/sdk/domain/refund_payment_batch_request.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .refund_request import RefundRequest
+
+
+class RefundPaymentBatchRequest(DataObject):
+
+    __payment_id: Optional[str] = None
+    __refund: Optional[RefundRequest] = None
+
+    @property
+    def payment_id(self) -> Optional[str]:
+        """
+        | This is our unique payment transaction identifier.
+
+        Type: str
+        """
+        return self.__payment_id
+
+    @payment_id.setter
+    def payment_id(self, value: Optional[str]) -> None:
+        self.__payment_id = value
+
+    @property
+    def refund(self) -> Optional[RefundRequest]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.refund_request.RefundRequest`
+        """
+        return self.__refund
+
+    @refund.setter
+    def refund(self, value: Optional[RefundRequest]) -> None:
+        self.__refund = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundPaymentBatchRequest, self).to_dictionary()
+        if self.payment_id is not None:
+            dictionary['paymentId'] = self.payment_id
+        if self.refund is not None:
+            dictionary['refund'] = self.refund.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundPaymentBatchRequest':
+        super(RefundPaymentBatchRequest, self).from_dictionary(dictionary)
+        if 'paymentId' in dictionary:
+            self.payment_id = dictionary['paymentId']
+        if 'refund' in dictionary:
+            if not isinstance(dictionary['refund'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['refund']))
+            value = RefundRequest()
+            self.refund = value.from_dictionary(dictionary['refund'])
+        return self

onlinepayments/sdk/domain/refund_payment_product840_customer_account.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class RefundPaymentProduct840CustomerAccount(DataObject):
+
+    __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]:
+        """
+        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]:
+        """
+        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

onlinepayments/sdk/domain/refund_payment_product840_specific_output.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .refund_payment_product840_customer_account import RefundPaymentProduct840CustomerAccount
+
+
+class RefundPaymentProduct840SpecificOutput(DataObject):
+
+    __customer_account: Optional[RefundPaymentProduct840CustomerAccount] = None
+
+    @property
+    def customer_account(self) -> Optional[RefundPaymentProduct840CustomerAccount]:
+        """
+        Type: :class:`onlinepayments.sdk.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

onlinepayments/sdk/domain/refund_redirect_method_specific_output.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class RefundRedirectMethodSpecificOutput(DataObject):
+
+    __total_amount_paid: Optional[int] = None
+    __total_amount_refunded: Optional[int] = None
+
+    @property
+    def total_amount_paid(self) -> Optional[int]:
+        """
+        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(RefundRedirectMethodSpecificOutput, self).to_dictionary()
+        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) -> 'RefundRedirectMethodSpecificOutput':
+        super(RefundRedirectMethodSpecificOutput, self).from_dictionary(dictionary)
+        if 'totalAmountPaid' in dictionary:
+            self.total_amount_paid = dictionary['totalAmountPaid']
+        if 'totalAmountRefunded' in dictionary:
+            self.total_amount_refunded = dictionary['totalAmountRefunded']
+        return self

onlinepayments/sdk/domain/refund_redirect_payment_method_specific_input.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .refund_redirect_payment_product900_specific_input import RefundRedirectPaymentProduct900SpecificInput
+
+
+class RefundRedirectPaymentMethodSpecificInput(DataObject):
+
+    __refund_redirect_payment_product900_specific_input: Optional[RefundRedirectPaymentProduct900SpecificInput] = None
+
+    @property
+    def refund_redirect_payment_product900_specific_input(self) -> Optional[RefundRedirectPaymentProduct900SpecificInput]:
+        """
+        | Object containing specific input required for Wero refunds (Payment product ID 900).
+
+        Type: :class:`onlinepayments.sdk.domain.refund_redirect_payment_product900_specific_input.RefundRedirectPaymentProduct900SpecificInput`
+        """
+        return self.__refund_redirect_payment_product900_specific_input
+
+    @refund_redirect_payment_product900_specific_input.setter
+    def refund_redirect_payment_product900_specific_input(self, value: Optional[RefundRedirectPaymentProduct900SpecificInput]) -> None:
+        self.__refund_redirect_payment_product900_specific_input = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundRedirectPaymentMethodSpecificInput, self).to_dictionary()
+        if self.refund_redirect_payment_product900_specific_input is not None:
+            dictionary['refundRedirectPaymentProduct900SpecificInput'] = self.refund_redirect_payment_product900_specific_input.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundRedirectPaymentMethodSpecificInput':
+        super(RefundRedirectPaymentMethodSpecificInput, self).from_dictionary(dictionary)
+        if 'refundRedirectPaymentProduct900SpecificInput' in dictionary:
+            if not isinstance(dictionary['refundRedirectPaymentProduct900SpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['refundRedirectPaymentProduct900SpecificInput']))
+            value = RefundRedirectPaymentProduct900SpecificInput()
+            self.refund_redirect_payment_product900_specific_input = value.from_dictionary(dictionary['refundRedirectPaymentProduct900SpecificInput'])
+        return self

onlinepayments/sdk/domain/refund_redirect_payment_product900_specific_input.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class RefundRedirectPaymentProduct900SpecificInput(DataObject):
+
+    __refund_reason: Optional[str] = None
+
+    @property
+    def refund_reason(self) -> Optional[str]:
+        """
+        | The reason for the refund, required for Wero payments. This value is sent to the consumer’s bank as part of the Wero refund request and will be shown to the consumer in their banking application. If not provided, the value defaults to "Other".
+
+        Type: str
+        """
+        return self.__refund_reason
+
+    @refund_reason.setter
+    def refund_reason(self, value: Optional[str]) -> None:
+        self.__refund_reason = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundRedirectPaymentProduct900SpecificInput, self).to_dictionary()
+        if self.refund_reason is not None:
+            dictionary['refundReason'] = self.refund_reason
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundRedirectPaymentProduct900SpecificInput':
+        super(RefundRedirectPaymentProduct900SpecificInput, self).from_dictionary(dictionary)
+        if 'refundReason' in dictionary:
+            self.refund_reason = dictionary['refundReason']
+        return self

onlinepayments/sdk/domain/refund_request.py

@@ -0,0 +1,210 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .amount_of_money import AmountOfMoney
+from .data_object import DataObject
+from .line_item_detail import LineItemDetail
+from .omnichannel_refund_specific_input import OmnichannelRefundSpecificInput
+from .operation_payment_references import OperationPaymentReferences
+from .payment_references import PaymentReferences
+from .refund_redirect_payment_method_specific_input import RefundRedirectPaymentMethodSpecificInput
+
+
+class RefundRequest(DataObject):
+
+    __amount_of_money: Optional[AmountOfMoney] = None
+    __capture_id: Optional[str] = None
+    __is_final: Optional[bool] = None
+    __line_item_details: Optional[List[LineItemDetail]] = None
+    __omnichannel_refund_specific_input: Optional[OmnichannelRefundSpecificInput] = None
+    __operation_references: Optional[OperationPaymentReferences] = None
+    __reason: Optional[str] = None
+    __references: Optional[PaymentReferences] = None
+    __refund_redirect_payment_method_specific_input: Optional[RefundRedirectPaymentMethodSpecificInput] = None
+
+    @property
+    def amount_of_money(self) -> Optional[AmountOfMoney]:
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`onlinepayments.sdk.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 capture_id(self) -> Optional[str]:
+        """
+        | The identifier of the capture that is used for partial refund. CaptureId is only necessary for Paypal/PostfinancePay multi-capture payments.
+
+        Type: str
+        """
+        return self.__capture_id
+
+    @capture_id.setter
+    def capture_id(self, value: Optional[str]) -> None:
+        self.__capture_id = value
+
+    @property
+    def is_final(self) -> Optional[bool]:
+        """
+        | This property indicates whether this will be the final operation. The default value for this property is false.
+
+        Type: bool
+        """
+        return self.__is_final
+
+    @is_final.setter
+    def is_final(self, value: Optional[bool]) -> None:
+        self.__is_final = value
+
+    @property
+    def line_item_details(self) -> Optional[List[LineItemDetail]]:
+        """
+        | List of lineItemIds and quantities for capture/refund/cancellation.
+
+        Type: list[:class:`onlinepayments.sdk.domain.line_item_detail.LineItemDetail`]
+        """
+        return self.__line_item_details
+
+    @line_item_details.setter
+    def line_item_details(self, value: Optional[List[LineItemDetail]]) -> None:
+        self.__line_item_details = value
+
+    @property
+    def omnichannel_refund_specific_input(self) -> Optional[OmnichannelRefundSpecificInput]:
+        """
+        | Object containing the additional refund details for an Omnichannel merchant
+
+        Type: :class:`onlinepayments.sdk.domain.omnichannel_refund_specific_input.OmnichannelRefundSpecificInput`
+        """
+        return self.__omnichannel_refund_specific_input
+
+    @omnichannel_refund_specific_input.setter
+    def omnichannel_refund_specific_input(self, value: Optional[OmnichannelRefundSpecificInput]) -> None:
+        self.__omnichannel_refund_specific_input = value
+
+    @property
+    def operation_references(self) -> Optional[OperationPaymentReferences]:
+        """
+        | Object that holds all reference properties that are linked to this transaction
+
+        Type: :class:`onlinepayments.sdk.domain.operation_payment_references.OperationPaymentReferences`
+        """
+        return self.__operation_references
+
+    @operation_references.setter
+    def operation_references(self, value: Optional[OperationPaymentReferences]) -> None:
+        self.__operation_references = value
+
+    @property
+    def reason(self) -> Optional[str]:
+        """
+        | The reason for the refund. This will be available in our portal and reports for your information only. It will NOT appear in the consumer bank statement or yours.§
+
+        Type: str
+        """
+        return self.__reason
+
+    @reason.setter
+    def reason(self, value: Optional[str]) -> None:
+        self.__reason = value
+
+    @property
+    def references(self) -> Optional[PaymentReferences]:
+        """
+        | Object that holds all reference properties that are linked to this transaction. **Deprecated for capture/refund**: Use operationReferences instead.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_references.PaymentReferences`
+        """
+        return self.__references
+
+    @references.setter
+    def references(self, value: Optional[PaymentReferences]) -> None:
+        self.__references = value
+
+    @property
+    def refund_redirect_payment_method_specific_input(self) -> Optional[RefundRedirectPaymentMethodSpecificInput]:
+        """
+        | Object containing the specific input details for refunds for redirection payment methods.
+
+        Type: :class:`onlinepayments.sdk.domain.refund_redirect_payment_method_specific_input.RefundRedirectPaymentMethodSpecificInput`
+        """
+        return self.__refund_redirect_payment_method_specific_input
+
+    @refund_redirect_payment_method_specific_input.setter
+    def refund_redirect_payment_method_specific_input(self, value: Optional[RefundRedirectPaymentMethodSpecificInput]) -> None:
+        self.__refund_redirect_payment_method_specific_input = 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.capture_id is not None:
+            dictionary['captureId'] = self.capture_id
+        if self.is_final is not None:
+            dictionary['isFinal'] = self.is_final
+        if self.line_item_details is not None:
+            dictionary['lineItemDetails'] = []
+            for element in self.line_item_details:
+                if element is not None:
+                    dictionary['lineItemDetails'].append(element.to_dictionary())
+        if self.omnichannel_refund_specific_input is not None:
+            dictionary['omnichannelRefundSpecificInput'] = self.omnichannel_refund_specific_input.to_dictionary()
+        if self.operation_references is not None:
+            dictionary['operationReferences'] = self.operation_references.to_dictionary()
+        if self.reason is not None:
+            dictionary['reason'] = self.reason
+        if self.references is not None:
+            dictionary['references'] = self.references.to_dictionary()
+        if self.refund_redirect_payment_method_specific_input is not None:
+            dictionary['refundRedirectPaymentMethodSpecificInput'] = self.refund_redirect_payment_method_specific_input.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 'captureId' in dictionary:
+            self.capture_id = dictionary['captureId']
+        if 'isFinal' in dictionary:
+            self.is_final = dictionary['isFinal']
+        if 'lineItemDetails' in dictionary:
+            if not isinstance(dictionary['lineItemDetails'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['lineItemDetails']))
+            self.line_item_details = []
+            for element in dictionary['lineItemDetails']:
+                value = LineItemDetail()
+                self.line_item_details.append(value.from_dictionary(element))
+        if 'omnichannelRefundSpecificInput' in dictionary:
+            if not isinstance(dictionary['omnichannelRefundSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['omnichannelRefundSpecificInput']))
+            value = OmnichannelRefundSpecificInput()
+            self.omnichannel_refund_specific_input = value.from_dictionary(dictionary['omnichannelRefundSpecificInput'])
+        if 'operationReferences' in dictionary:
+            if not isinstance(dictionary['operationReferences'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['operationReferences']))
+            value = OperationPaymentReferences()
+            self.operation_references = value.from_dictionary(dictionary['operationReferences'])
+        if 'reason' in dictionary:
+            self.reason = dictionary['reason']
+        if 'references' in dictionary:
+            if not isinstance(dictionary['references'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['references']))
+            value = PaymentReferences()
+            self.references = value.from_dictionary(dictionary['references'])
+        if 'refundRedirectPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['refundRedirectPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['refundRedirectPaymentMethodSpecificInput']))
+            value = RefundRedirectPaymentMethodSpecificInput()
+            self.refund_redirect_payment_method_specific_input = value.from_dictionary(dictionary['refundRedirectPaymentMethodSpecificInput'])
+        return self

onlinepayments/sdk/domain/refund_response.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .order_status_output import OrderStatusOutput
+from .refund_output import RefundOutput
+
+
+class RefundResponse(DataObject):
+
+    __id: Optional[str] = None
+    __refund_output: Optional[RefundOutput] = None
+    __status: Optional[str] = None
+    __status_output: Optional[OrderStatusOutput] = None
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        | This is our unique payment transaction identifier.
+
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    @property
+    def refund_output(self) -> Optional[RefundOutput]:
+        """
+        | Object containing refund details
+
+        Type: :class:`onlinepayments.sdk.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 payment in a human-readable form.
+
+        Type: str
+        """
+        return self.__status
+
+    @status.setter
+    def status(self, value: Optional[str]) -> None:
+        self.__status = value
+
+    @property
+    def status_output(self) -> Optional[OrderStatusOutput]:
+        """
+        Type: :class:`onlinepayments.sdk.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(RefundResponse, self).to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        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) -> 'RefundResponse':
+        super(RefundResponse, self).from_dictionary(dictionary)
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        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

onlinepayments/sdk/domain/refunds_response.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+from .refund_response import RefundResponse
+
+
+class RefundsResponse(DataObject):
+
+    __refunds: Optional[List[RefundResponse]] = None
+
+    @property
+    def refunds(self) -> Optional[List[RefundResponse]]:
+        """
+        | The list of all refunds performed on the requested payment.
+
+        Type: list[:class:`onlinepayments.sdk.domain.refund_response.RefundResponse`]
+        """
+        return self.__refunds
+
+    @refunds.setter
+    def refunds(self, value: Optional[List[RefundResponse]]) -> 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 = RefundResponse()
+                self.refunds.append(value.from_dictionary(element))
+        return self