adyen-apimatic-sdk 1.0.0

data/lib/adyen_ap_is/apis/modifications_api.rb

@@ -0,0 +1,394 @@
+# adyen_ap_is
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module AdyenApIs
+  # ModificationsApi
+  class ModificationsApi < BaseApi
+    # Cancels the authorisation on a payment that has not yet been
+    # [captured](https://docs.adyen.com/api-explorer/#/CheckoutService/latest/po
+    # st/payments/{paymentPspReference}/captures), and returns a unique
+    # reference for this request. You get the outcome of the request
+    # asynchronously, in a [**TECHNICAL_CANCEL**
+    # webhook](https://docs.adyen.com/online-payments/cancel#cancellation-webhoo
+    # k).
+    # If you want to cancel a payment using the
+    # [`pspReference`](https://docs.adyen.com/api-explorer/Checkout/latest/post/
+    # payments#responses-200-pspReference), use the
+    # [`/payments/{paymentPspReference}/cancels`](https://docs.adyen.com/api-exp
+    # lorer/#/CheckoutService/latest/post/payments/{paymentPspReference}/cancels
+    # ) endpoint instead.
+    # If you want to cancel a payment but are not sure whether it has been
+    # captured, use the
+    # [`/payments/{paymentPspReference}/reversals`](https://docs.adyen.com/api-e
+    # xplorer/#/CheckoutService/latest/post/payments/{paymentPspReference}/rever
+    # sals) endpoint instead.
+    # For more information, refer to
+    # [Cancel](https://docs.adyen.com/online-payments/cancel).
+    # @param [String] idempotency_key Optional parameter: A unique identifier
+    # for the message with a maximum of 64 characters (we recommend a UUID).
+    # @param [StandalonePaymentCancelRequest] body Optional parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def post_cancels(idempotency_key: nil,
+                     body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/cancels',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Or.new('BasicAuth', 'ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(StandalonePaymentCancelResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request - a problem reading or understanding the request.',
+                                 ServiceErrorException)
+                    .local_error('401',
+                                 'Unauthorized - authentication required.',
+                                 ServiceErrorException)
+                    .local_error('403',
+                                 'Forbidden - insufficient permissions to process the request.',
+                                 ServiceErrorException)
+                    .local_error('422',
+                                 'Unprocessable Entity - a request validation error.',
+                                 ServiceErrorException)
+                    .local_error('500',
+                                 'Internal Server Error - the server could not process the'\
+                                  ' request.',
+                                 ServiceErrorException))
+        .execute
+    end
+
+    # Increases or decreases the authorised payment amount and returns a unique
+    # reference for this request. You get the outcome of the request
+    # asynchronously, in an [**AUTHORISATION_ADJUSTMENT**
+    # webhook](https://docs.adyen.com/development-resources/webhooks/webhook-typ
+    # es/#event-codes).
+    # You can only update authorised amounts that have not yet been
+    # [captured](https://docs.adyen.com/api-explorer/#/CheckoutService/latest/po
+    # st/payments/{paymentPspReference}/captures).
+    # The amount you specify in the request is the updated amount, which is
+    # larger or smaller than the initial authorised amount.
+    # For more information, refer to [Authorisation
+    # adjustment](https://docs.adyen.com/online-payments/adjust-authorisation#us
+    # e-cases).
+    # @param [String] payment_psp_reference Required parameter: The
+    # [`pspReference`](https://docs.adyen.com/api-explorer/Checkout/latest/post/
+    # payments#responses-200-pspReference) of the payment.
+    # @param [String] idempotency_key Optional parameter: A unique identifier
+    # for the message with a maximum of 64 characters (we recommend a UUID).
+    # @param [PaymentAmountUpdateRequest] body Optional parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def post_payments_payment_psp_reference_amount_updates(payment_psp_reference,
+                                                           idempotency_key: nil,
+                                                           body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/{paymentPspReference}/amountUpdates',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(payment_psp_reference, key: 'paymentPspReference')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Or.new('BasicAuth', 'ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentAmountUpdateResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request - a problem reading or understanding the request.',
+                                 ServiceErrorException)
+                    .local_error('401',
+                                 'Unauthorized - authentication required.',
+                                 ServiceErrorException)
+                    .local_error('403',
+                                 'Forbidden - insufficient permissions to process the request.',
+                                 ServiceErrorException)
+                    .local_error('422',
+                                 'Unprocessable Entity - a request validation error.',
+                                 ServiceErrorException)
+                    .local_error('500',
+                                 'Internal Server Error - the server could not process the'\
+                                  ' request.',
+                                 ServiceErrorException))
+        .execute
+    end
+
+    # Cancels the authorisation on a payment that has not yet been
+    # [captured](https://docs.adyen.com/api-explorer/#/CheckoutService/latest/po
+    # st/payments/{paymentPspReference}/captures), and returns a unique
+    # reference for this request. You get the outcome of the request
+    # asynchronously, in a [**CANCELLATION**
+    # webhook](https://docs.adyen.com/online-payments/cancel#cancellation-webhoo
+    # k).
+    # If you want to cancel a payment but don't have the
+    # [`pspReference`](https://docs.adyen.com/api-explorer/Checkout/latest/post/
+    # payments#responses-200-pspReference), use the
+    # [`/cancels`](https://docs.adyen.com/api-explorer/#/CheckoutService/latest/
+    # post/cancels) endpoint instead.
+    # If you want to cancel a payment but are not sure whether it has been
+    # captured, use the
+    # [`/payments/{paymentPspReference}/reversals`](https://docs.adyen.com/api-e
+    # xplorer/#/CheckoutService/latest/post/payments/{paymentPspReference}/rever
+    # sals) endpoint instead.
+    # For more information, refer to
+    # [Cancel](https://docs.adyen.com/online-payments/cancel).
+    # @param [String] payment_psp_reference Required parameter: The
+    # [`pspReference`](https://docs.adyen.com/api-explorer/Checkout/latest/post/
+    # payments#responses-200-pspReference) of the payment that you want to
+    # cancel.
+    # @param [String] idempotency_key Optional parameter: A unique identifier
+    # for the message with a maximum of 64 characters (we recommend a UUID).
+    # @param [PaymentCancelRequest] body Optional parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def post_payments_payment_psp_reference_cancels(payment_psp_reference,
+                                                    idempotency_key: nil,
+                                                    body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/{paymentPspReference}/cancels',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(payment_psp_reference, key: 'paymentPspReference')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Or.new('BasicAuth', 'ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentCancelResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request - a problem reading or understanding the request.',
+                                 ServiceErrorException)
+                    .local_error('401',
+                                 'Unauthorized - authentication required.',
+                                 ServiceErrorException)
+                    .local_error('403',
+                                 'Forbidden - insufficient permissions to process the request.',
+                                 ServiceErrorException)
+                    .local_error('422',
+                                 'Unprocessable Entity - a request validation error.',
+                                 ServiceErrorException)
+                    .local_error('500',
+                                 'Internal Server Error - the server could not process the'\
+                                  ' request.',
+                                 ServiceErrorException))
+        .execute
+    end
+
+    #  Captures an authorised payment and returns a unique reference for this
+    # request. You get the outcome of the request asynchronously, in a
+    # [**CAPTURE**
+    # webhook](https://docs.adyen.com/online-payments/capture#capture-notificati
+    # on).
+    # You can capture either the full authorised amount or a part of the
+    # authorised amount. By default, any unclaimed amount after a partial
+    # capture gets cancelled. This does not apply if you enabled multiple
+    # partial captures on your account and the payment method supports multiple
+    # partial captures.
+    # [Automatic
+    # capture](https://docs.adyen.com/online-payments/capture#automatic-capture)
+    # is the default setting for most payment methods. In these cases, you don't
+    # need to make capture requests. However, making capture requests for
+    # payments that are captured automatically does not result in double
+    # charges.
+    # For more information, refer to
+    # [Capture](https://docs.adyen.com/online-payments/capture).
+    # @param [String] payment_psp_reference Required parameter: The
+    # [`pspReference`](https://docs.adyen.com/api-explorer/Checkout/latest/post/
+    # payments#responses-200-pspReference) of the payment that you want to
+    # capture.
+    # @param [String] idempotency_key Optional parameter: A unique identifier
+    # for the message with a maximum of 64 characters (we recommend a UUID).
+    # @param [PaymentCaptureRequest] body Optional parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def post_payments_payment_psp_reference_captures(payment_psp_reference,
+                                                     idempotency_key: nil,
+                                                     body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/{paymentPspReference}/captures',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(payment_psp_reference, key: 'paymentPspReference')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Or.new('BasicAuth', 'ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentCaptureResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request - a problem reading or understanding the request.',
+                                 ServiceErrorException)
+                    .local_error('401',
+                                 'Unauthorized - authentication required.',
+                                 ServiceErrorException)
+                    .local_error('403',
+                                 'Forbidden - insufficient permissions to process the request.',
+                                 ServiceErrorException)
+                    .local_error('422',
+                                 'Unprocessable Entity - a request validation error.',
+                                 ServiceErrorException)
+                    .local_error('500',
+                                 'Internal Server Error - the server could not process the'\
+                                  ' request.',
+                                 ServiceErrorException))
+        .execute
+    end
+
+    # Refunds a payment that has been
+    # [captured](https://docs.adyen.com/api-explorer/#/CheckoutService/latest/po
+    # st/payments/{paymentPspReference}/captures), and returns a unique
+    # reference for this request. You get the outcome of the request
+    # asynchronously, in a [**REFUND**
+    # webhook](https://docs.adyen.com/online-payments/refund#refund-webhook).
+    # You can refund either the full captured amount or a part of the captured
+    # amount. You can also perform multiple partial refunds, as long as their
+    # sum doesn't exceed the captured amount.
+    # > Some payment methods do not support partial refunds. To learn if a
+    # payment method supports partial refunds, refer to the payment method page
+    # such as
+    # [cards](https://docs.adyen.com/payment-methods/cards#supported-cards),
+    # [iDEAL](https://docs.adyen.com/payment-methods/ideal), or
+    # [Klarna](https://docs.adyen.com/payment-methods/klarna).
+    # If you want to refund a payment but are not sure whether it has been
+    # captured, use the
+    # [`/payments/{paymentPspReference}/reversals`](https://docs.adyen.com/api-e
+    # xplorer/#/CheckoutService/latest/post/payments/{paymentPspReference}/rever
+    # sals) endpoint instead.
+    # For more information, refer to
+    # [Refund](https://docs.adyen.com/online-payments/refund).
+    # @param [String] payment_psp_reference Required parameter: The
+    # [`pspReference`](https://docs.adyen.com/api-explorer/Checkout/latest/post/
+    # payments#responses-200-pspReference) of the payment that you want to
+    # refund.
+    # @param [String] idempotency_key Optional parameter: A unique identifier
+    # for the message with a maximum of 64 characters (we recommend a UUID).
+    # @param [PaymentRefundRequest] body Optional parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def post_payments_payment_psp_reference_refunds(payment_psp_reference,
+                                                    idempotency_key: nil,
+                                                    body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/{paymentPspReference}/refunds',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(payment_psp_reference, key: 'paymentPspReference')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Or.new('BasicAuth', 'ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentRefundResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request - a problem reading or understanding the request.',
+                                 ServiceErrorException)
+                    .local_error('401',
+                                 'Unauthorized - authentication required.',
+                                 ServiceErrorException)
+                    .local_error('403',
+                                 'Forbidden - insufficient permissions to process the request.',
+                                 ServiceErrorException)
+                    .local_error('422',
+                                 'Unprocessable Entity - a request validation error.',
+                                 ServiceErrorException)
+                    .local_error('500',
+                                 'Internal Server Error - the server could not process the'\
+                                  ' request.',
+                                 ServiceErrorException))
+        .execute
+    end
+
+    # [Refunds](https://docs.adyen.com/api-explorer/#/CheckoutService/latest/pos
+    # t/payments/{paymentPspReference}/refunds) a payment if it has already been
+    # captured, and
+    # [cancels](https://docs.adyen.com/api-explorer/#/CheckoutService/latest/pos
+    # t/payments/{paymentPspReference}/cancels) a payment if it has not yet been
+    # captured. Returns a unique reference for this request. You get the outcome
+    # of the request asynchronously, in a [**CANCEL_OR_REFUND**
+    # webhook](https://docs.adyen.com/online-payments/reversal/#cancel-or-refund
+    # -webhook).
+    # The reversed amount is always the full payment amount.
+    # > Do not use this request for payments that involve multiple partial
+    # captures.
+    # For more information, refer to
+    # [Reversal](https://docs.adyen.com/online-payments/reversal).
+    # @param [String] payment_psp_reference Required parameter: The
+    # [`pspReference`](https://docs.adyen.com/api-explorer/Checkout/latest/post/
+    # payments#responses-200-pspReference) of the payment that you want to
+    # reverse.
+    # @param [String] idempotency_key Optional parameter: A unique identifier
+    # for the message with a maximum of 64 characters (we recommend a UUID).
+    # @param [PaymentReversalRequest] body Optional parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def post_payments_payment_psp_reference_reversals(payment_psp_reference,
+                                                      idempotency_key: nil,
+                                                      body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/{paymentPspReference}/reversals',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(payment_psp_reference, key: 'paymentPspReference')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Or.new('BasicAuth', 'ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentReversalResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request - a problem reading or understanding the request.',
+                                 ServiceErrorException)
+                    .local_error('401',
+                                 'Unauthorized - authentication required.',
+                                 ServiceErrorException)
+                    .local_error('403',
+                                 'Forbidden - insufficient permissions to process the request.',
+                                 ServiceErrorException)
+                    .local_error('422',
+                                 'Unprocessable Entity - a request validation error.',
+                                 ServiceErrorException)
+                    .local_error('500',
+                                 'Internal Server Error - the server could not process the'\
+                                  ' request.',
+                                 ServiceErrorException))
+        .execute
+    end
+  end
+end

