connect-sdk-python2 4.6.0__tar.gz → 5.0.0__tar.gz

{connect-sdk-python2-4.6.0/connect_sdk_python2.egg-info → connect-sdk-python2-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: connect-sdk-python2
-Version: 4.6.0
+Version: 5.0.0
 Summary: SDK to communicate with the Worldline Global Collect platform using the Worldline Connect Server API
 Home-page: https://github.com/Worldline-Global-Collect/connect-sdk-python2
 Author: Worldline Global Collect

{connect-sdk-python2-4.6.0 → connect-sdk-python2-5.0.0/connect_sdk_python2.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: connect-sdk-python2
-Version: 4.6.0
+Version: 5.0.0
 Summary: SDK to communicate with the Worldline Global Collect platform using the Worldline Connect Server API
 Home-page: https://github.com/Worldline-Global-Collect/connect-sdk-python2
 Author: Worldline Global Collect

{connect-sdk-python2-4.6.0 → connect-sdk-python2-5.0.0}/connect_sdk_python2.egg-info/SOURCES.txt

@@ -321,6 +321,7 @@ worldline/connect/sdk/v1/domain/payment_context.py
 worldline/connect/sdk/v1/domain/payment_creation_output.py
 worldline/connect/sdk/v1/domain/payment_creation_references.py
 worldline/connect/sdk/v1/domain/payment_error_response.py
+worldline/connect/sdk/v1/domain/payment_operation.py
 worldline/connect/sdk/v1/domain/payment_output.py
 worldline/connect/sdk/v1/domain/payment_product.py
 worldline/connect/sdk/v1/domain/payment_product302_specific_data.py
@@ -475,6 +476,7 @@ worldline/connect/sdk/v1/merchant/mandates/__init__.py
 worldline/connect/sdk/v1/merchant/mandates/mandates_client.py
 worldline/connect/sdk/v1/merchant/payments/__init__.py
 worldline/connect/sdk/v1/merchant/payments/find_payments_params.py
+worldline/connect/sdk/v1/merchant/payments/get_payment_params.py
 worldline/connect/sdk/v1/merchant/payments/payments_client.py
 worldline/connect/sdk/v1/merchant/payouts/__init__.py
 worldline/connect/sdk/v1/merchant/payouts/find_payouts_params.py

{connect-sdk-python2-4.6.0 → connect-sdk-python2-5.0.0}/setup.py

@@ -21,7 +21,7 @@ def test_collector():
 
 setup(
     name="connect-sdk-python2",
-    version="4.6.0",
+    version="5.0.0",
     author="Worldline Global Collect",
     author_email="github.connect@worldline.com",
     description="SDK to communicate with the Worldline Global Collect platform using the Worldline Connect Server API",

{connect-sdk-python2-4.6.0 → connect-sdk-python2-5.0.0}/worldline/connect/sdk/communication/metadata_provider.py

@@ -21,7 +21,7 @@ class MetadataProvider(object):
     """
     Provides meta info about the server.
     """
-    __sdk_version = "4.6.0"
+    __sdk_version = "5.0.0"
     __server_meta_info_header = "X-GCS-ServerMetaInfo"
     __prohibited_headers = tuple(sorted([__server_meta_info_header, "X-GCS-Idempotence-Key", "Date", "Content-Type", "Authorization"],
                                         key=str.lower))

{connect-sdk-python2-4.6.0 → connect-sdk-python2-5.0.0}/worldline/connect/sdk/v1/domain/dispute.py

@@ -10,12 +10,26 @@ from worldline.connect.sdk.v1.domain.dispute_status_output import DisputeStatusO
 
 class Dispute(DataObject):
 
+    __capture_id = None
     __dispute_output = None
     __id = None
     __payment_id = None
     __status = None
     __status_output = None
 
+    @property
+    def capture_id(self):
+        """
+        | The ID of the capture that is being disputed.
+
+        Type: str
+        """
+        return self.__capture_id
+
+    @capture_id.setter
+    def capture_id(self, value):
+        self.__capture_id = value
+
     @property
     def dispute_output(self):
         """
@@ -83,6 +97,8 @@ class Dispute(DataObject):
 
     def to_dictionary(self):
         dictionary = super(Dispute, self).to_dictionary()
+        if self.capture_id is not None:
+            dictionary['captureId'] = self.capture_id
         if self.dispute_output is not None:
             dictionary['disputeOutput'] = self.dispute_output.to_dictionary()
         if self.id is not None:
@@ -97,6 +113,8 @@ class Dispute(DataObject):
 
     def from_dictionary(self, dictionary):
         super(Dispute, self).from_dictionary(dictionary)
+        if 'captureId' in dictionary:
+            self.capture_id = dictionary['captureId']
         if 'disputeOutput' in dictionary:
             if not isinstance(dictionary['disputeOutput'], dict):
                 raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['disputeOutput']))

{connect-sdk-python2-4.6.0 → connect-sdk-python2-5.0.0}/worldline/connect/sdk/v1/domain/external_cardholder_authentication_data.py

@@ -39,7 +39,12 @@ class ExternalCardholderAuthenticationData(DataObject):
     @property
     def applied_exemption(self):
         """
-        | Exemption code from Carte Bancaire (130) (unknown possible values so far -free format).
+        | When you request an exemptions via your non-Worldline 3D Secure provider successfully, you need to provide in this property the exemption that was granted, in combination with all 3DS results given by issuer.
+        | Possible values:
+        
+        * transaction-risk-analysis - You have determined that this transaction is of low risk and are willing to take the liability. Please note that your fraud rate needs to stay below thresholds to allow your use of this exemption.
+        * low-value - The value of the transaction is below 30 EUR. Please note that the issuer will still require every 5th low-value transaction pithing 24 hours to be strongly authenticated. The issuer will also keep track of the cumulative amount authorized on the card. When this exceeds 100 EUR strong customer authentication is also required.
+        * whitelist - You have been whitelisted by the customer at the issuer.
 
         Type: str
         """
@@ -132,6 +137,10 @@ class ExternalCardholderAuthenticationData(DataObject):
         * 1.0.2
         * 2.1.0
         * 2.2.0
+        * 2.3
+        * 2.3.0
+        * 2.3.1
+        * 2.3.1.1
 
         Type: str
         """

connect-sdk-python2-5.0.0/worldline/connect/sdk/v1/domain/payment_operation.py

@@ -0,0 +1,132 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.amount_of_money import AmountOfMoney
+
+
+class PaymentOperation(DataObject):
+
+    __amount_of_money = None
+    __id = None
+    __status = None
+    __timestamp = None
+    __type = None
+
+    @property
+    def amount_of_money(self):
+        """
+        | 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):
+        self.__amount_of_money = value
+
+    @property
+    def id(self):
+        """
+        | A unique identifier of the operation, generated by us.
+
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value):
+        self.__id = value
+
+    @property
+    def status(self):
+        """
+        | Status of the operation. Possible values of a capture operation are:
+        
+        * CREATED
+        * REJECTED
+        * CANCELLED
+        * CAPTURED
+        * PAID
+        * CHARGEBACKED
+        * CHARGEBACK_NOTIFICATION
+        
+        
+        
+        | Possible values of a refund operation are:
+        
+        * CREATED
+        * PENDING_CAPTURE
+        * REJECTED
+        * REFUNDED
+
+        Type: str
+        """
+        return self.__status
+
+    @status.setter
+    def status(self, value):
+        self.__status = value
+
+    @property
+    def timestamp(self):
+        """
+        | Date and time of the operation.Format: YYYYMMDDHH24MISS
+
+        Type: str
+        """
+        return self.__timestamp
+
+    @timestamp.setter
+    def timestamp(self, value):
+        self.__timestamp = value
+
+    @property
+    def type(self):
+        """
+        | The type of operation. Possible values are: 
+        
+        * capture
+        * refund
+
+        Type: str
+        """
+        return self.__type
+
+    @type.setter
+    def type(self, value):
+        self.__type = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentOperation, self).to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.status is not None:
+            dictionary['status'] = self.status
+        if self.timestamp is not None:
+            dictionary['timestamp'] = self.timestamp
+        if self.type is not None:
+            dictionary['type'] = self.type
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentOperation, 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 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'status' in dictionary:
+            self.status = dictionary['status']
+        if 'timestamp' in dictionary:
+            self.timestamp = dictionary['timestamp']
+        if 'type' in dictionary:
+            self.type = dictionary['type']
+        return self

{connect-sdk-python2-4.6.0 → connect-sdk-python2-5.0.0}/worldline/connect/sdk/v1/domain/payment_output.py

@@ -11,13 +11,18 @@ from worldline.connect.sdk.v1.domain.invoice_payment_method_specific_output impo
 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.payment_operation import PaymentOperation
 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 PaymentOutput(OrderOutput):
 
+    __amount_capture_requested = None
+    __amount_captured = None
     __amount_paid = None
+    __amount_refund_requested = None
+    __amount_refunded = None
     __amount_reversed = None
     __bank_transfer_payment_method_specific_output = None
     __card_payment_method_specific_output = None
@@ -26,11 +31,38 @@ class PaymentOutput(OrderOutput):
     __e_invoice_payment_method_specific_output = None
     __invoice_payment_method_specific_output = None
     __mobile_payment_method_specific_output = None
+    __operations = None
     __payment_method = None
     __redirect_payment_method_specific_output = None
     __reversal_reason = None
     __sepa_direct_debit_payment_method_specific_output = None
 
+    @property
+    def amount_capture_requested(self):
+        """
+        | Amount that has been requested to be captured.
+
+        Type: long
+        """
+        return self.__amount_capture_requested
+
+    @amount_capture_requested.setter
+    def amount_capture_requested(self, value):
+        self.__amount_capture_requested = value
+
+    @property
+    def amount_captured(self):
+        """
+        | Amount that has been captured.
+
+        Type: long
+        """
+        return self.__amount_captured
+
+    @amount_captured.setter
+    def amount_captured(self, value):
+        self.__amount_captured = value
+
     @property
     def amount_paid(self):
         """
@@ -44,6 +76,32 @@ class PaymentOutput(OrderOutput):
     def amount_paid(self, value):
         self.__amount_paid = value
 
+    @property
+    def amount_refund_requested(self):
+        """
+        | Amount that has been requested to be refunded.
+
+        Type: long
+        """
+        return self.__amount_refund_requested
+
+    @amount_refund_requested.setter
+    def amount_refund_requested(self, value):
+        self.__amount_refund_requested = value
+
+    @property
+    def amount_refunded(self):
+        """
+        | Amount that has been refunded.
+
+        Type: long
+        """
+        return self.__amount_refunded
+
+    @amount_refunded.setter
+    def amount_refunded(self, value):
+        self.__amount_refunded = value
+
     @property
     def amount_reversed(self):
         """
@@ -148,6 +206,19 @@ class PaymentOutput(OrderOutput):
     def mobile_payment_method_specific_output(self, value):
         self.__mobile_payment_method_specific_output = value
 
+    @property
+    def operations(self):
+        """
+        | An object array containing information of captures and refunds.
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.payment_operation.PaymentOperation`]
+        """
+        return self.__operations
+
+    @operations.setter
+    def operations(self, value):
+        self.__operations = value
+
     @property
     def payment_method(self):
         """
@@ -211,8 +282,16 @@ class PaymentOutput(OrderOutput):
 
     def to_dictionary(self):
         dictionary = super(PaymentOutput, self).to_dictionary()
+        if self.amount_capture_requested is not None:
+            dictionary['amountCaptureRequested'] = self.amount_capture_requested
+        if self.amount_captured is not None:
+            dictionary['amountCaptured'] = self.amount_captured
         if self.amount_paid is not None:
             dictionary['amountPaid'] = self.amount_paid
+        if self.amount_refund_requested is not None:
+            dictionary['amountRefundRequested'] = self.amount_refund_requested
+        if self.amount_refunded is not None:
+            dictionary['amountRefunded'] = self.amount_refunded
         if self.amount_reversed is not None:
             dictionary['amountReversed'] = self.amount_reversed
         if self.bank_transfer_payment_method_specific_output is not None:
@@ -229,6 +308,11 @@ class PaymentOutput(OrderOutput):
             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.operations is not None:
+            dictionary['operations'] = []
+            for element in self.operations:
+                if element is not None:
+                    dictionary['operations'].append(element.to_dictionary())
         if self.payment_method is not None:
             dictionary['paymentMethod'] = self.payment_method
         if self.redirect_payment_method_specific_output is not None:
@@ -241,8 +325,16 @@ class PaymentOutput(OrderOutput):
 
     def from_dictionary(self, dictionary):
         super(PaymentOutput, self).from_dictionary(dictionary)
+        if 'amountCaptureRequested' in dictionary:
+            self.amount_capture_requested = dictionary['amountCaptureRequested']
+        if 'amountCaptured' in dictionary:
+            self.amount_captured = dictionary['amountCaptured']
         if 'amountPaid' in dictionary:
             self.amount_paid = dictionary['amountPaid']
+        if 'amountRefundRequested' in dictionary:
+            self.amount_refund_requested = dictionary['amountRefundRequested']
+        if 'amountRefunded' in dictionary:
+            self.amount_refunded = dictionary['amountRefunded']
         if 'amountReversed' in dictionary:
             self.amount_reversed = dictionary['amountReversed']
         if 'bankTransferPaymentMethodSpecificOutput' in dictionary:
@@ -280,6 +372,13 @@ class PaymentOutput(OrderOutput):
                 raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mobilePaymentMethodSpecificOutput']))
             value = MobilePaymentMethodSpecificOutput()
             self.mobile_payment_method_specific_output = value.from_dictionary(dictionary['mobilePaymentMethodSpecificOutput'])
+        if 'operations' in dictionary:
+            if not isinstance(dictionary['operations'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['operations']))
+            self.operations = []
+            for element in dictionary['operations']:
+                value = PaymentOperation()
+                self.operations.append(value.from_dictionary(element))
         if 'paymentMethod' in dictionary:
             self.payment_method = dictionary['paymentMethod']
         if 'redirectPaymentMethodSpecificOutput' in dictionary:

{connect-sdk-python2-4.6.0 → connect-sdk-python2-5.0.0}/worldline/connect/sdk/v1/domain/webhooks_event.py

@@ -4,6 +4,7 @@
 # https://apireference.connect.worldline-solutions.com/
 #
 from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.capture_response import CaptureResponse
 from worldline.connect.sdk.v1.domain.dispute_response import DisputeResponse
 from worldline.connect.sdk.v1.domain.payment_response import PaymentResponse
 from worldline.connect.sdk.v1.domain.payout_response import PayoutResponse
@@ -14,6 +15,7 @@ from worldline.connect.sdk.v1.domain.token_response import TokenResponse
 class WebhooksEvent(DataObject):
 
     __api_version = None
+    __capture = None
     __created = None
     __dispute = None
     __id = None
@@ -35,6 +37,17 @@ class WebhooksEvent(DataObject):
     def api_version(self, value):
         self.__api_version = value
 
+    @property
+    def capture(self):
+        """
+        Type: :class:`worldline.connect.sdk.v1.domain.capture_response.CaptureResponse`
+        """
+        return self.__capture
+
+    @capture.setter
+    def capture(self, value):
+        self.__capture = value
+
     @property
     def created(self):
         """
@@ -138,6 +151,8 @@ class WebhooksEvent(DataObject):
         dictionary = super(WebhooksEvent, self).to_dictionary()
         if self.api_version is not None:
             dictionary['apiVersion'] = self.api_version
+        if self.capture is not None:
+            dictionary['capture'] = self.capture.to_dictionary()
         if self.created is not None:
             dictionary['created'] = self.created
         if self.dispute is not None:
@@ -162,6 +177,11 @@ class WebhooksEvent(DataObject):
         super(WebhooksEvent, self).from_dictionary(dictionary)
         if 'apiVersion' in dictionary:
             self.api_version = dictionary['apiVersion']
+        if 'capture' in dictionary:
+            if not isinstance(dictionary['capture'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['capture']))
+            value = CaptureResponse()
+            self.capture = value.from_dictionary(dictionary['capture'])
         if 'created' in dictionary:
             self.created = dictionary['created']
         if 'dispute' in dictionary:

connect-sdk-python2-5.0.0/worldline/connect/sdk/v1/merchant/captures/captures_client.py

@@ -0,0 +1,175 @@
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.api_resource import ApiResource
+from worldline.connect.sdk.communication.response_exception import ResponseException
+from worldline.connect.sdk.v1.domain.capture_response import CaptureResponse
+from worldline.connect.sdk.v1.domain.dispute_response import DisputeResponse
+from worldline.connect.sdk.v1.domain.disputes_response import DisputesResponse
+from worldline.connect.sdk.v1.domain.error_response import ErrorResponse
+from worldline.connect.sdk.v1.domain.refund_error_response import RefundErrorResponse
+from worldline.connect.sdk.v1.domain.refund_response import RefundResponse
+from worldline.connect.sdk.v1.exception_factory import create_exception
+
+
+class CapturesClient(ApiResource):
+    """
+    Captures client. Thread-safe.
+    """
+
+    def __init__(self, parent, path_context):
+        """
+        :param parent:       :class:`worldline.connect.sdk.api_resource.ApiResource`
+        :param path_context: dict[str, str]
+        """
+        super(CapturesClient, self).__init__(parent=parent, path_context=path_context)
+
+    def get(self, capture_id, context=None):
+        """
+        Resource /{merchantId}/captures/{captureId} - Get capture
+
+        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/captures/get.html
+
+        :param capture_id:  str
+        :param context:     :class:`worldline.connect.sdk.call_context.CallContext`
+        :return: :class:`worldline.connect.sdk.v1.domain.capture_response.CaptureResponse`
+        :raise IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :raise ValidationException: if the request was not correct and couldn't be processed (HTTP status code 400)
+        :raise AuthorizationException: if the request was not allowed (HTTP status code 403)
+        :raise ReferenceException: if an object was attempted to be referenced that doesn't exist or has been removed,
+                   or there was a conflict (HTTP status code 404, 409 or 410)
+        :raise PlatformException: if something went wrong at the Worldline Global Collect platform,
+                   the Worldline Global Collect platform was unable to process a message from a downstream partner/acquirer,
+                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
+        :raise ApiException: if the Worldline Global Collect platform returned any other error
+        """
+        path_context = {
+            "captureId": capture_id,
+        }
+        uri = self._instantiate_uri("/v1/{merchantId}/captures/{captureId}", path_context)
+        try:
+            return self._communicator.get(
+                    uri,
+                    self._client_headers,
+                    None,
+                    CaptureResponse,
+                    context)
+
+        except ResponseException as e:
+            error_type = ErrorResponse
+            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
+            raise create_exception(e.status_code, e.body, error_object, context)
+
+    def refund(self, capture_id, body, context=None):
+        """
+        Resource /{merchantId}/captures/{captureId}/refund - Create Refund
+
+        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/captures/refund.html
+
+        :param capture_id:  str
+        :param body:        :class:`worldline.connect.sdk.v1.domain.refund_request.RefundRequest`
+        :param context:     :class:`worldline.connect.sdk.call_context.CallContext`
+        :return: :class:`worldline.connect.sdk.v1.domain.refund_response.RefundResponse`
+        :raise DeclinedRefundException: if the Worldline Global Collect platform declined / rejected the refund. The refund result will be available from the exception.
+        :raise IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :raise ValidationException: if the request was not correct and couldn't be processed (HTTP status code 400)
+        :raise AuthorizationException: if the request was not allowed (HTTP status code 403)
+        :raise ReferenceException: if an object was attempted to be referenced that doesn't exist or has been removed,
+                   or there was a conflict (HTTP status code 404, 409 or 410)
+        :raise PlatformException: if something went wrong at the Worldline Global Collect platform,
+                   the Worldline Global Collect platform was unable to process a message from a downstream partner/acquirer,
+                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
+        :raise ApiException: if the Worldline Global Collect platform returned any other error
+        """
+        path_context = {
+            "captureId": capture_id,
+        }
+        uri = self._instantiate_uri("/v1/{merchantId}/captures/{captureId}/refund", path_context)
+        try:
+            return self._communicator.post(
+                    uri,
+                    self._client_headers,
+                    None,
+                    body,
+                    RefundResponse,
+                    context)
+
+        except ResponseException as e:
+            error_type = RefundErrorResponse
+            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
+            raise create_exception(e.status_code, e.body, error_object, context)
+
+    def disputes(self, capture_id, context=None):
+        """
+        Resource /{merchantId}/captures/{captureId}/disputes - Get disputes
+
+        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/captures/disputes.html
+
+        :param capture_id:  str
+        :param context:     :class:`worldline.connect.sdk.call_context.CallContext`
+        :return: :class:`worldline.connect.sdk.v1.domain.disputes_response.DisputesResponse`
+        :raise IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :raise ValidationException: if the request was not correct and couldn't be processed (HTTP status code 400)
+        :raise AuthorizationException: if the request was not allowed (HTTP status code 403)
+        :raise ReferenceException: if an object was attempted to be referenced that doesn't exist or has been removed,
+                   or there was a conflict (HTTP status code 404, 409 or 410)
+        :raise PlatformException: if something went wrong at the Worldline Global Collect platform,
+                   the Worldline Global Collect platform was unable to process a message from a downstream partner/acquirer,
+                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
+        :raise ApiException: if the Worldline Global Collect platform returned any other error
+        """
+        path_context = {
+            "captureId": capture_id,
+        }
+        uri = self._instantiate_uri("/v1/{merchantId}/captures/{captureId}/disputes", path_context)
+        try:
+            return self._communicator.get(
+                    uri,
+                    self._client_headers,
+                    None,
+                    DisputesResponse,
+                    context)
+
+        except ResponseException as e:
+            error_type = ErrorResponse
+            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
+            raise create_exception(e.status_code, e.body, error_object, context)
+
+    def dispute(self, capture_id, body, context=None):
+        """
+        Resource /{merchantId}/captures/{captureId}/dispute - Create dispute
+
+        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/captures/dispute.html
+
+        :param capture_id:  str
+        :param body:        :class:`worldline.connect.sdk.v1.domain.create_dispute_request.CreateDisputeRequest`
+        :param context:     :class:`worldline.connect.sdk.call_context.CallContext`
+        :return: :class:`worldline.connect.sdk.v1.domain.dispute_response.DisputeResponse`
+        :raise IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :raise ValidationException: if the request was not correct and couldn't be processed (HTTP status code 400)
+        :raise AuthorizationException: if the request was not allowed (HTTP status code 403)
+        :raise ReferenceException: if an object was attempted to be referenced that doesn't exist or has been removed,
+                   or there was a conflict (HTTP status code 404, 409 or 410)
+        :raise PlatformException: if something went wrong at the Worldline Global Collect platform,
+                   the Worldline Global Collect platform was unable to process a message from a downstream partner/acquirer,
+                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
+        :raise ApiException: if the Worldline Global Collect platform returned any other error
+        """
+        path_context = {
+            "captureId": capture_id,
+        }
+        uri = self._instantiate_uri("/v1/{merchantId}/captures/{captureId}/dispute", path_context)
+        try:
+            return self._communicator.post(
+                    uri,
+                    self._client_headers,
+                    None,
+                    body,
+                    DisputeResponse,
+                    context)
+
+        except ResponseException as e:
+            error_type = ErrorResponse
+            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
+            raise create_exception(e.status_code, e.body, error_object, context)