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

onlinepayments/sdk/domain/capture_output.py

@@ -0,0 +1,272 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .amount_of_money import AmountOfMoney
+from .card_payment_method_specific_output import CardPaymentMethodSpecificOutput
+from .data_object import DataObject
+from .mobile_payment_method_specific_output import MobilePaymentMethodSpecificOutput
+from .operation_payment_references import OperationPaymentReferences
+from .payment_references import PaymentReferences
+from .redirect_payment_method_specific_output import RedirectPaymentMethodSpecificOutput
+from .sepa_direct_debit_payment_method_specific_output import SepaDirectDebitPaymentMethodSpecificOutput
+from .surcharge_specific_output import SurchargeSpecificOutput
+
+
+class CaptureOutput(DataObject):
+
+    __acquired_amount: Optional[AmountOfMoney] = None
+    __amount_of_money: Optional[AmountOfMoney] = None
+    __amount_paid: Optional[int] = None
+    __card_payment_method_specific_output: Optional[CardPaymentMethodSpecificOutput] = None
+    __merchant_parameters: Optional[str] = None
+    __mobile_payment_method_specific_output: Optional[MobilePaymentMethodSpecificOutput] = None
+    __operation_references: Optional[OperationPaymentReferences] = None
+    __payment_method: Optional[str] = None
+    __redirect_payment_method_specific_output: Optional[RedirectPaymentMethodSpecificOutput] = None
+    __references: Optional[PaymentReferences] = None
+    __sepa_direct_debit_payment_method_specific_output: Optional[SepaDirectDebitPaymentMethodSpecificOutput] = None
+    __surcharge_specific_output: Optional[SurchargeSpecificOutput] = None
+
+    @property
+    def acquired_amount(self) -> Optional[AmountOfMoney]:
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`onlinepayments.sdk.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__acquired_amount
+
+    @acquired_amount.setter
+    def acquired_amount(self, value: Optional[AmountOfMoney]) -> None:
+        self.__acquired_amount = value
+
+    @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 amount_paid(self) -> Optional[int]:
+        """
+        | Amount that has been paid. This is deprecated. Use acquiredAmount instead.
+
+        Type: int
+
+        Deprecated; Amount that has been paid. This is deprecated. Use acquiredAmount instead.
+        """
+        return self.__amount_paid
+
+    @amount_paid.setter
+    def amount_paid(self, value: Optional[int]) -> None:
+        self.__amount_paid = value
+
+    @property
+    def card_payment_method_specific_output(self) -> Optional[CardPaymentMethodSpecificOutput]:
+        """
+        | Object containing the card payment method details
+
+        Type: :class:`onlinepayments.sdk.domain.card_payment_method_specific_output.CardPaymentMethodSpecificOutput`
+        """
+        return self.__card_payment_method_specific_output
+
+    @card_payment_method_specific_output.setter
+    def card_payment_method_specific_output(self, value: Optional[CardPaymentMethodSpecificOutput]) -> None:
+        self.__card_payment_method_specific_output = value
+
+    @property
+    def merchant_parameters(self) -> Optional[str]:
+        """
+        | It allows you to store additional parameters for the transaction in the format you prefer (e.g.-> key-value query string, JSON, etc.) These parameters are then echoed back to you in API GET calls and Webhook notifications. This field must not contain any personal data.
+
+        Type: str
+        """
+        return self.__merchant_parameters
+
+    @merchant_parameters.setter
+    def merchant_parameters(self, value: Optional[str]) -> None:
+        self.__merchant_parameters = value
+
+    @property
+    def mobile_payment_method_specific_output(self) -> Optional[MobilePaymentMethodSpecificOutput]:
+        """
+        | Object containing the mobile payment method details
+
+        Type: :class:`onlinepayments.sdk.domain.mobile_payment_method_specific_output.MobilePaymentMethodSpecificOutput`
+        """
+        return self.__mobile_payment_method_specific_output
+
+    @mobile_payment_method_specific_output.setter
+    def mobile_payment_method_specific_output(self, value: Optional[MobilePaymentMethodSpecificOutput]) -> None:
+        self.__mobile_payment_method_specific_output = 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 payment_method(self) -> Optional[str]:
+        """
+        | Payment method identifier used by the our payment engine.
+
+        Type: str
+        """
+        return self.__payment_method
+
+    @payment_method.setter
+    def payment_method(self, value: Optional[str]) -> None:
+        self.__payment_method = value
+
+    @property
+    def redirect_payment_method_specific_output(self) -> Optional[RedirectPaymentMethodSpecificOutput]:
+        """
+        | Object containing the redirect payment product details
+
+        Type: :class:`onlinepayments.sdk.domain.redirect_payment_method_specific_output.RedirectPaymentMethodSpecificOutput`
+        """
+        return self.__redirect_payment_method_specific_output
+
+    @redirect_payment_method_specific_output.setter
+    def redirect_payment_method_specific_output(self, value: Optional[RedirectPaymentMethodSpecificOutput]) -> None:
+        self.__redirect_payment_method_specific_output = 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 sepa_direct_debit_payment_method_specific_output(self) -> Optional[SepaDirectDebitPaymentMethodSpecificOutput]:
+        """
+        | Object containing the SEPA direct debit details
+
+        Type: :class:`onlinepayments.sdk.domain.sepa_direct_debit_payment_method_specific_output.SepaDirectDebitPaymentMethodSpecificOutput`
+        """
+        return self.__sepa_direct_debit_payment_method_specific_output
+
+    @sepa_direct_debit_payment_method_specific_output.setter
+    def sepa_direct_debit_payment_method_specific_output(self, value: Optional[SepaDirectDebitPaymentMethodSpecificOutput]) -> None:
+        self.__sepa_direct_debit_payment_method_specific_output = value
+
+    @property
+    def surcharge_specific_output(self) -> Optional[SurchargeSpecificOutput]:
+        """
+        | Object containing specific surcharging attributes applied to an order.
+
+        Type: :class:`onlinepayments.sdk.domain.surcharge_specific_output.SurchargeSpecificOutput`
+        """
+        return self.__surcharge_specific_output
+
+    @surcharge_specific_output.setter
+    def surcharge_specific_output(self, value: Optional[SurchargeSpecificOutput]) -> None:
+        self.__surcharge_specific_output = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CaptureOutput, self).to_dictionary()
+        if self.acquired_amount is not None:
+            dictionary['acquiredAmount'] = self.acquired_amount.to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.amount_paid is not None:
+            dictionary['amountPaid'] = self.amount_paid
+        if self.card_payment_method_specific_output is not None:
+            dictionary['cardPaymentMethodSpecificOutput'] = self.card_payment_method_specific_output.to_dictionary()
+        if self.merchant_parameters is not None:
+            dictionary['merchantParameters'] = self.merchant_parameters
+        if self.mobile_payment_method_specific_output is not None:
+            dictionary['mobilePaymentMethodSpecificOutput'] = self.mobile_payment_method_specific_output.to_dictionary()
+        if self.operation_references is not None:
+            dictionary['operationReferences'] = self.operation_references.to_dictionary()
+        if self.payment_method is not None:
+            dictionary['paymentMethod'] = self.payment_method
+        if self.redirect_payment_method_specific_output is not None:
+            dictionary['redirectPaymentMethodSpecificOutput'] = self.redirect_payment_method_specific_output.to_dictionary()
+        if self.references is not None:
+            dictionary['references'] = self.references.to_dictionary()
+        if self.sepa_direct_debit_payment_method_specific_output is not None:
+            dictionary['sepaDirectDebitPaymentMethodSpecificOutput'] = self.sepa_direct_debit_payment_method_specific_output.to_dictionary()
+        if self.surcharge_specific_output is not None:
+            dictionary['surchargeSpecificOutput'] = self.surcharge_specific_output.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CaptureOutput':
+        super(CaptureOutput, self).from_dictionary(dictionary)
+        if 'acquiredAmount' in dictionary:
+            if not isinstance(dictionary['acquiredAmount'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['acquiredAmount']))
+            value = AmountOfMoney()
+            self.acquired_amount = value.from_dictionary(dictionary['acquiredAmount'])
+        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 'amountPaid' in dictionary:
+            self.amount_paid = dictionary['amountPaid']
+        if 'cardPaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['cardPaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardPaymentMethodSpecificOutput']))
+            value = CardPaymentMethodSpecificOutput()
+            self.card_payment_method_specific_output = value.from_dictionary(dictionary['cardPaymentMethodSpecificOutput'])
+        if 'merchantParameters' in dictionary:
+            self.merchant_parameters = dictionary['merchantParameters']
+        if 'mobilePaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['mobilePaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mobilePaymentMethodSpecificOutput']))
+            value = MobilePaymentMethodSpecificOutput()
+            self.mobile_payment_method_specific_output = value.from_dictionary(dictionary['mobilePaymentMethodSpecificOutput'])
+        if '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 'paymentMethod' in dictionary:
+            self.payment_method = dictionary['paymentMethod']
+        if 'redirectPaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['redirectPaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['redirectPaymentMethodSpecificOutput']))
+            value = RedirectPaymentMethodSpecificOutput()
+            self.redirect_payment_method_specific_output = value.from_dictionary(dictionary['redirectPaymentMethodSpecificOutput'])
+        if '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 'sepaDirectDebitPaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['sepaDirectDebitPaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['sepaDirectDebitPaymentMethodSpecificOutput']))
+            value = SepaDirectDebitPaymentMethodSpecificOutput()
+            self.sepa_direct_debit_payment_method_specific_output = value.from_dictionary(dictionary['sepaDirectDebitPaymentMethodSpecificOutput'])
+        if 'surchargeSpecificOutput' in dictionary:
+            if not isinstance(dictionary['surchargeSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['surchargeSpecificOutput']))
+            value = SurchargeSpecificOutput()
+            self.surcharge_specific_output = value.from_dictionary(dictionary['surchargeSpecificOutput'])
+        return self

onlinepayments/sdk/domain/capture_payment_batch_request.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .capture_payment_request import CapturePaymentRequest
+from .data_object import DataObject
+
+
+class CapturePaymentBatchRequest(DataObject):
+
+    __capture: Optional[CapturePaymentRequest] = None
+    __payment_id: Optional[str] = None
+
+    @property
+    def capture(self) -> Optional[CapturePaymentRequest]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.capture_payment_request.CapturePaymentRequest`
+        """
+        return self.__capture
+
+    @capture.setter
+    def capture(self, value: Optional[CapturePaymentRequest]) -> None:
+        self.__capture = value
+
+    @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
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CapturePaymentBatchRequest, self).to_dictionary()
+        if self.capture is not None:
+            dictionary['capture'] = self.capture.to_dictionary()
+        if self.payment_id is not None:
+            dictionary['paymentId'] = self.payment_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CapturePaymentBatchRequest':
+        super(CapturePaymentBatchRequest, self).from_dictionary(dictionary)
+        if 'capture' in dictionary:
+            if not isinstance(dictionary['capture'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['capture']))
+            value = CapturePaymentRequest()
+            self.capture = value.from_dictionary(dictionary['capture'])
+        if 'paymentId' in dictionary:
+            self.payment_id = dictionary['paymentId']
+        return self

onlinepayments/sdk/domain/capture_payment_request.py

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+from .line_item_detail import LineItemDetail
+from .operation_payment_references import OperationPaymentReferences
+from .payment_references import PaymentReferences
+from .shipping_detail import ShippingDetail
+
+
+class CapturePaymentRequest(DataObject):
+
+    __amount: Optional[int] = None
+    __is_final: Optional[bool] = None
+    __line_item_details: Optional[List[LineItemDetail]] = None
+    __operation_references: Optional[OperationPaymentReferences] = None
+    __references: Optional[PaymentReferences] = None
+    __shipping: Optional[ShippingDetail] = None
+
+    @property
+    def amount(self) -> Optional[int]:
+        """
+        | Here you can specify the amount that you want to capture (specified in cents, where single digit currencies are presumed to have 2 digits). The amount can be lower than the amount that was authorized, but not higher. If left empty, the full amount will be captured and the request will be final. If the full amount is captured, the request will also be final.
+
+        Type: int
+        """
+        return self.__amount
+
+    @amount.setter
+    def amount(self, value: Optional[int]) -> None:
+        self.__amount = 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 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 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 shipping(self) -> Optional[ShippingDetail]:
+        """
+        | Object containing the details of the shipping of the order
+
+        Type: :class:`onlinepayments.sdk.domain.shipping_detail.ShippingDetail`
+        """
+        return self.__shipping
+
+    @shipping.setter
+    def shipping(self, value: Optional[ShippingDetail]) -> None:
+        self.__shipping = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CapturePaymentRequest, self).to_dictionary()
+        if self.amount is not None:
+            dictionary['amount'] = self.amount
+        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.operation_references is not None:
+            dictionary['operationReferences'] = self.operation_references.to_dictionary()
+        if self.references is not None:
+            dictionary['references'] = self.references.to_dictionary()
+        if self.shipping is not None:
+            dictionary['shipping'] = self.shipping.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CapturePaymentRequest':
+        super(CapturePaymentRequest, self).from_dictionary(dictionary)
+        if 'amount' in dictionary:
+            self.amount = dictionary['amount']
+        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 '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 '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 'shipping' in dictionary:
+            if not isinstance(dictionary['shipping'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['shipping']))
+            value = ShippingDetail()
+            self.shipping = value.from_dictionary(dictionary['shipping'])
+        return self

onlinepayments/sdk/domain/capture_response.py

@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .capture_output import CaptureOutput
+from .capture_status_output import CaptureStatusOutput
+from .data_object import DataObject
+
+
+class CaptureResponse(DataObject):
+
+    __capture_output: Optional[CaptureOutput] = None
+    __id: Optional[str] = None
+    __status: Optional[str] = None
+    __status_output: Optional[CaptureStatusOutput] = None
+
+    @property
+    def capture_output(self) -> Optional[CaptureOutput]:
+        """
+        | Object containing capture details
+
+        Type: :class:`onlinepayments.sdk.domain.capture_output.CaptureOutput`
+        """
+        return self.__capture_output
+
+    @capture_output.setter
+    def capture_output(self, value: Optional[CaptureOutput]) -> None:
+        self.__capture_output = value
+
+    @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 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[CaptureStatusOutput]:
+        """
+        | This object has the numeric representation of the current capture status, timestamp of last status change and performable action on the current payment resource. In case of failed payments and negative scenarios, detailed error information is listed.
+
+        Type: :class:`onlinepayments.sdk.domain.capture_status_output.CaptureStatusOutput`
+        """
+        return self.__status_output
+
+    @status_output.setter
+    def status_output(self, value: Optional[CaptureStatusOutput]) -> None:
+        self.__status_output = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CaptureResponse, self).to_dictionary()
+        if self.capture_output is not None:
+            dictionary['captureOutput'] = self.capture_output.to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        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) -> 'CaptureResponse':
+        super(CaptureResponse, self).from_dictionary(dictionary)
+        if 'captureOutput' in dictionary:
+            if not isinstance(dictionary['captureOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['captureOutput']))
+            value = CaptureOutput()
+            self.capture_output = value.from_dictionary(dictionary['captureOutput'])
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        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 = CaptureStatusOutput()
+            self.status_output = value.from_dictionary(dictionary['statusOutput'])
+        return self

onlinepayments/sdk/domain/capture_status_output.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CaptureStatusOutput(DataObject):
+
+    __status_code: Optional[int] = None
+
+    @property
+    def status_code(self) -> Optional[int]:
+        """
+        | Numeric status code of the legacy API. The value can also be found in the BackOffice and in report files.
+
+        Type: int
+        """
+        return self.__status_code
+
+    @status_code.setter
+    def status_code(self, value: Optional[int]) -> None:
+        self.__status_code = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CaptureStatusOutput, self).to_dictionary()
+        if self.status_code is not None:
+            dictionary['statusCode'] = self.status_code
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CaptureStatusOutput':
+        super(CaptureStatusOutput, self).from_dictionary(dictionary)
+        if 'statusCode' in dictionary:
+            self.status_code = dictionary['statusCode']
+        return self

onlinepayments/sdk/domain/captures_response.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .capture import Capture
+from .data_object import DataObject
+
+
+class CapturesResponse(DataObject):
+
+    __captures: Optional[List[Capture]] = None
+
+    @property
+    def captures(self) -> Optional[List[Capture]]:
+        """
+        | The list of all captures performed on the requested payment.
+
+        Type: list[:class:`onlinepayments.sdk.domain.capture.Capture`]
+        """
+        return self.__captures
+
+    @captures.setter
+    def captures(self, value: Optional[List[Capture]]) -> None:
+        self.__captures = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CapturesResponse, self).to_dictionary()
+        if self.captures is not None:
+            dictionary['captures'] = []
+            for element in self.captures:
+                if element is not None:
+                    dictionary['captures'].append(element.to_dictionary())
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CapturesResponse':
+        super(CapturesResponse, self).from_dictionary(dictionary)
+        if 'captures' in dictionary:
+            if not isinstance(dictionary['captures'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['captures']))
+            self.captures = []
+            for element in dictionary['captures']:
+                value = Capture()
+                self.captures.append(value.from_dictionary(element))
+        return self