data/lib/adyen_ap_is/apis/my_api_credential_api.rb

@@ -0,0 +1,245 @@
+# adyen_ap_is
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module AdyenApIs
+  # MyApiCredentialApi
+  class MyApiCredentialApi < BaseApi
+    # Returns your [API
+    # credential](https://docs.adyen.com/development-resources/api-credentials)
+    # details based on the API Key you used in the request.
+    # You can make this request with any of the Management API roles.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_me
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/me',
+                                     Server::DEFAULT1)
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Or.new('BasicAuth', 'ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(MeApiCredential.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request - a problem reading or understanding the request.',
+                                 RestServiceErrorException)
+                    .local_error('401',
+                                 'Unauthorized - authentication required.',
+                                 RestServiceErrorException)
+                    .local_error('403',
+                                 'Forbidden - insufficient permissions to process the request.',
+                                 RestServiceErrorException)
+                    .local_error('422',
+                                 'Unprocessable Entity - a request validation error.',
+                                 RestServiceErrorException)
+                    .local_error('500',
+                                 'Internal Server Error - the server could not process the'\
+                                  ' request.',
+                                 RestServiceErrorException))
+        .execute
+    end
+
+    # Returns the list of [allowed
+    # origins](https://docs.adyen.com/development-resources/client-side-authenti
+    # cation#allowed-origins) of your [API
+    # credential](https://docs.adyen.com/development-resources/api-credentials)
+    # based on the API key you used in the request.
+    # You can make this request with any of the Management API roles.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_me_allowed_origins
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/me/allowedOrigins',
+                                     Server::DEFAULT1)
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Or.new('BasicAuth', 'ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AllowedOriginsResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request - a problem reading or understanding the request.',
+                                 RestServiceErrorException)
+                    .local_error('401',
+                                 'Unauthorized - authentication required.',
+                                 RestServiceErrorException)
+                    .local_error('403',
+                                 'Forbidden - insufficient permissions to process the request.',
+                                 RestServiceErrorException)
+                    .local_error('422',
+                                 'Unprocessable Entity - a request validation error.',
+                                 RestServiceErrorException)
+                    .local_error('500',
+                                 'Internal Server Error - the server could not process the'\
+                                  ' request.',
+                                 RestServiceErrorException))
+        .execute
+    end
+
+    # Adds an allowed origin to the list of [allowed
+    # origins](https://docs.adyen.com/development-resources/client-side-authenti
+    # cation#allowed-origins) of your API credential.
+    # The API key from the request is used to identify the [API
+    # credential](https://docs.adyen.com/development-resources/api-credentials).
+    # You can make this request with any of the Management API roles.
+    # @param [CreateAllowedOriginRequest] body Optional parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def post_me_allowed_origins(body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/me/allowedOrigins',
+                                     Server::DEFAULT1)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Or.new('BasicAuth', 'ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AllowedOrigin.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request - a problem reading or understanding the request.',
+                                 RestServiceErrorException)
+                    .local_error('401',
+                                 'Unauthorized - authentication required.',
+                                 RestServiceErrorException)
+                    .local_error('403',
+                                 'Forbidden - insufficient permissions to process the request.',
+                                 RestServiceErrorException)
+                    .local_error('422',
+                                 'Unprocessable Entity - a request validation error.',
+                                 RestServiceErrorException)
+                    .local_error('500',
+                                 'Internal Server Error - the server could not process the'\
+                                  ' request.',
+                                 RestServiceErrorException))
+        .execute
+    end
+
+    # Removes the [allowed
+    # origin](https://docs.adyen.com/development-resources/client-side-authentic
+    # ation#allowed-origins) specified in the path.
+    # The API key from the request is used to identify the [API
+    # credential](https://docs.adyen.com/development-resources/api-credentials).
+    # You can make this request with any of the Management API roles.
+    # @param [String] origin_id Required parameter: Unique identifier of the
+    # allowed origin.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def delete_me_allowed_origins_origin_id(origin_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/me/allowedOrigins/{originId}',
+                                     Server::DEFAULT1)
+                   .template_param(new_parameter(origin_id, key: 'originId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .auth(Or.new('BasicAuth', 'ApiKeyAuth')))
+        .response(new_response_handler
+                    .is_response_void(true)
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request - a problem reading or understanding the request.',
+                                 RestServiceErrorException)
+                    .local_error('401',
+                                 'Unauthorized - authentication required.',
+                                 RestServiceErrorException)
+                    .local_error('403',
+                                 'Forbidden - insufficient permissions to process the request.',
+                                 RestServiceErrorException)
+                    .local_error('422',
+                                 'Unprocessable Entity - a request validation error.',
+                                 RestServiceErrorException)
+                    .local_error('500',
+                                 'Internal Server Error - the server could not process the'\
+                                  ' request.',
+                                 RestServiceErrorException))
+        .execute
+    end
+
+    # Returns the details of the [allowed
+    # origin](https://docs.adyen.com/development-resources/client-side-authentic
+    # ation#allowed-origins) specified in the path.
+    # The API key from the request is used to identify the [API
+    # credential](https://docs.adyen.com/development-resources/api-credentials).
+    # You can make this request with any of the Management API roles.
+    # @param [String] origin_id Required parameter: Unique identifier of the
+    # allowed origin.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_me_allowed_origins_origin_id(origin_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/me/allowedOrigins/{originId}',
+                                     Server::DEFAULT1)
+                   .template_param(new_parameter(origin_id, key: 'originId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Or.new('BasicAuth', 'ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AllowedOrigin.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request - a problem reading or understanding the request.',
+                                 RestServiceErrorException)
+                    .local_error('401',
+                                 'Unauthorized - authentication required.',
+                                 RestServiceErrorException)
+                    .local_error('403',
+                                 'Forbidden - insufficient permissions to process the request.',
+                                 RestServiceErrorException)
+                    .local_error('422',
+                                 'Unprocessable Entity - a request validation error.',
+                                 RestServiceErrorException)
+                    .local_error('500',
+                                 'Internal Server Error - the server could not process the'\
+                                  ' request.',
+                                 RestServiceErrorException))
+        .execute
+    end
+
+    # Generates a new [client
+    # key](https://docs.adyen.com/development-resources/client-side-authenticati
+    # on/) used to authenticate requests from your payment environment.
+    # You can use the new client key a few minutes after generating it.
+    # The old client key stops working 24 hours after generating a new one.
+    # To make this request, your API credential must have the following
+    # [role](https://docs.adyen.com/development-resources/api-credentials#api-pe
+    # rmissions):
+    # * Management API—API credentials read and write
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def post_me_generate_client_key
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/me/generateClientKey',
+                                     Server::DEFAULT1)
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Or.new('BasicAuth', 'ApiKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GenerateClientKeyResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request - a problem reading or understanding the request.',
+                                 RestServiceErrorException)
+                    .local_error('401',
+                                 'Unauthorized - authentication required.',
+                                 RestServiceErrorException)
+                    .local_error('403',
+                                 'Forbidden - insufficient permissions to process the request.',
+                                 RestServiceErrorException)
+                    .local_error('422',
+                                 'Unprocessable Entity - a request validation error.',
+                                 RestServiceErrorException)
+                    .local_error('500',
+                                 'Internal Server Error - the server could not process the'\
+                                  ' request.',
+                                 RestServiceErrorException))
+        .execute
+    end
+  end
+end