connect-sdk-python2 4.0.0__zip → 4.1.0__zip

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/merchant/services/convert_amount_params.py

@@ -1,71 +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.param_request import ParamRequest
-from worldline.connect.sdk.communication.request_param import RequestParam
-
-
-class ConvertAmountParams(ParamRequest):
-    """
-    Query parameters for Convert amount
-    
-    See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/services/convertAmount.html
-    """
-
-    __source = None
-    __target = None
-    __amount = None
-
-    @property
-    def source(self):
-        """
-        | Three-letter ISO currency code representing the source currency
-        
-        Type: str
-        """
-        return self.__source
-
-    @source.setter
-    def source(self, value):
-        self.__source = value
-
-    @property
-    def target(self):
-        """
-        | Three-letter ISO currency code representing the target currency
-        
-        Type: str
-        """
-        return self.__target
-
-    @target.setter
-    def target(self, value):
-        self.__target = value
-
-    @property
-    def amount(self):
-        """
-        | Amount to be converted in cents and always having 2 decimals
-        
-        Type: long
-        """
-        return self.__amount
-
-    @amount.setter
-    def amount(self, value):
-        self.__amount = value
-
-    def to_request_parameters(self):
-        """
-        :return: list[RequestParam]
-        """
-        result = []
-        if self.source is not None:
-            result.append(RequestParam("source", self.source))
-        if self.target is not None:
-            result.append(RequestParam("target", self.target))
-        if self.amount is not None:
-            result.append(RequestParam("amount", str(self.amount)))
-        return result

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/merchant/services/privacypolicy_params.py

@@ -1,55 +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.param_request import ParamRequest
-from worldline.connect.sdk.communication.request_param import RequestParam
-
-
-class PrivacypolicyParams(ParamRequest):
-    """
-    Query parameters for Get privacy policy
-    
-    See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/services/privacypolicy.html
-    """
-
-    __locale = None
-    __payment_product_id = None
-
-    @property
-    def locale(self):
-        """
-        | Locale in which the privacy policy should be returned. Uses your default locale when none is provided.
-        
-        Type: str
-        """
-        return self.__locale
-
-    @locale.setter
-    def locale(self, value):
-        self.__locale = value
-
-    @property
-    def payment_product_id(self):
-        """
-        | ID of the payment product for which you wish to retrieve the privacy policy. When no ID is provided you will receive all privacy policies for your payment products.
-        
-        Type: int
-        """
-        return self.__payment_product_id
-
-    @payment_product_id.setter
-    def payment_product_id(self, value):
-        self.__payment_product_id = value
-
-    def to_request_parameters(self):
-        """
-        :return: list[RequestParam]
-        """
-        result = []
-        if self.locale is not None:
-            result.append(RequestParam("locale", self.locale))
-        if self.payment_product_id is not None:
-            result.append(RequestParam("paymentProductId", str(self.payment_product_id)))
-        return result

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/merchant/services/services_client.py

