onlinepayments-sdk-python3 4.22.0__zip → 5.0.0__zip

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/merchant/payments/payments_client.py

@@ -1,391 +0,0 @@
-#
-# This class was auto-generated.
-#
-from onlinepayments.sdk.api_resource import ApiResource
-from onlinepayments.sdk.call_context import CallContext
-from onlinepayments.sdk.response_exception import ResponseException
-from onlinepayments.sdk.domain.cancel_payment_request import CancelPaymentRequest
-from onlinepayments.sdk.domain.cancel_payment_response import CancelPaymentResponse
-from onlinepayments.sdk.domain.capture_payment_request import CapturePaymentRequest
-from onlinepayments.sdk.domain.capture_response import CaptureResponse
-from onlinepayments.sdk.domain.captures_response import CapturesResponse
-from onlinepayments.sdk.domain.complete_payment_request import CompletePaymentRequest
-from onlinepayments.sdk.domain.complete_payment_response import CompletePaymentResponse
-from onlinepayments.sdk.domain.create_payment_request import CreatePaymentRequest
-from onlinepayments.sdk.domain.create_payment_response import CreatePaymentResponse
-from onlinepayments.sdk.domain.error_response import ErrorResponse
-from onlinepayments.sdk.domain.payment_details_response import PaymentDetailsResponse
-from onlinepayments.sdk.domain.payment_error_response import PaymentErrorResponse
-from onlinepayments.sdk.domain.payment_response import PaymentResponse
-from onlinepayments.sdk.domain.refund_error_response import RefundErrorResponse
-from onlinepayments.sdk.domain.refund_request import RefundRequest
-from onlinepayments.sdk.domain.refund_response import RefundResponse
-from onlinepayments.sdk.domain.refunds_response import RefundsResponse
-from onlinepayments.sdk.domain.subsequent_payment_request import SubsequentPaymentRequest
-from onlinepayments.sdk.domain.subsequent_payment_response import SubsequentPaymentResponse
-from onlinepayments.sdk.merchant.payments.i_payments_client import IPaymentsClient
-
-
-class PaymentsClient(ApiResource, IPaymentsClient):
-    """
-    Payments client. Thread-safe.
-    """
-
-    def __init__(self, parent, path_context):
-        """
-        :param parent:       :class:`onlinepayments.sdk.api_resource.ApiResource`
-        :param path_context: dict[str, str]
-        """
-        super(PaymentsClient, self).__init__(parent, path_context)
-
-    def create_payment(self, body: CreatePaymentRequest, context: CallContext = None) -> CreatePaymentResponse:
-        """
-        Resource /v2/{merchantId}/payments - Create payment
-
-
-        :param body: :class:`onlinepayments.sdk.domain.create_payment_request.CreatePaymentRequest`
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.domain.create_payment_response.CreatePaymentResponse`
-        :raise: DeclinedPaymentException if the payment platform declined / rejected the payment. The payment 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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        uri = self._instantiate_uri("/v2/{merchantId}/payments", None)
-        try:
-            return self._communicator.post(
-                uri,
-                self._client_headers,
-                None,
-                body,
-                CreatePaymentResponse,
-                context)
-
-        except ResponseException as e:
-            error_type = PaymentErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)
-
-    def get_payment(self, payment_id: str, context: CallContext = None) -> PaymentResponse:
-        """
-        Resource /v2/{merchantId}/payments/{paymentId} - Get payment
-
-
-        :param payment_id: str
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.domain.payment_response.PaymentResponse`
-        :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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        path_context = {
-            "paymentId": payment_id,
-        }
-        uri = self._instantiate_uri("/v2/{merchantId}/payments/{paymentId}", path_context)
-        try:
-            return self._communicator.get(
-                uri,
-                self._client_headers,
-                None,
-                PaymentResponse,
-                context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)
-
-    def complete_payment(self, payment_id: str, body: CompletePaymentRequest, context: CallContext = None) -> CompletePaymentResponse:
-        """
-        Resource /v2/{merchantId}/payments/{paymentId}/complete - Complete payment
-
-
-        :param payment_id: str
-        :param body: :class:`onlinepayments.sdk.domain.complete_payment_request.CompletePaymentRequest`
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.domain.complete_payment_response.CompletePaymentResponse`
-        :raise: DeclinedPaymentException if the payment platform declined / rejected the payment. The payment 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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        path_context = {
-            "paymentId": payment_id,
-        }
-        uri = self._instantiate_uri("/v2/{merchantId}/payments/{paymentId}/complete", path_context)
-        try:
-            return self._communicator.post(
-                uri,
-                self._client_headers,
-                None,
-                body,
-                CompletePaymentResponse,
-                context)
-
-        except ResponseException as e:
-            error_type = PaymentErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)
-
-    def cancel_payment(self, payment_id: str, body: CancelPaymentRequest = None, context: CallContext = None) -> CancelPaymentResponse:
-        """
-        Resource /v2/{merchantId}/payments/{paymentId}/cancel - Cancel payment
-
-
-        :param payment_id: str
-        :param body: :class:`onlinepayments.sdk.domain.cancel_payment_request.CancelPaymentRequest`
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.domain.cancel_payment_response.CancelPaymentResponse`
-        :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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        path_context = {
-            "paymentId": payment_id,
-        }
-        uri = self._instantiate_uri("/v2/{merchantId}/payments/{paymentId}/cancel", path_context)
-        try:
-            return self._communicator.post(
-                uri,
-                self._client_headers,
-                None,
-                body,
-                CancelPaymentResponse,
-                context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)
-
-    def subsequent_payment(self, payment_id: str, body: SubsequentPaymentRequest, context: CallContext = None) -> SubsequentPaymentResponse:
-        """
-        Resource /v2/{merchantId}/payments/{paymentId}/subsequent - Subsequent payment
-
-
-        :param payment_id: str
-        :param body: :class:`onlinepayments.sdk.domain.subsequent_payment_request.SubsequentPaymentRequest`
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.domain.subsequent_payment_response.SubsequentPaymentResponse`
-        :raise: DeclinedPaymentException if the payment platform declined / rejected the payment. The payment 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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        path_context = {
-            "paymentId": payment_id,
-        }
-        uri = self._instantiate_uri("/v2/{merchantId}/payments/{paymentId}/subsequent", path_context)
-        try:
-            return self._communicator.post(
-                uri,
-                self._client_headers,
-                None,
-                body,
-                SubsequentPaymentResponse,
-                context)
-
-        except ResponseException as e:
-            error_type = PaymentErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)
-
-    def refund_payment(self, payment_id: str, body: RefundRequest, context: CallContext = None) -> RefundResponse:
-        """
-        Resource /v2/{merchantId}/payments/{paymentId}/refund - Refund payment
-
-
-        :param payment_id: str
-        :param body: :class:`onlinepayments.sdk.domain.refund_request.RefundRequest`
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.domain.refund_response.RefundResponse`
-        :raise: DeclinedRefundException if the payment 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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        path_context = {
-            "paymentId": payment_id,
-        }
-        uri = self._instantiate_uri("/v2/{merchantId}/payments/{paymentId}/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 self._create_exception(e.status_code, e.body, error_object, context)
-
-    def capture_payment(self, payment_id: str, body: CapturePaymentRequest, context: CallContext = None) -> CaptureResponse:
-        """
-        Resource /v2/{merchantId}/payments/{paymentId}/capture - Capture payment
-
-
-        :param payment_id: str
-        :param body: :class:`onlinepayments.sdk.domain.capture_payment_request.CapturePaymentRequest`
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        path_context = {
-            "paymentId": payment_id,
-        }
-        uri = self._instantiate_uri("/v2/{merchantId}/payments/{paymentId}/capture", path_context)
-        try:
-            return self._communicator.post(
-                uri,
-                self._client_headers,
-                None,
-                body,
-                CaptureResponse,
-                context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)
-
-    def get_captures(self, payment_id: str, context: CallContext = None) -> CapturesResponse:
-        """
-        Resource /v2/{merchantId}/payments/{paymentId}/captures - Get Captures Api
-
-
-        :param payment_id: str
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.domain.captures_response.CapturesResponse`
-        :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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        path_context = {
-            "paymentId": payment_id,
-        }
-        uri = self._instantiate_uri("/v2/{merchantId}/payments/{paymentId}/captures", path_context)
-        try:
-            return self._communicator.get(
-                uri,
-                self._client_headers,
-                None,
-                CapturesResponse,
-                context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)
-
-    def get_payment_details(self, payment_id: str, context: CallContext = None) -> PaymentDetailsResponse:
-        """
-        Resource /v2/{merchantId}/payments/{paymentId}/details - Get payment details
-
-
-        :param payment_id: str
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.domain.payment_details_response.PaymentDetailsResponse`
-        :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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        path_context = {
-            "paymentId": payment_id,
-        }
-        uri = self._instantiate_uri("/v2/{merchantId}/payments/{paymentId}/details", path_context)
-        try:
-            return self._communicator.get(
-                uri,
-                self._client_headers,
-                None,
-                PaymentDetailsResponse,
-                context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)
-
-    def get_refunds(self, payment_id: str, context: CallContext = None) -> RefundsResponse:
-        """
-        Resource /v2/{merchantId}/payments/{paymentId}/refunds - Get Refunds Api
-
-
-        :param payment_id: str
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.domain.refunds_response.RefundsResponse`
-        :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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        path_context = {
-            "paymentId": payment_id,
-        }
-        uri = self._instantiate_uri("/v2/{merchantId}/payments/{paymentId}/refunds", path_context)
-        try:
-            return self._communicator.get(
-                uri,
-                self._client_headers,
-                None,
-                RefundsResponse,
-                context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/merchant/services/i_services_client.py

@@ -1,114 +0,0 @@
-#
-# This class was auto-generated.
-#
-from abc import ABC, abstractmethod
-
-from onlinepayments.sdk.call_context import CallContext
-from onlinepayments.sdk.domain.calculate_surcharge_request import CalculateSurchargeRequest
-from onlinepayments.sdk.domain.calculate_surcharge_response import CalculateSurchargeResponse
-from onlinepayments.sdk.domain.currency_conversion_request import CurrencyConversionRequest
-from onlinepayments.sdk.domain.currency_conversion_response import CurrencyConversionResponse
-from onlinepayments.sdk.domain.get_iin_details_request import GetIINDetailsRequest
-from onlinepayments.sdk.domain.get_iin_details_response import GetIINDetailsResponse
-from onlinepayments.sdk.domain.get_privacy_policy_response import GetPrivacyPolicyResponse
-from onlinepayments.sdk.domain.test_connection import TestConnection
-from onlinepayments.sdk.merchant.services.get_privacy_policy_params import GetPrivacyPolicyParams
-
-class IServicesClient(ABC):
-    """
-    Services client interface. Thread-safe.
-    """
-
-    @abstractmethod
-    def surcharge_calculation(self, body: CalculateSurchargeRequest, context: CallContext = None) -> CalculateSurchargeResponse:
-        """
-        Resource /v2/{merchantId}/services/surchargecalculation - Surcharge Calculation
-
-
-        :param body: :class:`onlinepayments.sdk.domain.calculate_surcharge_request.CalculateSurchargeRequest`
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.domain.calculate_surcharge_response.CalculateSurchargeResponse`
-        :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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-
-    @abstractmethod
-    def get_dcc_rate_inquiry(self, body: CurrencyConversionRequest, context: CallContext = None) -> CurrencyConversionResponse:
-        """
-        Resource /v2/{merchantId}/services/dccrate - Get Dcc Rate Inquiry Api
-
-
-        :param body: :class:`onlinepayments.sdk.domain.currency_conversion_request.CurrencyConversionRequest`
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.domain.currency_conversion_response.CurrencyConversionResponse`
-        :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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-
-    @abstractmethod
-    def get_privacy_policy(self, query: GetPrivacyPolicyParams, context: CallContext = None) -> GetPrivacyPolicyResponse:
-        """
-        Resource /v2/{merchantId}/services/privacypolicy - Get Privacy Policy
-
-
-        :param query: :class:`onlinepayments.sdk.merchant.services.get_privacy_policy_params.GetPrivacyPolicyParams`
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-
-    @abstractmethod
-    def test_connection(self, context: CallContext = None) -> TestConnection:
-        """
-        Resource /v2/{merchantId}/services/testconnection - Test connection
-
-
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-
-    @abstractmethod
-    def get_iin_details(self, body: GetIINDetailsRequest, context: CallContext = None) -> GetIINDetailsResponse:
-        """
-        Resource /v2/{merchantId}/services/getIINdetails - Get IIN details
-
-
-        :param body: :class:`onlinepayments.sdk.domain.get_iin_details_request.GetIINDetailsRequest`
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """