connect-sdk-python2 4.0.0__zip → 4.1.0__zip

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/idempotence_exception.py

@@ -1,33 +0,0 @@
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from api_exception import ApiException
-
-
-class IdempotenceException(ApiException):
-    """
-    Represents an error response from the Worldline Global Collect platform when an
-    idempotent request failed because the first request has not finished yet.
-    """
-
-    def __init__(self, idempotence_key, idempotence_request_timestamp,
-                 status_code, response_body, error_id, errors,
-                 message="the Worldline Global Collect platform returned a duplicate request error response"):
-        super(IdempotenceException, self).__init__(status_code, response_body, error_id, errors, message)
-        self.__idempotence_key = idempotence_key
-        self.__idempotence_request_timestamp = idempotence_request_timestamp
-
-    @property
-    def idempotence_key(self):
-        """
-        :return: The key that was used for the idempotent request.
-        """
-        return self.__idempotence_key
-
-    @property
-    def idempotence_request_timestamp(self):
-        """
-        :return: The request timestamp of the first idempotent request with the same key.
-        """
-        return self.__idempotence_request_timestamp

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

@@ -1,97 +0,0 @@
-#
-# 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.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: 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: 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)

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/merchant/disputes/disputes_client.py

@@ -1,167 +0,0 @@
-#
-# 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.dispute_response import DisputeResponse
-from worldline.connect.sdk.v1.domain.error_response import ErrorResponse
-from worldline.connect.sdk.v1.domain.upload_dispute_file_response import UploadDisputeFileResponse
-from worldline.connect.sdk.v1.exception_factory import create_exception
-
-
-class DisputesClient(ApiResource):
-    """
-    Disputes 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(DisputesClient, self).__init__(parent=parent, path_context=path_context)
-
-    def get(self, dispute_id, context=None):
-        """
-        Resource /{merchantId}/disputes/{disputeId} - Get dispute
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/disputes/get.html
-
-        :param dispute_id:  str
-        :param context:     :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.dispute_response.DisputeResponse`
-        :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 = {
-            "disputeId": dispute_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/disputes/{disputeId}", path_context)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    None,
-                    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)
-
-    def submit(self, dispute_id, context=None):
-        """
-        Resource /{merchantId}/disputes/{disputeId}/submit - Submit dispute
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/disputes/submit.html
-
-        :param dispute_id:  str
-        :param context:     :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.dispute_response.DisputeResponse`
-        :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 = {
-            "disputeId": dispute_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/disputes/{disputeId}/submit", path_context)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    None,
-                    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)
-
-    def cancel(self, dispute_id, context=None):
-        """
-        Resource /{merchantId}/disputes/{disputeId}/cancel - Cancel dispute
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/disputes/cancel.html
-
-        :param dispute_id:  str
-        :param context:     :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.dispute_response.DisputeResponse`
-        :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 = {
-            "disputeId": dispute_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/disputes/{disputeId}/cancel", path_context)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    None,
-                    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)
-
-    def upload_file(self, dispute_id, body, context=None):
-        """
-        Resource /{merchantId}/disputes/{disputeId} - Upload File
-        
-        See also https://apireference.connect.worldline-solutions.com/fileserviceapi/v1/en_US/python/disputes/uploadFile.html
-
-        :param dispute_id:  str
-        :param body:        :class:`worldline.connect.sdk.v1.merchant.disputes.upload_file_request.UploadFileRequest`
-        :param context:     :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.upload_dispute_file_response.UploadDisputeFileResponse`
-        :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 = {
-            "disputeId": dispute_id,
-        }
-        uri = self._instantiate_uri("/files/v1/{merchantId}/disputes/{disputeId}", path_context)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    UploadDisputeFileResponse,
-                    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)

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/merchant/disputes/upload_file_request.py

@@ -1,39 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.communication.multipart_form_data_request import MultipartFormDataRequest
-from worldline.connect.sdk.communication.multipart_form_data_object import MultipartFormDataObject
-
-
-class UploadFileRequest(MultipartFormDataRequest):
-    """
-    Multipart/form-data parameters for Upload File
-    
-    See also https://apireference.connect.worldline-solutions.com/fileserviceapi/v1/en_US/python/disputes/uploadFile.html
-    """
-
-    __file = None
-
-    @property
-    def file(self):
-        """
-        | The file that you will upload as evidence to support a dispute.
-        
-        Type: :class:`worldline.connect.sdk.UploadableFile`
-        """
-        return self.__file
-
-    @file.setter
-    def file(self, value):
-        self.__file = value
-
-    def to_multipart_form_data_object(self):
-        """
-        :return: :class:`worldline.connect.sdk.MultipartFormDataObject`
-        """
-        result = MultipartFormDataObject()
-        if self.file is not None:
-            result.add_file("file", self.file)
-        return result

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/merchant/files/files_client.py

@@ -1,55 +0,0 @@
-#
-# 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.error_response import ErrorResponse
-from worldline.connect.sdk.v1.exception_factory import create_exception
-
-
-class FilesClient(ApiResource):
-    """
-    Files 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(FilesClient, self).__init__(parent=parent, path_context=path_context)
-
-    def get_file(self, file_id, context=None):
-        """
-        Resource /{merchantId}/files/{fileId} - Retrieve File
-        
-        See also https://apireference.connect.worldline-solutions.com/fileserviceapi/v1/en_US/python/files/getFile.html
-
-        :param file_id:  str
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: a tuple with the headers and a generator of body chunks
-        :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 = {
-            "fileId": file_id,
-        }
-        uri = self._instantiate_uri("/files/v1/{merchantId}/files/{fileId}", path_context)
-        try:
-            return self._communicator.get_with_binary_response(
-                    uri,
-                    self._client_headers,
-                    None,
-                    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)

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/merchant/hostedcheckouts/hostedcheckouts_client.py

@@ -1,126 +0,0 @@
-#
-# 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.create_hosted_checkout_response import CreateHostedCheckoutResponse
-from worldline.connect.sdk.v1.domain.error_response import ErrorResponse
-from worldline.connect.sdk.v1.domain.get_hosted_checkout_response import GetHostedCheckoutResponse
-from worldline.connect.sdk.v1.exception_factory import create_exception
-
-
-class HostedcheckoutsClient(ApiResource):
-    """
-    Hostedcheckouts 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(HostedcheckoutsClient, self).__init__(parent=parent, path_context=path_context)
-
-    def create(self, body, context=None):
-        """
-        Resource /{merchantId}/hostedcheckouts - Create hosted checkout
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/hostedcheckouts/create.html
-
-        :param body:     :class:`worldline.connect.sdk.v1.domain.create_hosted_checkout_request.CreateHostedCheckoutRequest`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.create_hosted_checkout_response.CreateHostedCheckoutResponse`
-        :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
-        """
-        uri = self._instantiate_uri("/v1/{merchantId}/hostedcheckouts", None)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    CreateHostedCheckoutResponse,
-                    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 get(self, hosted_checkout_id, context=None):
-        """
-        Resource /{merchantId}/hostedcheckouts/{hostedCheckoutId} - Get hosted checkout status
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/hostedcheckouts/get.html
-
-        :param hosted_checkout_id:  str
-        :param context:             :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.get_hosted_checkout_response.GetHostedCheckoutResponse`
-        :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 = {
-            "hostedCheckoutId": hosted_checkout_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/hostedcheckouts/{hostedCheckoutId}", path_context)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    None,
-                    GetHostedCheckoutResponse,
-                    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 delete(self, hosted_checkout_id, context=None):
-        """
-        Resource /{merchantId}/hostedcheckouts/{hostedCheckoutId} - Delete hosted checkout
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/hostedcheckouts/delete.html
-
-        :param hosted_checkout_id:  str
-        :param context:             :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: None
-        :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 = {
-            "hostedCheckoutId": hosted_checkout_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/hostedcheckouts/{hostedCheckoutId}", path_context)
-        try:
-            return self._communicator.delete(
-                    uri,
-                    self._client_headers,
-                    None,
-                    None,
-                    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)

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/merchant/hostedmandatemanagements/hostedmandatemanagements_client.py

@@ -1,91 +0,0 @@
-#
-# 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.create_hosted_mandate_management_response import CreateHostedMandateManagementResponse
-from worldline.connect.sdk.v1.domain.error_response import ErrorResponse
-from worldline.connect.sdk.v1.domain.get_hosted_mandate_management_response import GetHostedMandateManagementResponse
-from worldline.connect.sdk.v1.exception_factory import create_exception
-
-
-class HostedmandatemanagementsClient(ApiResource):
-    """
-    Hostedmandatemanagements 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(HostedmandatemanagementsClient, self).__init__(parent=parent, path_context=path_context)
-
-    def create(self, body, context=None):
-        """
-        Resource /{merchantId}/hostedmandatemanagements - Create hosted mandate management
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/hostedmandatemanagements/create.html
-
-        :param body:     :class:`worldline.connect.sdk.v1.domain.create_hosted_mandate_management_request.CreateHostedMandateManagementRequest`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.create_hosted_mandate_management_response.CreateHostedMandateManagementResponse`
-        :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
-        """
-        uri = self._instantiate_uri("/v1/{merchantId}/hostedmandatemanagements", None)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    CreateHostedMandateManagementResponse,
-                    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 get(self, hosted_mandate_management_id, context=None):
-        """
-        Resource /{merchantId}/hostedmandatemanagements/{hostedMandateManagementId} - Get hosted mandate management status
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/hostedmandatemanagements/get.html
-
-        :param hosted_mandate_management_id:  str
-        :param context:                       :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.get_hosted_mandate_management_response.GetHostedMandateManagementResponse`
-        :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 = {
-            "hostedMandateManagementId": hosted_mandate_management_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/hostedmandatemanagements/{hostedMandateManagementId}", path_context)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    None,
-                    GetHostedMandateManagementResponse,
-                    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)