connect-sdk-python3 3.47.0__zip → 4.0.1__zip

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

@@ -0,0 +1,92 @@
+# -*- 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.capture_output import CaptureOutput
+from worldline.connect.sdk.v1.domain.capture_status_output import CaptureStatusOutput
+
+
+class Capture(AbstractOrderStatus):
+
+    __capture_output: Optional[CaptureOutput] = None
+    __status: Optional[str] = None
+    __status_output: Optional[CaptureStatusOutput] = None
+
+    @property
+    def capture_output(self) -> Optional[CaptureOutput]:
+        """
+        | Object containing capture details
+
+        Type: :class:`worldline.connect.sdk.v1.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 status(self) -> Optional[str]:
+        """
+        | Current high-level status of the payment in a human-readable form. Possible values are :
+        
+        * CAPTURE_REQUESTED - The transaction is in the queue to be captured.
+        * CAPTURED - The transaction has been captured and we have received online confirmation.
+        * CANCELLED - You have cancelled the transaction.
+        * REJECTED_CAPTURE - We or one of our downstream acquirers/providers have rejected the capture request.
+        * REVERSED - The transaction has been reversed.
+        
+        
+        | 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[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:`worldline.connect.sdk.v1.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(Capture, self).to_dictionary()
+        if self.capture_output is not None:
+            dictionary['captureOutput'] = self.capture_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) -> 'Capture':
+        super(Capture, 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 '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

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

@@ -0,0 +1,299 @@
+# -*- 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.bank_transfer_payment_method_specific_output import BankTransferPaymentMethodSpecificOutput
+from worldline.connect.sdk.v1.domain.card_payment_method_specific_output import CardPaymentMethodSpecificOutput
+from worldline.connect.sdk.v1.domain.cash_payment_method_specific_output import CashPaymentMethodSpecificOutput
+from worldline.connect.sdk.v1.domain.e_invoice_payment_method_specific_output import EInvoicePaymentMethodSpecificOutput
+from worldline.connect.sdk.v1.domain.invoice_payment_method_specific_output import InvoicePaymentMethodSpecificOutput
+from worldline.connect.sdk.v1.domain.mobile_payment_method_specific_output import MobilePaymentMethodSpecificOutput
+from worldline.connect.sdk.v1.domain.non_sepa_direct_debit_payment_method_specific_output import NonSepaDirectDebitPaymentMethodSpecificOutput
+from worldline.connect.sdk.v1.domain.order_output import OrderOutput
+from worldline.connect.sdk.v1.domain.redirect_payment_method_specific_output import RedirectPaymentMethodSpecificOutput
+from worldline.connect.sdk.v1.domain.sepa_direct_debit_payment_method_specific_output import SepaDirectDebitPaymentMethodSpecificOutput
+
+
+class CaptureOutput(OrderOutput):
+
+    __amount_paid: Optional[int] = None
+    __amount_reversed: Optional[int] = None
+    __bank_transfer_payment_method_specific_output: Optional[BankTransferPaymentMethodSpecificOutput] = None
+    __card_payment_method_specific_output: Optional[CardPaymentMethodSpecificOutput] = None
+    __cash_payment_method_specific_output: Optional[CashPaymentMethodSpecificOutput] = None
+    __direct_debit_payment_method_specific_output: Optional[NonSepaDirectDebitPaymentMethodSpecificOutput] = None
+    __e_invoice_payment_method_specific_output: Optional[EInvoicePaymentMethodSpecificOutput] = None
+    __invoice_payment_method_specific_output: Optional[InvoicePaymentMethodSpecificOutput] = None
+    __mobile_payment_method_specific_output: Optional[MobilePaymentMethodSpecificOutput] = None
+    __payment_method: Optional[str] = None
+    __redirect_payment_method_specific_output: Optional[RedirectPaymentMethodSpecificOutput] = None
+    __reversal_reason: Optional[str] = None
+    __sepa_direct_debit_payment_method_specific_output: Optional[SepaDirectDebitPaymentMethodSpecificOutput] = None
+
+    @property
+    def amount_paid(self) -> Optional[int]:
+        """
+        | Amount that has been paid
+
+        Type: int
+        """
+        return self.__amount_paid
+
+    @amount_paid.setter
+    def amount_paid(self, value: Optional[int]) -> None:
+        self.__amount_paid = value
+
+    @property
+    def amount_reversed(self) -> Optional[int]:
+        """
+        | Amount that has been reversed
+
+        Type: int
+        """
+        return self.__amount_reversed
+
+    @amount_reversed.setter
+    def amount_reversed(self, value: Optional[int]) -> None:
+        self.__amount_reversed = value
+
+    @property
+    def bank_transfer_payment_method_specific_output(self) -> Optional[BankTransferPaymentMethodSpecificOutput]:
+        """
+        | Object containing the bank transfer payment method details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_transfer_payment_method_specific_output.BankTransferPaymentMethodSpecificOutput`
+        """
+        return self.__bank_transfer_payment_method_specific_output
+
+    @bank_transfer_payment_method_specific_output.setter
+    def bank_transfer_payment_method_specific_output(self, value: Optional[BankTransferPaymentMethodSpecificOutput]) -> None:
+        self.__bank_transfer_payment_method_specific_output = value
+
+    @property
+    def card_payment_method_specific_output(self) -> Optional[CardPaymentMethodSpecificOutput]:
+        """
+        | Object containing the card payment method details
+
+        Type: :class:`worldline.connect.sdk.v1.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 cash_payment_method_specific_output(self) -> Optional[CashPaymentMethodSpecificOutput]:
+        """
+        | Object containing the cash payment method details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.cash_payment_method_specific_output.CashPaymentMethodSpecificOutput`
+        """
+        return self.__cash_payment_method_specific_output
+
+    @cash_payment_method_specific_output.setter
+    def cash_payment_method_specific_output(self, value: Optional[CashPaymentMethodSpecificOutput]) -> None:
+        self.__cash_payment_method_specific_output = value
+
+    @property
+    def direct_debit_payment_method_specific_output(self) -> Optional[NonSepaDirectDebitPaymentMethodSpecificOutput]:
+        """
+        | Object containing the non SEPA direct debit payment method details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.non_sepa_direct_debit_payment_method_specific_output.NonSepaDirectDebitPaymentMethodSpecificOutput`
+        """
+        return self.__direct_debit_payment_method_specific_output
+
+    @direct_debit_payment_method_specific_output.setter
+    def direct_debit_payment_method_specific_output(self, value: Optional[NonSepaDirectDebitPaymentMethodSpecificOutput]) -> None:
+        self.__direct_debit_payment_method_specific_output = value
+
+    @property
+    def e_invoice_payment_method_specific_output(self) -> Optional[EInvoicePaymentMethodSpecificOutput]:
+        """
+        | Object containing the e-invoice payment method details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.e_invoice_payment_method_specific_output.EInvoicePaymentMethodSpecificOutput`
+        """
+        return self.__e_invoice_payment_method_specific_output
+
+    @e_invoice_payment_method_specific_output.setter
+    def e_invoice_payment_method_specific_output(self, value: Optional[EInvoicePaymentMethodSpecificOutput]) -> None:
+        self.__e_invoice_payment_method_specific_output = value
+
+    @property
+    def invoice_payment_method_specific_output(self) -> Optional[InvoicePaymentMethodSpecificOutput]:
+        """
+        | Object containing the invoice payment method details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.invoice_payment_method_specific_output.InvoicePaymentMethodSpecificOutput`
+        """
+        return self.__invoice_payment_method_specific_output
+
+    @invoice_payment_method_specific_output.setter
+    def invoice_payment_method_specific_output(self, value: Optional[InvoicePaymentMethodSpecificOutput]) -> None:
+        self.__invoice_payment_method_specific_output = value
+
+    @property
+    def mobile_payment_method_specific_output(self) -> Optional[MobilePaymentMethodSpecificOutput]:
+        """
+        | Object containing the mobile payment method details
+
+        Type: :class:`worldline.connect.sdk.v1.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 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
+
+    @property
+    def redirect_payment_method_specific_output(self) -> Optional[RedirectPaymentMethodSpecificOutput]:
+        """
+        | Object containing the redirect payment product details
+
+        Type: :class:`worldline.connect.sdk.v1.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 reversal_reason(self) -> Optional[str]:
+        """
+        | The reason description given for the reversedAmount property.
+
+        Type: str
+        """
+        return self.__reversal_reason
+
+    @reversal_reason.setter
+    def reversal_reason(self, value: Optional[str]) -> None:
+        self.__reversal_reason = value
+
+    @property
+    def sepa_direct_debit_payment_method_specific_output(self) -> Optional[SepaDirectDebitPaymentMethodSpecificOutput]:
+        """
+        | Object containing the SEPA direct debit details
+
+        Type: :class:`worldline.connect.sdk.v1.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
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CaptureOutput, self).to_dictionary()
+        if self.amount_paid is not None:
+            dictionary['amountPaid'] = self.amount_paid
+        if self.amount_reversed is not None:
+            dictionary['amountReversed'] = self.amount_reversed
+        if self.bank_transfer_payment_method_specific_output is not None:
+            dictionary['bankTransferPaymentMethodSpecificOutput'] = self.bank_transfer_payment_method_specific_output.to_dictionary()
+        if self.card_payment_method_specific_output is not None:
+            dictionary['cardPaymentMethodSpecificOutput'] = self.card_payment_method_specific_output.to_dictionary()
+        if self.cash_payment_method_specific_output is not None:
+            dictionary['cashPaymentMethodSpecificOutput'] = self.cash_payment_method_specific_output.to_dictionary()
+        if self.direct_debit_payment_method_specific_output is not None:
+            dictionary['directDebitPaymentMethodSpecificOutput'] = self.direct_debit_payment_method_specific_output.to_dictionary()
+        if self.e_invoice_payment_method_specific_output is not None:
+            dictionary['eInvoicePaymentMethodSpecificOutput'] = self.e_invoice_payment_method_specific_output.to_dictionary()
+        if self.invoice_payment_method_specific_output is not None:
+            dictionary['invoicePaymentMethodSpecificOutput'] = self.invoice_payment_method_specific_output.to_dictionary()
+        if self.mobile_payment_method_specific_output is not None:
+            dictionary['mobilePaymentMethodSpecificOutput'] = self.mobile_payment_method_specific_output.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.reversal_reason is not None:
+            dictionary['reversalReason'] = self.reversal_reason
+        if self.sepa_direct_debit_payment_method_specific_output is not None:
+            dictionary['sepaDirectDebitPaymentMethodSpecificOutput'] = self.sepa_direct_debit_payment_method_specific_output.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CaptureOutput':
+        super(CaptureOutput, self).from_dictionary(dictionary)
+        if 'amountPaid' in dictionary:
+            self.amount_paid = dictionary['amountPaid']
+        if 'amountReversed' in dictionary:
+            self.amount_reversed = dictionary['amountReversed']
+        if 'bankTransferPaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['bankTransferPaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankTransferPaymentMethodSpecificOutput']))
+            value = BankTransferPaymentMethodSpecificOutput()
+            self.bank_transfer_payment_method_specific_output = value.from_dictionary(dictionary['bankTransferPaymentMethodSpecificOutput'])
+        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 'cashPaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['cashPaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cashPaymentMethodSpecificOutput']))
+            value = CashPaymentMethodSpecificOutput()
+            self.cash_payment_method_specific_output = value.from_dictionary(dictionary['cashPaymentMethodSpecificOutput'])
+        if 'directDebitPaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['directDebitPaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['directDebitPaymentMethodSpecificOutput']))
+            value = NonSepaDirectDebitPaymentMethodSpecificOutput()
+            self.direct_debit_payment_method_specific_output = value.from_dictionary(dictionary['directDebitPaymentMethodSpecificOutput'])
+        if 'eInvoicePaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['eInvoicePaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['eInvoicePaymentMethodSpecificOutput']))
+            value = EInvoicePaymentMethodSpecificOutput()
+            self.e_invoice_payment_method_specific_output = value.from_dictionary(dictionary['eInvoicePaymentMethodSpecificOutput'])
+        if 'invoicePaymentMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['invoicePaymentMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['invoicePaymentMethodSpecificOutput']))
+            value = InvoicePaymentMethodSpecificOutput()
+            self.invoice_payment_method_specific_output = value.from_dictionary(dictionary['invoicePaymentMethodSpecificOutput'])
+        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 '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 'reversalReason' in dictionary:
+            self.reversal_reason = dictionary['reversalReason']
+        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'])
+        return self

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

@@ -0,0 +1,60 @@
+# -*- 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 CapturePaymentRequest(DataObject):
+
+    __amount: Optional[int] = None
+    __is_final: Optional[bool] = 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 capture of this transaction.
+        | 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
+
+    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
+        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']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/capture_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.capture import Capture
+
+
+class CaptureResponse(Capture):
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CaptureResponse, self).to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CaptureResponse':
+        super(CaptureResponse, self).from_dictionary(dictionary)
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/capture_status_output.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 List, Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.key_value_pair import KeyValuePair
+
+
+class CaptureStatusOutput(DataObject):
+
+    __is_retriable: Optional[bool] = None
+    __provider_raw_output: Optional[List[KeyValuePair]] = None
+    __status_code: Optional[int] = None
+
+    @property
+    def is_retriable(self) -> Optional[bool]:
+        """
+        | Flag indicating whether a rejected payment may be retried by the merchant without incurring a fee 
+        
+        * true
+        * false
+
+        Type: bool
+        """
+        return self.__is_retriable
+
+    @is_retriable.setter
+    def is_retriable(self, value: Optional[bool]) -> None:
+        self.__is_retriable = value
+
+    @property
+    def provider_raw_output(self) -> Optional[List[KeyValuePair]]:
+        """
+        | This is the raw response returned by the acquirer. This property contains unprocessed data directly returned by the acquirer. It's recommended for data analysis only due to its dynamic nature, which may undergo future changes.
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.key_value_pair.KeyValuePair`]
+        """
+        return self.__provider_raw_output
+
+    @provider_raw_output.setter
+    def provider_raw_output(self, value: Optional[List[KeyValuePair]]) -> None:
+        self.__provider_raw_output = value
+
+    @property
+    def status_code(self) -> Optional[int]:
+        """
+        | Numeric status code of the legacy API. It is returned to ease the migration from the legacy APIs to Worldline Connect. You should not write new business logic based on this property as it will be deprecated in a future version of the API. The value can also be found in the GlobalCollect Payment Console, in the Ogone 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.is_retriable is not None:
+            dictionary['isRetriable'] = self.is_retriable
+        if self.provider_raw_output is not None:
+            dictionary['providerRawOutput'] = []
+            for element in self.provider_raw_output:
+                if element is not None:
+                    dictionary['providerRawOutput'].append(element.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 'isRetriable' in dictionary:
+            self.is_retriable = dictionary['isRetriable']
+        if 'providerRawOutput' in dictionary:
+            if not isinstance(dictionary['providerRawOutput'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['providerRawOutput']))
+            self.provider_raw_output = []
+            for element in dictionary['providerRawOutput']:
+                value = KeyValuePair()
+                self.provider_raw_output.append(value.from_dictionary(element))
+        if 'statusCode' in dictionary:
+            self.status_code = dictionary['statusCode']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/captures_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.capture import Capture
+
+
+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:`worldline.connect.sdk.v1.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

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

@@ -0,0 +1,56 @@
+# -*- 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.card_without_cvv import CardWithoutCvv
+
+
+class Card(CardWithoutCvv):
+
+    __cvv: Optional[str] = None
+    __partial_pin: Optional[str] = None
+
+    @property
+    def cvv(self) -> Optional[str]:
+        """
+        | Card Verification Value, a 3 or 4 digit code used as an additional security feature for card not present transactions.
+
+        Type: str
+        """
+        return self.__cvv
+
+    @cvv.setter
+    def cvv(self, value: Optional[str]) -> None:
+        self.__cvv = value
+
+    @property
+    def partial_pin(self) -> Optional[str]:
+        """
+        | The first 2 digits of the card's PIN code. May be optionally submitted for South Korean cards (paymentProductIds 180, 181, 182, 183, 184, 185 and 186). Submitting this property may improve your authorization rate.
+
+        Type: str
+        """
+        return self.__partial_pin
+
+    @partial_pin.setter
+    def partial_pin(self, value: Optional[str]) -> None:
+        self.__partial_pin = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Card, self).to_dictionary()
+        if self.cvv is not None:
+            dictionary['cvv'] = self.cvv
+        if self.partial_pin is not None:
+            dictionary['partialPin'] = self.partial_pin
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Card':
+        super(Card, self).from_dictionary(dictionary)
+        if 'cvv' in dictionary:
+            self.cvv = dictionary['cvv']
+        if 'partialPin' in dictionary:
+            self.partial_pin = dictionary['partialPin']
+        return self