apimatic-cp-sdk 0.0.1

data/lib/cell_point_api/apis/notes_api.rb

@@ -0,0 +1,66 @@
+# cell_point_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module CellPointApi
+  # NotesApi
+  class NotesApi < BaseApi
+    # Create a new note for a payment.
+    # @param [NoteRequest] body Optional parameter: Request body containing the
+    # note details.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def create_note(body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/v1/notes',
+                                     Server::DEFAULT)
+                   .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(Single.new('cpdIssuedJWT')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Note.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 ProblemException))
+        .execute
+    end
+
+    # Retrieve a specific note by its ID.
+    # @param [String] note_id Required parameter: Unique identifier of the
+    # note.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_note_by_id(note_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/payments/v1/notes/{noteId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(note_id, key: 'noteId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('cpdIssuedJWT')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Note.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 ProblemException)
+                    .local_error('401',
+                                 'Authorization Required',
+                                 APIException)
+                    .local_error('404',
+                                 'Resource Not Found',
+                                 APIException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ProblemException))
+        .execute
+    end
+  end
+end

data/lib/cell_point_api/apis/oauth_authorization_api.rb

@@ -0,0 +1,44 @@
+# cell_point_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module CellPointApi
+  # OauthAuthorizationApi
+  class OauthAuthorizationApi < BaseApi
+    # Create a new OAuth 2 token.
+    # @param [String] authorization Required parameter: Authorization header in
+    # Basic auth format
+    # @param [String] scope Optional parameter: Requested scopes as a
+    # space-delimited list.
+    # @param [Hash] _field_parameters Additional optional form parameters are
+    # supported by this endpoint.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def request_token_cpd_issued_jwt(authorization,
+                                     scope: nil,
+                                     _field_parameters: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/token',
+                                     Server::ACCESS_TOKEN_SERVER)
+                   .form_param(new_parameter('client_credentials', key: 'grant_type'))
+                   .header_param(new_parameter(authorization, key: 'Authorization')
+                                  .is_required(true))
+                   .form_param(new_parameter(scope, key: 'scope'))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .additional_form_params(_field_parameters))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(OauthToken.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'OAuth 2 provider returned an error.',
+                                 OauthProviderException)
+                    .local_error('401',
+                                 'OAuth 2 provider says client authentication failed.',
+                                 OauthProviderException))
+        .execute
+    end
+  end
+end

data/lib/cell_point_api/apis/orders_api.rb

