pq-api-matic-sdk 1.0.0

data/lib/pay_quicker_sdk/controllers/bank_accounts_controller.rb

@@ -0,0 +1,587 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # BankAccountsController
+  class BankAccountsController < BaseController
+    # Retrieve a list of [bank accounts](page:resources/bank-accounts) that
+    # supports filtering, sorting, and pagination through existing mechanisms.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [Integer] page Required parameter: Page number of specific page to
+    # return
+    # @param [Integer] page_size Required parameter: Number of items to be
+    # displayed per page
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [String] sort Optional parameter: Sort request results by specific
+    # attribute.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [BankAccountListResult] Response from the API call.
+    def list_bank_accounts(user_token,
+                           page,
+                           page_size,
+                           filter: nil,
+                           sort: nil,
+                           language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/bank-accounts',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(page, key: 'page')
+                                 .is_required(true))
+                   .query_param(new_parameter(page_size, key: 'pageSize')
+                                 .is_required(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(sort, key: 'sort'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BankAccountListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Create a [bank account](page:resources/bank-accounts) using a user token.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [CreateOrUpdateBankAccount] body Optional parameter: TODO: type
+    # description here
+    # @return [BankAccountResult] Response from the API call.
+    def create_bank_account(user_token,
+                            body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/users/{user-token}/bank-accounts',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(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)
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BankAccountResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a single [bank account](page:resources/bank-accounts) using a
+    # destination token.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] destination_token Required parameter: Auto-generated
+    # unique identifier representing a transfer destination, including prepaid
+    # cards, bank accounts, paper checks, and other users, prefixed with
+    # `dest-`.
+    # @param [Integer] page Required parameter: Page number of specific page to
+    # return
+    # @param [Integer] page_size Required parameter: Number of items to be
+    # displayed per page
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [String] sort Optional parameter: Sort request results by specific
+    # attribute.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [BankAccountResult] Response from the API call.
+    def retrieve_bank_account(user_token,
+                              destination_token,
+                              page,
+                              page_size,
+                              filter: nil,
+                              sort: nil,
+                              language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/bank-accounts/{destination-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(destination_token, key: 'destination-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(page, key: 'page')
+                                 .is_required(true))
+                   .query_param(new_parameter(page_size, key: 'pageSize')
+                                 .is_required(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(sort, key: 'sort'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BankAccountResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Update a [bank account](page:resources/bank-accounts).
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] destination_token Required parameter: Auto-generated
+    # unique identifier representing a transfer destination, including prepaid
+    # cards, bank accounts, paper checks, and other users, prefixed with
+    # `dest-`.
+    # @param [CreateOrUpdateBankAccount] body Optional parameter: TODO: type
+    # description here
+    # @return [BankAccountResult] Response from the API call.
+    def update_bank_account(user_token,
+                            destination_token,
+                            body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/users/{user-token}/bank-accounts/{destination-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(destination_token, key: 'destination-token')
+                                    .is_required(true)
+                                    .should_encode(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(BankAccountResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Delete a user [bank account](page:resources/bank-accounts).
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] destination_token Required parameter: Auto-generated
+    # unique identifier representing a transfer destination, including prepaid
+    # cards, bank accounts, paper checks, and other users, prefixed with
+    # `dest-`.
+    # @return [OperationResult] Response from the API call.
+    def delete_bank_account(user_token,
+                            destination_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/users/{user-token}/bank-accounts/{destination-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(destination_token, key: 'destination-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(OperationResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve requirements for adding a [bank
+    # account](page:resources/bank-accounts) using the parameters provided.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [Countries] country Optional parameter: Filter results by
+    # country.
+    # @param [Currencies] currency Optional parameter: Filter results by
+    # currency.
+    # @return [BankAccountRequirementListResult] Response from the API call.
+    def retrieve_creation_requirements(user_token,
+                                       country: nil,
+                                       currency: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/bank-accounts/requirements',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(country, key: 'country'))
+                   .query_param(new_parameter(currency, key: 'currency'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BankAccountRequirementListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a list of company [bank accounts](page:resources/bank-accounts)
+    # that supports filtering, sorting, and pagination through existing
+    # mechanisms.
+    # @param [String] account_token Required parameter: Auto-generated unique
+    # identifier representing a company account, prefixed with `acct-`.
+    # @param [Integer] page Required parameter: Page number of specific page to
+    # return
+    # @param [Integer] page_size Required parameter: Number of items to be
+    # displayed per page
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [String] sort Optional parameter: Sort request results by specific
+    # attribute.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [BankAccountListResult] Response from the API call.
+    def list_company_bank_accounts(account_token,
+                                   page,
+                                   page_size,
+                                   filter: nil,
+                                   sort: nil,
+                                   language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/accounts/{account-token}/bank-accounts',
+                                     Server::API)
+                   .template_param(new_parameter(account_token, key: 'account-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(page, key: 'page')
+                                 .is_required(true))
+                   .query_param(new_parameter(page_size, key: 'pageSize')
+                                 .is_required(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(sort, key: 'sort'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BankAccountListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Create a company [bank account](page:resources/bank-accounts) using an
+    # account token.
+    # @param [String] account_token Required parameter: Auto-generated unique
+    # identifier representing a company account, prefixed with `acct-`.
+    # @param [CreateOrUpdateBankAccount] body Optional parameter: TODO: type
+    # description here
+    # @return [BankAccountResult] Response from the API call.
+    def create_company_bank_account(account_token,
+                                    body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/accounts/{account-token}/bank-accounts',
+                                     Server::API)
+                   .template_param(new_parameter(account_token, key: 'account-token')
+                                    .is_required(true)
+                                    .should_encode(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)
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BankAccountResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a single company [bank account](page:resources/bank-accounts)
+    # using a destination token.
+    # @param [String] account_token Required parameter: Auto-generated unique
+    # identifier representing a company account, prefixed with `acct-`.
+    # @param [String] destination_token Required parameter: Auto-generated
+    # unique identifier representing a transfer destination, including prepaid
+    # cards, bank accounts, paper checks, and other users, prefixed with
+    # `dest-`.
+    # @param [Integer] page Required parameter: Page number of specific page to
+    # return
+    # @param [Integer] page_size Required parameter: Number of items to be
+    # displayed per page
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [String] sort Optional parameter: Sort request results by specific
+    # attribute.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [BankAccountResult] Response from the API call.
+    def retrieve_company_bank_account(account_token,
+                                      destination_token,
+                                      page,
+                                      page_size,
+                                      filter: nil,
+                                      sort: nil,
+                                      language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/accounts/{account-token}/bank-accounts/{destination-token}',
+                                     Server::API)
+                   .template_param(new_parameter(account_token, key: 'account-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(destination_token, key: 'destination-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(page, key: 'page')
+                                 .is_required(true))
+                   .query_param(new_parameter(page_size, key: 'pageSize')
+                                 .is_required(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(sort, key: 'sort'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BankAccountResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Update a company [bank account](page:resources/bank-accounts).
+    # @param [String] account_token Required parameter: Auto-generated unique
+    # identifier representing a company account, prefixed with `acct-`.
+    # @param [String] destination_token Required parameter: Auto-generated
+    # unique identifier representing a transfer destination, including prepaid
+    # cards, bank accounts, paper checks, and other users, prefixed with
+    # `dest-`.
+    # @param [CreateOrUpdateBankAccount] body Optional parameter: TODO: type
+    # description here
+    # @return [BankAccountResult] Response from the API call.
+    def update_company_bank_account(account_token,
+                                    destination_token,
+                                    body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/accounts/{account-token}/bank-accounts/{destination-token}',
+                                     Server::API)
+                   .template_param(new_parameter(account_token, key: 'account-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(destination_token, key: 'destination-token')
+                                    .is_required(true)
+                                    .should_encode(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)
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BankAccountResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Delete a company [bank account](page:resources/bank-accounts).
+    # @param [String] account_token Required parameter: Auto-generated unique
+    # identifier representing a company account, prefixed with `acct-`.
+    # @param [String] destination_token Required parameter: Auto-generated
+    # unique identifier representing a transfer destination, including prepaid
+    # cards, bank accounts, paper checks, and other users, prefixed with
+    # `dest-`.
+    # @return [OperationResult] Response from the API call.
+    def delete_company_bank_account(account_token,
+                                    destination_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/accounts/{account-token}/bank-accounts/{destination-token}',
+                                     Server::API)
+                   .template_param(new_parameter(account_token, key: 'account-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(destination_token, key: 'destination-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(OperationResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve requirements for adding a [bank
+    # account](page:resources/bank-accounts) using the parameters provided.
+    # @param [String] account_token Required parameter: Auto-generated unique
+    # identifier representing a company account, prefixed with `acct-`.
+    # @param [Countries] country Optional parameter: Filter results by
+    # country.
+    # @param [Currencies] currency Optional parameter: Filter results by
+    # currency.
+    # @return [BankAccountRequirementListResult] Response from the API call.
+    def retrieve_company_bank_account_creation_requirements(account_token,
+                                                            country: nil,
+                                                            currency: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/accounts/{account-token}/bank-accounts/requirements',
+                                     Server::API)
+                   .template_param(new_parameter(account_token, key: 'account-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(country, key: 'country'))
+                   .query_param(new_parameter(currency, key: 'currency'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BankAccountRequirementListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve requirements for adding a [bank
+    # account](page:resources/bank-accounts) using the pre-paid card as the
+    # destination.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] destination_token Required parameter: Auto-generated
+    # unique identifier representing a transfer destination, including prepaid
+    # cards, bank accounts, paper checks, and other users, prefixed with
+    # `dest-`.
+    # @param [Countries] country Optional parameter: Filter results by
+    # country.
+    # @param [Currencies] currency Optional parameter: Filter results by
+    # currency.
+    # @return [BankAccountRequirementListResult] Response from the API call.
+    def retrieve_bank_account_creation_requirements_for_a_prepaid_card(user_token,
+                                                                       destination_token,
+                                                                       country: nil,
+                                                                       currency: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/prepaid-cards/{destination-token}/bank-accounts/requirements',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(destination_token, key: 'destination-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(country, key: 'country'))
+                   .query_param(new_parameter(currency, key: 'currency'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(BankAccountRequirementListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+  end
+end

data/lib/pay_quicker_sdk/controllers/base_controller.rb

@@ -0,0 +1,60 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # BaseController.
+  class BaseController
+    include CoreLibrary
+    attr_accessor :config, :http_call_back
+
+    def self.user_agent
+      'PayQuicker SDK 2026.02.01'
+    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