loyalty-sdk 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 346e6a793917166b67bda7bd4018ce13f909cbf2259773cc78f38df546aa4ddd
+  data.tar.gz: 99dd50a7713af2b6d8d558f3f1587e71b232f1a29db33e5dfdfa7235f95502fb
+SHA512:
+  metadata.gz: bc48d367b5bfc78cb7f80136ac4a51f9e45dc4568190d3406a64d4b445466452d3c072c889594a5ed5a2948a754b9bb7f9c835c3c370d61a728df533f4a327c9
+  data.tar.gz: 466a111f8b8379cb00dc366b1bc8f2f3e6748f46b627cc48a618abd4be4b1502b0ff7f6a46197d2d3d03d4d34eb60c69998c6e3e7c04ef0c95d9ba111a17ccfa

data/LICENSE

@@ -0,0 +1,28 @@
+License: 
+========
+The MIT License (MIT)
+http://opensource.org/licenses/MIT
+
+Copyright (c) 2014 - 2026 APIMATIC Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+Trade Mark:
+==========
+APIMATIC is a trade mark for APIMATIC Limited

data/README.md

@@ -0,0 +1,187 @@
+
+# Getting Started with Loyalty APIs
+
+## Introduction
+
+Loyalty Account Management provides the end points needed in order to generate the user Authorization Tokens which will provide access to the Loyalty APIs and also to update the user profile.
+
+## Install the Package
+
+Install the gem from the command line:
+
+```bash
+gem install loyalty-sdk -v 0.0.1
+```
+
+Or add the gem to your Gemfile and run `bundle`:
+
+```ruby
+gem 'loyalty-sdk', '0.0.1'
+```
+
+For additional gem details, see the [RubyGems page for the loyalty-sdk gem](https://rubygems.org/gems/loyalty-sdk/versions/0.0.1).
+
+## IRB Console Usage
+
+You can explore the SDK interactively using IRB in two ways
+
+### 1. Use IRB with Installed Gem
+
+Open your system terminal (Command Prompt, Git Bash or macOS Terminal) and type the following command to start the irb console.
+
+```bash
+irb
+```
+
+Now you can load the SDK in the IRB
+
+```ruby
+require 'loyalty_ap_is'
+include LoyaltyApIs
+```
+
+### 2. Use IRB within SDK
+
+Open your system terminal (Command Prompt, Git Bash or macOS Terminal) and navigate to the root folder of SDK.
+
+```
+cd path/to/loyalty_ap_is
+```
+
+Now you can start the preconfigured irb console by running the following command
+
+```bash
+ruby bin/console
+```
+
+**_Note:_** This automatically loads the SDK from lib/
+
+## Initialize the API Client
+
+**_Note:_** Documentation for the client can be found [here.](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/client.md)
+
+The following parameters are configurable for the API Client:
+
+| Parameter | Type | Description |
+|  --- | --- | --- |
+| environment | [`Environment`](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/README.md#environments) | The API environment. <br> **Default: `Environment.SIT`** |
+| connection | `Faraday::Connection` | The Faraday connection object passed by the SDK user for making requests |
+| adapter | `Faraday::Adapter` | The Faraday adapter object passed by the SDK user for performing http requests |
+| timeout | `Float` | The value to use for connection timeout. <br> **Default: 30** |
+| max_retries | `Integer` | The number of times to retry an endpoint call if it fails. <br> **Default: 0** |
+| retry_interval | `Float` | Pause in seconds between retries. <br> **Default: 1** |
+| backoff_factor | `Float` | The amount to multiply each successive retry's interval amount by in order to provide backoff. <br> **Default: 2** |
+| retry_statuses | `Array` | A list of HTTP statuses to retry. <br> **Default: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524]** |
+| retry_methods | `Array` | A list of HTTP methods to retry. <br> **Default: %i[get put]** |
+| http_callback | `HttpCallBack` | The Http CallBack allows defining callables for pre and post API calls. |
+| proxy_settings | [`ProxySettings`](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/proxy-settings.md) | Optional proxy configuration to route HTTP requests through a proxy server. |
+| logging_configuration | [`LoggingConfiguration`](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/logging-configuration.md) | The SDK logging configuration for API calls |
+| public_bearer_token_credentials | [`PublicBearerTokenCredentials`](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/auth/oauth-2-bearer-token.md) | The credential object for OAuth 2 Bearer token |
+| public_basic_token_credentials | [`PublicBasicTokenCredentials`](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/auth/custom-header-signature.md) | The credential object for Custom Header Signature |
+| private_basic_token_credentials | [`PrivateBasicTokenCredentials`](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/auth/custom-header-signature-1.md) | The credential object for Custom Header Signature |
+| client_authorization_token_credentials | [`ClientAuthorizationTokenCredentials`](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/auth/oauth-2-client-credentials-grant.md) | The credential object for OAuth 2 Client Credentials Grant |
+| customer_header_credentials | [`CustomerHeaderCredentials`](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/auth/custom-header-signature-2.md) | The credential object for Custom Header Signature |
+
+The API client can be initialized as follows:
+
+### Code-Based Client Initialization
+
+```ruby
+require 'loyalty_ap_is'
+include LoyaltyApIs
+
+client = Client.new(
+  public_bearer_token_credentials: PublicBearerTokenCredentials.new(
+    access_token: 'AccessToken'
+  ),
+  public_basic_token_credentials: PublicBasicTokenCredentials.new(
+    public_basic_token: 'Public Basic Token'
+  ),
+  private_basic_token_credentials: PrivateBasicTokenCredentials.new(
+    public_basic_token: 'Public Basic Token'
+  ),
+  client_authorization_token_credentials: ClientAuthorizationTokenCredentials.new(
+    oauth_client_id: 'OAuthClientId',
+    oauth_client_secret: 'OAuthClientSecret'
+  ),
+  customer_header_credentials: CustomerHeaderCredentials.new(
+    authorization_token: 'Authorization-Token'
+  ),
+  environment: Environment::SIT,
+  logging_configuration: LoggingConfiguration.new(
+    log_level: Logger::INFO,
+    request_logging_config: RequestLoggingConfiguration.new(
+      log_body: true
+    ),
+    response_logging_config: ResponseLoggingConfiguration.new(
+      log_headers: true
+    )
+  )
+)
+```
+
+### Environment-Based Client Initialization
+
+```ruby
+require 'loyalty_ap_is'
+include LoyaltyApIs
+
+# Create client from environment
+client = Client.from_env
+```
+
+See the [`Environment-Based Client Initialization`](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/environment-based-client-initialization.md) section for details.
+
+## Environments
+
+The SDK can be configured to use a different environment for making API calls. Available environments are:
+
+### Fields
+
+| Name | Description |
+|  --- | --- |
+| SIT | **Default** |
+| PRODUCTION | - |
+| UAT | - |
+
+## Authorization
+
+This API uses the following authentication schemes.
+
+* [`PublicBearerToken (OAuth 2 Bearer token)`](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/auth/oauth-2-bearer-token.md)
+* [`PublicBasicToken (Custom Header Signature)`](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/auth/custom-header-signature.md)
+* [`PrivateBasicToken (Custom Header Signature)`](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/auth/custom-header-signature-1.md)
+* [`client-authorization-token (OAuth 2 Client Credentials Grant)`](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/auth/oauth-2-client-credentials-grant.md)
+* [`customerHeader (Custom Header Signature)`](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/auth/custom-header-signature-2.md)
+
+## List of APIs
+
+* [Profile Management](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/controllers/profile-management.md)
+* [Authorization](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/controllers/authorization.md)
+* [Offer](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/controllers/offer.md)
+* [Balances](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/controllers/balances.md)
+* [Redemption](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/controllers/redemption.md)
+* [Transaction](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/controllers/transaction.md)
+
+## SDK Infrastructure
+
+### Configuration
+
+* [ProxySettings](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/proxy-settings.md)
+* [Environment-Based Client Initialization](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/environment-based-client-initialization.md)
+* [AbstractLogger](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/abstract-logger.md)
+* [LoggingConfiguration](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/logging-configuration.md)
+* [RequestLoggingConfiguration](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/request-logging-configuration.md)
+* [ResponseLoggingConfiguration](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/response-logging-configuration.md)
+
+### HTTP
+
+* [HttpResponse](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/http-response.md)
+* [HttpRequest](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/http-request.md)
+
+### Utilities
+
+* [ApiResponse](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/api-response.md)
+* [ApiHelper](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/api-helper.md)
+* [DateTimeHelper](https://www.github.com/sdks-io/loyalty-ruby-sdk/tree/0.0.1/doc/date-time-helper.md)
+

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+# Load the lib folder into Ruby's load path
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+# Require the gem
+require 'loyalty_ap_is'
+
+puts 'LoyaltyApIs SDK loaded!'
+puts 'You can now create a client with: client = LoyaltyApIs::Client.new'
+puts 'Or use from_env: client = LoyaltyApIs::Client.from_env'
+
+# Start an interactive IRB session
+require 'irb'
+IRB.start

data/lib/loyalty_ap_is/api_helper.rb

@@ -0,0 +1,10 @@
+# loyalty_ap_is
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module LoyaltyApIs
+  # API utility class
+  class APIHelper < CoreLibrary::ApiHelper
+  end
+end

data/lib/loyalty_ap_is/apis/authorization_api.rb

@@ -0,0 +1,116 @@
+# loyalty_ap_is
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module LoyaltyApIs
+  # AuthorizationApi
+  class AuthorizationApi < BaseApi
+    # When partner wants to get the basic public token, to be authorized to
+    # perform any other call inside SSO, needs to call this endpoint
+    # @param [AuthTokenRequest] body Required parameter: Digest data generated
+    # using sha256(client_id)
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_authorization_token(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/api/v2/auth/token',
+                                     Server::SHELL)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AuthTokenResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request. If the request is missing the digest field',
+                                 JsonApiErrorException)
+                    .local_error('401',
+                                 'Unauthorized. If the digest provided is not valid',
+                                 JsonApiErrorException)
+                    .local_error('500',
+                                 'Any unexpected error',
+                                 JsonApiErrorException))
+        .execute
+    end
+
+    # This endpoint allows to given an access code to retrieve an user profile
+    # with a pair of valid tokens. In this end point, accessCode can be
+    # exchanged for an accessToken which is user-authorization-token.
+    # @param [String] authorization Required parameter: Basic Public token which
+    # was generated with auth/token end point.
+    # @param [ExchangeAccessCodeRequest] body Required parameter: Exchange
+    # access code data
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def exchange_access_code(authorization,
+                             body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/api/v2/auth/exchangeAccessCode',
+                                     Server::SHELL)
+                   .header_param(new_parameter(authorization, key: 'Authorization')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('PublicBasicToken')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(M200UserPartners.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized. If making the call with an invalid token',
+                                 JsonApiErrorException)
+                    .local_error('404',
+                                 'Not found. If the access code is not in the database',
+                                 JsonApiErrorException)
+                    .local_error('500',
+                                 'Any unexpected error',
+                                 JsonApiErrorException))
+        .execute
+    end
+
+    # When an access token has expired, a partner that wants to get a new pair
+    # of valid tokens to go on performing operations against SSO needs to call
+    # this endpoint.
+    # @param [String] authorization Required parameter: Basic Public token which
+    # was generated with auth/token end point.
+    # @param [RefreshTokenRequest] body Optional parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def refresh(authorization,
+                body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/api/v2/auth/token/refresh',
+                                     Server::SHELL)
+                   .header_param(new_parameter(authorization, key: 'Authorization')
+                                  .is_required(true))
+                   .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))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(RefreshTokenResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request. The request is missing the Refresh Token field.',
+                                 JsonApiErrorException)
+                    .local_error('401',
+                                 'Unauthorized. This response is generated when either the Basic'\
+                                  ' Token is invalid or the Refresh Token is invalid (see'\
+                                  ' examples)',
+                                 JsonApiErrorException)
+                    .local_error('500',
+                                 'Any unexpected error',
+                                 JsonApiErrorException))
+        .execute
+    end
+  end
+end