@@ -0,0 +1,483 @@
+# cell_point_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module CellPointApi
+  # OrdersApi
+  class OrdersApi < BaseApi
+    # Creates a new order.
+    # @param [UUID | String] idempotency_key Optional parameter: A unique
+    # identifier.  If you don't receive a response (for example, in case of a
+    # timeout), you can safely retry the request with the same header.  If the
+    # system already processed the request, the response to the first attempt
+    # will be returned without duplication.  Idempotency-Keys will last for
+    # 24hrs. After this time, please do a GET call to the resource to check the
+    # status.  > This is used only in `POST` requests, so they have the same
+    # idempotency guarantees as `PUT`.
+    # @param [Order] body Optional parameter: Order request body.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def create_order(idempotency_key: nil,
+                     body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/v1/orders',
+                                     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(Single.new('cpdIssuedJWT')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(OrderCore.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 ProblemException)
+                    .local_error('401',
+                                 'Authorization Required',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 ProblemException)
+                    .local_error('406',
+                                 'Cannot generate content acceptable according to the `Accept`'\
+                                  ' headers in the request',
+                                 ProblemException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ProblemException)
+                    .local_error('502',
+                                 'Bad Gateway',
+                                 APIException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 APIException))
+        .execute
+    end
+
+    # Retrieve a specific order
+    # @param [String] order_id Required parameter: Order to retrieve
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_order_by_id(order_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/payments/v1/orders/{orderId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(order_id, key: 'orderId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Or.new('cpdIssuedJWT', 'cpdIssuedJWT')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Order.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 ProblemException)
+                    .local_error('401',
+                                 'Authorization Required',
+                                 APIException)
+                    .local_error('404',
+                                 'Resource Not Found',
+                                 APIException)
+                    .local_error('406',
+                                 'Cannot generate content acceptable according to the `Accept`'\
+                                  ' headers in the request',
+                                 ProblemException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ProblemException)
+                    .local_error('502',
+                                 'Bad Gateway',
+                                 APIException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 APIException))
+        .execute
+    end
+
+    # Retrieve the status and summary of a specific order.
+    # Same information can be retrieved from the callback of [Create
+    # Order](#tag/Orders/operation/create-order).
+    # This can be polled as an alternative to that callback.
+    # The information from the endpoint will change when the `order.status` has
+    # changed. Changes to transactions within an order will not cause a
+    # new version of this resource to be available.
+    # As such, do not use the endpoint to get real-time information about an
+    # active order that a buyer is attempting to pay for.
+    # The status will only change once the order is fully paid and has
+    # transitioned to the `PAID` state.
+    # For polling, we recommend using the `If-None-Match` header and sending the
+    # ETag, so a `304` will be responded with if the resource has not changed.
+    # @param [String] order_id Required parameter: Order to retrieve status
+    # of.
+    # @param [Date] if_none_match Optional parameter: The `If-None-Match` HTTP
+    # request header makes the request conditional. For `GET` and `HEAD`
+    # methods, the server will return the requested resource, with a `200`
+    # status, only if it doesn't have an `ETag` matching the given ones. For
+    # other methods, the request will be processed only if the eventually
+    # existing resource's `ETag` doesn't match any of the values listed.  When
+    # the condition fails for `GET` and `HEAD` methods, then the server must
+    # return HTTP status code `304` (Not Modified). For methods that apply
+    # server-side changes, the status code `412` (Precondition Failed) is used.
+    # Note that the server generating a `304` response MUST generate any of the
+    # following header fields that would have been sent in a `200` (OK) response
+    # to the same request: Cache-Control, Content-Location, Date, ETag, Expires,
+    # and Vary.  The comparison with the stored `ETag` uses the weak comparison
+    # algorithm, meaning two files are considered identical if the content is
+    # equivalent — they don't have to be identical byte by byte. For example,
+    # two pages that differ by their creation date in the footer would still be
+    # considered identical.  When used in combination with `If-Modified-Since`,
+    # `If-None-Match` has precedence (if the server supports it).  There are two
+    # common use cases:    - For `GET` and `HEAD` methods, to update a cached
+    # entity that has an associated ETag.   - For other methods, and in
+    # particular for `PUT`,     `If-None-Match` used with the * value can be
+    # used to save a file not known to exist,     guaranteeing that another
+    # upload didn't happen before, losing the data of the previous put;     this
+    # problem is a variation of the lost update problem.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_order_summary_by_id(order_id,
+                                if_none_match: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/payments/v1/orders/{orderId}/summary',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(order_id, key: 'orderId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(if_none_match, key: 'If-None-Match'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Or.new('cpdIssuedJWT', 'cpdIssuedJWT')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(OrderPaymentSummary.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 ProblemException)
+                    .local_error('401',
+                                 'Authorization Required',
+                                 APIException)
+                    .local_error('404',
+                                 'Resource Not Found',
+                                 APIException)
+                    .local_error('406',
+                                 'Cannot generate content acceptable according to the `Accept`'\
+                                  ' headers in the request',
+                                 ProblemException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ProblemException)
+                    .local_error('502',
+                                 'Bad Gateway',
+                                 APIException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 APIException))
+        .execute
+    end
+
+    # Retrieve all transactions connected to an order.
+    # A transaction includes:
+    #   - Payments
+    #   - Refunds
+    #   - Payouts
+    # @param [String] order_id Required parameter: Order to retrieve all
+    # transactions for.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def orders_transactions(order_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/payments/v1/orders/{orderId}/transactions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(order_id, key: 'orderId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('cpdIssuedJWT')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(OrderTransactions.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 ProblemException))
+        .execute
+    end
+
+    # Fulfills a completed order.
+    # @param [String] order_id Required parameter: Order to fulfill.
+    # @param [UUID | String] idempotency_key Optional parameter: A unique
+    # identifier.  If you don't receive a response (for example, in case of a
+    # timeout), you can safely retry the request with the same header.  If the
+    # system already processed the request, the response to the first attempt
+    # will be returned without duplication.  Idempotency-Keys will last for
+    # 24hrs. After this time, please do a GET call to the resource to check the
+    # status.  > This is used only in `POST` requests, so they have the same
+    # idempotency guarantees as `PUT`.
+    # @param [FulfilledOrder] body Optional parameter: Order fulfillment request
+    # body.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def fulfill_order(order_id,
+                      idempotency_key: nil,
+                      body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/v1/orders/{orderId}/fulfillments',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(order_id, key: 'orderId')
+                                    .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(Single.new('cpdIssuedJWT')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(OrderPaymentSummary.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 ProblemException)
+                    .local_error('401',
+                                 'Authorization Required',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 ProblemException)
+                    .local_error('406',
+                                 'Cannot generate content acceptable according to the `Accept`'\
+                                  ' headers in the request',
+                                 ProblemException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ProblemException)
+                    .local_error('502',
+                                 'Bad Gateway',
+                                 APIException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 APIException))
+        .execute
+    end
+
+    # Before the payment can transition to a PAID state, the terms and
+    # conditions must be accepted.
+    # Each payment can mark itself as accepting those terms, but if the payments
+    # weren't marked so,
+    # an additional call to this endpoint would be required after all the
+    # payments have been made.
+    # @param [String] order_id Required parameter: Order to accept Terms and
+    # Conditions for
+    # @param [UUID | String] idempotency_key Optional parameter: A unique
+    # identifier.  If you don't receive a response (for example, in case of a
+    # timeout), you can safely retry the request with the same header.  If the
+    # system already processed the request, the response to the first attempt
+    # will be returned without duplication.  Idempotency-Keys will last for
+    # 24hrs. After this time, please do a GET call to the resource to check the
+    # status.  > This is used only in `POST` requests, so they have the same
+    # idempotency guarantees as `PUT`.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def confirm_payments(order_id,
+                         idempotency_key: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/v1/orders/{orderId}/confirm-payments',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(order_id, key: 'orderId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
+                   .auth(Single.new('cpdIssuedJWT')))
+        .response(new_response_handler
+                    .is_response_void(true)
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 ProblemException))
+        .execute
+    end
+
+    # Creates a new fingerprint for a buyer.
+    # @param [String] order_id Required parameter: OrderId to save the
+    # fingerprint against.
+    # @param [UUID | String] idempotency_key Optional parameter: A unique
+    # identifier.  If you don't receive a response (for example, in case of a
+    # timeout), you can safely retry the request with the same header.  If the
+    # system already processed the request, the response to the first attempt
+    # will be returned without duplication.  Idempotency-Keys will last for
+    # 24hrs. After this time, please do a GET call to the resource to check the
+    # status.  > This is used only in `POST` requests, so they have the same
+    # idempotency guarantees as `PUT`.
+    # @param [BuyerFingerprint] body Optional parameter: Buyer Fingerprint to be
+    # saved.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def create_fingerprint(order_id,
+                           idempotency_key: nil,
+                           body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/v1/orders/{orderId}/fingerprints',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(order_id, key: 'orderId')
+                                    .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))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('cpdIssuedJWT')))
+        .response(new_response_handler
+                    .is_response_void(true)
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 ProblemException)
+                    .local_error('401',
+                                 'Authorization Required',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 ProblemException)
+                    .local_error('406',
+                                 'Cannot generate content acceptable according to the `Accept`'\
+                                  ' headers in the request',
+                                 ProblemException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ProblemException)
+                    .local_error('502',
+                                 'Bad Gateway',
+                                 APIException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 APIException))
+        .execute
+    end
+
+    # Creates an order connected to other orders within an existing Order Group.
+    # An Order Group is made by passing an `orderGroupId` when [creating an
+    # order](#tag/Orders/operation/create-order).
+    # @param [String] order_group_id Required parameter: Order group in which to
+    # make the connected order.
+    # @param [UUID | String] idempotency_key Optional parameter: A unique
+    # identifier.  If you don't receive a response (for example, in case of a
+    # timeout), you can safely retry the request with the same header.  If the
+    # system already processed the request, the response to the first attempt
+    # will be returned without duplication.  Idempotency-Keys will last for
+    # 24hrs. After this time, please do a GET call to the resource to check the
+    # status.  > This is used only in `POST` requests, so they have the same
+    # idempotency guarantees as `PUT`.
+    # @param [Order] body Optional parameter: Order request body.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def create_connected_order(order_group_id,
+                               idempotency_key: nil,
+                               body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/v1/order-groups/{orderGroupId}/orders',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(order_group_id, key: 'orderGroupId')
+                                    .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(Single.new('cpdIssuedJWT')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(OrderCore.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 ProblemException)
+                    .local_error('401',
+                                 'Authorization Required',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 ProblemException)
+                    .local_error('406',
+                                 'Cannot generate content acceptable according to the `Accept`'\
+                                  ' headers in the request',
+                                 ProblemException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ProblemException)
+                    .local_error('502',
+                                 'Bad Gateway',
+                                 APIException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 APIException))
+        .execute
+    end
+
+    # Refunds an entire order group.
+    # An Order Group is made by passing an `orderGroupId` when [creating an
+    # order](#tag/Orders/operation/create-order).
+    # @param [String] order_group_id Required parameter: Order to fulfill.
+    # @param [UUID | String] idempotency_key Optional parameter: A unique
+    # identifier.  If you don't receive a response (for example, in case of a
+    # timeout), you can safely retry the request with the same header.  If the
+    # system already processed the request, the response to the first attempt
+    # will be returned without duplication.  Idempotency-Keys will last for
+    # 24hrs. After this time, please do a GET call to the resource to check the
+    # status.  > This is used only in `POST` requests, so they have the same
+    # idempotency guarantees as `PUT`.
+    # @param [RefundRequest] body Optional parameter: Refund request body.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def refund_order_group(order_group_id,
+                           idempotency_key: nil,
+                           body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/v1/order-groups/{orderGroupId}/refunds',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(order_group_id, key: 'orderGroupId')
+                                    .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(Single.new('cpdIssuedJWT')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(RefundOrderGroupPost201Response.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 ProblemException)
+                    .local_error('401',
+                                 'Authorization Required',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 ProblemException)
+                    .local_error('406',
+                                 'Cannot generate content acceptable according to the `Accept`'\
+                                  ' headers in the request',
+                                 ProblemException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ProblemException)
+                    .local_error('502',
+                                 'Bad Gateway',
+                                 APIException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 APIException))
+        .execute
+    end
+  end
+end

data/lib/cell_point_api/apis/payment_methods_api.rb

@@ -0,0 +1,57 @@
+# cell_point_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module CellPointApi
+  # PaymentMethodsApi
+  class PaymentMethodsApi < BaseApi
+    # Gets the payment methods available for a given order id.
+    # @param [String] order_id Required parameter: Order to retrieve the payment
+    # methods that the buyer has available to pay for it with.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def orders_get_payment_methods(order_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/payments/v1/orders/{orderId}/payment-methods',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(order_id, key: 'orderId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('cpdIssuedJWT')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentMethodsForOrderGet200Response.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 ProblemException))
+        .execute
+    end
+
+    # Returns a list of available vouchers matching the search criteria.
+    # @param [SearchVouchersRequest] body Optional parameter: Request body
+    # containing the search criteria.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def orders_search_vouchers(body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/v1/search-vouchers',
+                                     Server::DEFAULT)
+                   .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(Single.new('cpdIssuedJWT')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentMethodsSearchVouchersPost200Response.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 ProblemException))
+        .execute
+    end
+  end
+end