@@ -1,187 +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.bank_details_response import BankDetailsResponse
-from worldline.connect.sdk.v1.domain.convert_amount import ConvertAmount
-from worldline.connect.sdk.v1.domain.error_response import ErrorResponse
-from worldline.connect.sdk.v1.domain.get_iin_details_response import GetIINDetailsResponse
-from worldline.connect.sdk.v1.domain.get_privacy_policy_response import GetPrivacyPolicyResponse
-from worldline.connect.sdk.v1.domain.test_connection import TestConnection
-from worldline.connect.sdk.v1.exception_factory import create_exception
-
-
-class ServicesClient(ApiResource):
-    """
-    Services 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(ServicesClient, self).__init__(parent=parent, path_context=path_context)
-
-    def convert_amount(self, query, context=None):
-        """
-        Resource /{merchantId}/services/convert/amount - Convert amount
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/services/convertAmount.html
-
-        :param query:    :class:`worldline.connect.sdk.v1.merchant.services.convert_amount_params.ConvertAmountParams`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.convert_amount.ConvertAmount`
-        :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}/services/convert/amount", None)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    query,
-                    ConvertAmount,
-                    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 bankaccount(self, body, context=None):
-        """
-        Resource /{merchantId}/services/convert/bankaccount - Convert bankaccount
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/services/bankaccount.html
-
-        :param body:     :class:`worldline.connect.sdk.v1.domain.bank_details_request.BankDetailsRequest`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.bank_details_response.BankDetailsResponse`
-        :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}/services/convert/bankaccount", None)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    BankDetailsResponse,
-                    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_iin_details(self, body, context=None):
-        """
-        Resource /{merchantId}/services/getIINdetails - Get IIN details
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/services/getIINdetails.html
-
-        :param body:     :class:`worldline.connect.sdk.v1.domain.get_iin_details_request.GetIINDetailsRequest`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.get_iin_details_response.GetIINDetailsResponse`
-        :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}/services/getIINdetails", None)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    GetIINDetailsResponse,
-                    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 privacypolicy(self, query, context=None):
-        """
-        Resource /{merchantId}/services/privacypolicy - Get privacy policy
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/services/privacypolicy.html
-
-        :param query:    :class:`worldline.connect.sdk.v1.merchant.services.privacypolicy_params.PrivacypolicyParams`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.get_privacy_policy_response.GetPrivacyPolicyResponse`
-        :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}/services/privacypolicy", None)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    query,
-                    GetPrivacyPolicyResponse,
-                    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 testconnection(self, context=None):
-        """
-        Resource /{merchantId}/services/testconnection - Test connection
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/services/testconnection.html
-
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.test_connection.TestConnection`
-        :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}/services/testconnection", None)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    None,
-                    TestConnection,
-                    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/sessions/sessions_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.domain.session_response import SessionResponse
-from worldline.connect.sdk.v1.exception_factory import create_exception
-
-
-class SessionsClient(ApiResource):
-    """
-    Sessions 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(SessionsClient, self).__init__(parent=parent, path_context=path_context)
-
-    def create(self, body, context=None):
-        """
-        Resource /{merchantId}/sessions - Create session
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/sessions/create.html
-
-        :param body:     :class:`worldline.connect.sdk.v1.domain.session_request.SessionRequest`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.session_response.SessionResponse`
-        :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}/sessions", None)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    SessionResponse,
-                    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/tokens/delete_token_params.py

@@ -1,40 +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.param_request import ParamRequest
-from worldline.connect.sdk.communication.request_param import RequestParam
-
-
-class DeleteTokenParams(ParamRequest):
-    """
-    Query parameters for Delete token
-    
-    See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/tokens/delete.html
-    """
-
-    __mandate_cancel_date = None
-
-    @property
-    def mandate_cancel_date(self):
-        """
-        | Date of the mandate cancellation
-        | Format: YYYYMMDD
-        
-        Type: str
-        """
-        return self.__mandate_cancel_date
-
-    @mandate_cancel_date.setter
-    def mandate_cancel_date(self, value):
-        self.__mandate_cancel_date = value
-
-    def to_request_parameters(self):
-        """
-        :return: list[RequestParam]
-        """
-        result = []
-        if self.mandate_cancel_date is not None:
-            result.append(RequestParam("mandateCancelDate", self.mandate_cancel_date))
-        return result

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/merchant/tokens/tokens_client.py

@@ -1,201 +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_token_response import CreateTokenResponse
-from worldline.connect.sdk.v1.domain.error_response import ErrorResponse
-from worldline.connect.sdk.v1.domain.token_response import TokenResponse
-from worldline.connect.sdk.v1.exception_factory import create_exception
-
-
-class TokensClient(ApiResource):
-    """
-    Tokens 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(TokensClient, self).__init__(parent=parent, path_context=path_context)
-
-    def create(self, body, context=None):
-        """
-        Resource /{merchantId}/tokens - Create token
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/tokens/create.html
-
-        :param body:     :class:`worldline.connect.sdk.v1.domain.create_token_request.CreateTokenRequest`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.create_token_response.CreateTokenResponse`
-        :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}/tokens", None)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    CreateTokenResponse,
-                    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, token_id, context=None):
-        """
-        Resource /{merchantId}/tokens/{tokenId} - Get token
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/tokens/get.html
-
-        :param token_id:  str
-        :param context:   :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.token_response.TokenResponse`
-        :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 = {
-            "tokenId": token_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/tokens/{tokenId}", path_context)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    None,
-                    TokenResponse,
-                    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 update(self, token_id, body, context=None):
-        """
-        Resource /{merchantId}/tokens/{tokenId} - Update token
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/tokens/update.html
-
-        :param token_id:  str
-        :param body:      :class:`worldline.connect.sdk.v1.domain.update_token_request.UpdateTokenRequest`
-        :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 = {
-            "tokenId": token_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/tokens/{tokenId}", path_context)
-        try:
-            return self._communicator.put(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    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)
-
-    def delete(self, token_id, query, context=None):
-        """
-        Resource /{merchantId}/tokens/{tokenId} - Delete token
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/tokens/delete.html
-
-        :param token_id:  str
-        :param query:     :class:`worldline.connect.sdk.v1.merchant.tokens.delete_token_params.DeleteTokenParams`
-        :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 = {
-            "tokenId": token_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/tokens/{tokenId}", path_context)
-        try:
-            return self._communicator.delete(
-                    uri,
-                    self._client_headers,
-                    query,
-                    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)
-
-    def approvesepadirectdebit(self, token_id, body, context=None):
-        """
-        Resource /{merchantId}/tokens/{tokenId}/approvesepadirectdebit - Approve SEPA DD mandate
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/tokens/approvesepadirectdebit.html
-
-        :param token_id:  str
-        :param body:      :class:`worldline.connect.sdk.v1.domain.approve_token_request.ApproveTokenRequest`
-        :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 = {
-            "tokenId": token_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/tokens/{tokenId}/approvesepadirectdebit", path_context)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    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/platform_exception.py

@@ -1,16 +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 PlatformException(ApiException):
-    """
-    Represents an error response from the Worldline Global Collect platform when something
-    went wrong at the Worldline Global Collect platform or further downstream.
-    """
-
-    def __init__(self, status_code, response_body, error_id, errors,
-                 message="the Worldline Global Collect platform returned an error response"):
-        super(PlatformException, self).__init__(status_code, response_body, error_id, errors, message)

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

@@ -1,16 +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 ReferenceException(ApiException):
-    """
-    Represents an error response from the Worldline Global Collect platform when a
-    non-existing or removed object is trying to be accessed.
-    """
-
-    def __init__(self, status_code, response_body, error_id, errors,
-                 message="the Worldline Global Collect platform returned a reference error response"):
-        super(ReferenceException, self).__init__(status_code, response_body, error_id, errors, message)