data/lib/loyalty_ap_is/apis/balances_api.rb

@@ -0,0 +1,96 @@
+# loyalty_ap_is
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module LoyaltyApIs
+  # BalancesApi
+  class BalancesApi < BaseApi
+    # Retrieve the customer's loyalty point balance
+    # @param [String] language_code Required parameter: This is a concatenation
+    # of language in lower case as per ISO 639-1 , “-” and country code as per
+    # ISO 3166-1 alpha-2.
+    # @param [String] user_authorization_token Required parameter: The value of
+    # the accessToken retrieved from the /auth/exchangeAccessCode endpoint. This
+    # is referred to as user-authorization-token where the access is provided by
+    # the end user.
+    # @param [String] consumer_uuid Required parameter: SSO uuid of the user
+    # signed in with Shell credentials Format: 32 hexadecimal digits grouped the
+    # following way: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+    # @param [String] country_code Required parameter: The two character ISO
+    # 3166-1 alpha-2 [country
+    # code](https://www.iso.org/iso-3166-country-codes.html).
+    # @param [UUID | String] x_correlation_id Optional parameter: An unique ID
+    # in GUID format in order to track the request.
+    # @param [AssignOfferChannel] channel Optional parameter: Channel.
+    # @param [String] application Optional parameter: String
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_balance_by_uuid(language_code,
+                            user_authorization_token,
+                            consumer_uuid,
+                            country_code,
+                            x_correlation_id: nil,
+                            channel: nil,
+                            application: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/consumers/balances',
+                                     Server::SHELL1)
+                   .query_param(new_parameter(language_code, key: 'language_code')
+                                 .is_required(true))
+                   .header_param(new_parameter(user_authorization_token, key: 'user-authorization-token')
+                                  .is_required(true))
+                   .header_param(new_parameter(consumer_uuid, key: 'consumerUUID')
+                                  .is_required(true))
+                   .header_param(new_parameter(country_code, key: 'country-code')
+                                  .is_required(true))
+                   .header_param(new_parameter(x_correlation_id, key: 'x-correlation-id'))
+                   .header_param(new_parameter(channel, key: 'channel'))
+                   .header_param(new_parameter(application, key: 'application'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(And.new('customerHeader', 'client-authorization-token')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CustomerBalances.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad request - The request was not valid. This code is returned'\
+                                  ' when the server has attempted to process the request, but some'\
+                                  ' aspect of the request is not valid, for example an incorrectly'\
+                                  ' formatted resource or an attempt to deploy an invalid event'\
+                                  ' project to the event runtime. Information about the request is'\
+                                  ' provided in the response body, and includes an error code and'\
+                                  ' error message.',
+                                 ConsumersBalances400ErrorException)
+                    .local_error('401',
+                                 "Unauthorized request, Missing Authorization header, or expired'\
+                                  ' authorization token etc. It is returned from the application'\
+                                  ' server \nwhen application security is enabled, and'\
+                                  ' authorization information was missing from the request.\n",
+                                 ConsumersBalances401ErrorException)
+                    .local_error('404',
+                                 'Not found - the server can not find the requested resource.',
+                                 ConsumersBalances404ErrorException)
+                    .local_error('422',
+                                 "Unprocessable Entity (WebDAV). If you are receiving an HTTP'\
+                                  ' 422 - Unprocessable Entity error, \nthere are several'\
+                                  ' possibilities for why it might be occurring-<br>\n - You are'\
+                                  ' sending in a payload that is not valid JSON. <br> \n - You are'\
+                                  ' sending HTTP headers, such as Content-Type or Accept, which'\
+                                  ' specify a value other than application/json. <br>\n - The'\
+                                  ' request may be valid JSON, but there is something wrong with'\
+                                  ' the content. \n",
+                                 ConsumersBalances422ErrorException)
+                    .local_error('429',
+                                 'Rate limit hit. See the Retry-After header to specify a delay,'\
+                                  ' but note that there is no guarantee that subsequent requests'\
+                                  ' won\'t be limited.',
+                                 APIException)
+                    .local_error('500',
+                                 'Internal error - the server encountered an unexpected'\
+                                  ' condition that prevented it from fulfilling the request.',
+                                 APIException))
+        .execute
+    end
+  end
+end

data/lib/loyalty_ap_is/apis/base_api.rb

@@ -0,0 +1,67 @@
+# loyalty_ap_is
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module LoyaltyApIs
+  # BaseApi.
+  class BaseApi
+    include CoreLibrary
+    attr_accessor :config, :http_call_back
+
+    def self.user_agent
+      'Ruby-SDK/0.0.1 (OS: {os-info}, Engine: {engine}/{engine-version})'
+    end
+
+    def self.user_agent_parameters
+      {
+        '{engine}' => { 'value' => RUBY_ENGINE, 'encode' => false },
+        '{engine-version}' => { 'value' => RUBY_ENGINE_VERSION, 'encode' => false },
+        '{os-info}' => { 'value' => RUBY_PLATFORM, 'encode' => false }
+      }
+    end
+
+    GLOBAL_ERRORS = {
+      'default' => ErrorCase.new
+                            .error_message('HTTP response not OK.')
+                            .exception_type(APIException)
+    }.freeze
+
+    # Initialization constructor.
+    # @param [GlobalConfiguration] global_configuration The instance of GlobalConfiguration.
+    def initialize(global_configuration)
+      @global_configuration = global_configuration
+      @config = @global_configuration.client_configuration
+      @http_call_back = @config.http_callback
+      @api_call = ApiCall.new(@global_configuration)
+    end
+
+    # Creates a new instance of the request builder.
+    # @param [String] http_method The HTTP method to use in the request.
+    # @param [String] path The endpoint path to use in the request.
+    # @param [String] server The server to extract the base uri for the request.
+    # @return [RequestBuilder] The instance of RequestBuilder.
+    def new_request_builder(http_method, path, server)
+      RequestBuilder.new
+                    .http_method(http_method)
+                    .path(path)
+                    .server(server)
+    end
+
+    # Creates a new instance of the response handler.
+    # @return [ResponseHandler] The instance of ResponseHandler.
+    def new_response_handler
+      ResponseHandler.new
+    end
+
+    # Creates a new instance of the parameter.
+    # @param [String|optional] key The key of the parameter.
+    # @param [Object] value The value of the parameter.
+    # @return [Parameter] The instance of Parameter.
+    def new_parameter(value, key: nil)
+      Parameter.new
+               .key(key)
+               .value(value)
+    end
+  end
+end

data/lib/loyalty_ap_is/apis/oauth_authorization_api.rb

@@ -0,0 +1,44 @@
+# loyalty_ap_is
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module LoyaltyApIs
+  # 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_client_authorization_token(authorization,
+                                                 scope: nil,
+                                                 _field_parameters: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/v2/oauth/token',
+                                     Server::OAUTH_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