pq-api-matic-sdk 1.0.0

data/lib/pay_quicker_sdk/configuration.rb

@@ -0,0 +1,229 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # An enum for SDK environments.
+  class Environment
+    # PRODUCTION: Production
+    # SANDBOX: Sandbox is used for both sandbox testing and customer UAT.
+    # UAT: UAT is used for both sandbox testing and customer UAT.
+    # DEVELOPMENT: Development is used for local development testing.
+    ENVIRONMENT = [
+      PRODUCTION = 'production'.freeze,
+      SANDBOX = 'sandbox'.freeze,
+      UAT = 'uat'.freeze,
+      DEVELOPMENT = 'development'.freeze
+    ].freeze
+
+    # Converts a string or symbol into a valid Environment constant.
+    def self.from_value(value, default_value = PRODUCTION)
+      return default_value if value.nil?
+
+      str = value.to_s.strip.downcase
+      case str
+      when 'production' then PRODUCTION
+      when 'sandbox' then SANDBOX
+      when 'uat' then UAT
+      when 'development' then DEVELOPMENT
+
+      else
+        warn "[Environment] Unknown environment '#{value}', falling back to #{default_value} "
+        default_value
+      end
+    end
+  end
+
+  # An enum for API servers.
+  class Server
+    SERVER = [
+      API = 'api'.freeze
+    ].freeze
+
+    # Converts a string or symbol into a valid Server constant.
+    def self.from_value(value, default_value = API)
+      return default_value if value.nil?
+
+      default_value
+    end
+  end
+
+  # All configuration including auth info and base URI for the API access
+  # are configured in this class.
+  class Configuration < CoreLibrary::HttpClientConfiguration
+    # The attribute readers for properties.
+    attr_reader :environment, :sandbox_instance, :uat_instance,
+                :server_credentials, :clientside_credentials,
+                :x_my_pay_quicker_version
+
+    class << self
+      attr_reader :environments
+    end
+
+    def initialize(
+      connection: nil, adapter: :net_http_persistent, timeout: 60,
+      max_retries: 0, retry_interval: 1, backoff_factor: 2,
+      retry_statuses: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524],
+      retry_methods: %i[get put], http_callback: nil, proxy_settings: nil,
+      logging_configuration: nil, environment: Environment::SANDBOX,
+      sandbox_instance: SandboxInstance::SANDBOX,
+      uat_instance: UatInstance::UAT1, server_credentials: nil,
+      clientside_credentials: nil, x_my_pay_quicker_version: '2026.02.01'
+    )
+      super connection: connection, adapter: adapter, timeout: timeout,
+            max_retries: max_retries, retry_interval: retry_interval,
+            backoff_factor: backoff_factor, retry_statuses: retry_statuses,
+            retry_methods: retry_methods, http_callback: http_callback,
+            proxy_settings: proxy_settings,
+            logging_configuration: logging_configuration
+
+      # Current API environment
+      @environment = String(environment)
+
+      # Sandbox Environments
+      @sandbox_instance = sandbox_instance
+
+      # UAT Environments
+      @uat_instance = uat_instance
+
+      # The object holding OAuth 2 Client Credentials Grant credentials
+      @server_credentials = server_credentials
+
+      # The object holding OAuth 2 Bearer token credentials
+      @clientside_credentials = clientside_credentials
+
+      # Date-based API Version specified in the header *required* on all calls.
+      @x_my_pay_quicker_version = x_my_pay_quicker_version
+
+      # The Http Client to use for making requests.
+      set_http_client CoreLibrary::FaradayClient.new(self)
+    end
+
+    def clone_with(connection: nil, adapter: nil, timeout: nil,
+                   max_retries: nil, retry_interval: nil, backoff_factor: nil,
+                   retry_statuses: nil, retry_methods: nil, http_callback: nil,
+                   proxy_settings: nil, logging_configuration: nil,
+                   environment: nil, sandbox_instance: nil, uat_instance: nil,
+                   server_credentials: nil, clientside_credentials: nil,
+                   x_my_pay_quicker_version: nil)
+      connection ||= self.connection
+      adapter ||= self.adapter
+      timeout ||= self.timeout
+      max_retries ||= self.max_retries
+      retry_interval ||= self.retry_interval
+      backoff_factor ||= self.backoff_factor
+      retry_statuses ||= self.retry_statuses
+      retry_methods ||= self.retry_methods
+      http_callback ||= self.http_callback
+      proxy_settings ||= self.proxy_settings
+      logging_configuration ||= self.logging_configuration
+      environment ||= self.environment
+      sandbox_instance ||= self.sandbox_instance
+      uat_instance ||= self.uat_instance
+      server_credentials ||= self.server_credentials
+      clientside_credentials ||= self.clientside_credentials
+      x_my_pay_quicker_version ||= self.x_my_pay_quicker_version
+
+      Configuration.new(connection: connection, adapter: adapter,
+                        timeout: timeout, max_retries: max_retries,
+                        retry_interval: retry_interval,
+                        backoff_factor: backoff_factor,
+                        retry_statuses: retry_statuses,
+                        retry_methods: retry_methods,
+                        http_callback: http_callback,
+                        proxy_settings: proxy_settings,
+                        logging_configuration: logging_configuration,
+                        environment: environment,
+                        sandbox_instance: sandbox_instance,
+                        uat_instance: uat_instance,
+                        server_credentials: server_credentials,
+                        clientside_credentials: clientside_credentials,
+                        x_my_pay_quicker_version: x_my_pay_quicker_version)
+    end
+
+
+    # All the environments the SDK can run in.
+    ENVIRONMENTS = {
+      Environment::PRODUCTION => {
+        Server::API => 'https://api.payquicker.io/api/v2'
+      },
+      Environment::SANDBOX => {
+        Server::API => 'https://api.{sandbox_instance}.payquicker.io/api/v2'
+      },
+      Environment::UAT => {
+        Server::API => 'https://api.{uat_instance}.payquicker.io/api/v2'
+      },
+      Environment::DEVELOPMENT => {
+        Server::API => 'https://api.local.payquicker.io/api/v2'
+      }
+    }.freeze
+
+    # Generates the appropriate base URI for the environment and the server.
+    # @param [Configuration::Server] server The server enum for which the base URI is
+    # required.
+    # @return [String] The base URI.
+    def get_base_uri(server = Server::API)
+      parameters = {
+        'sandbox_instance' => { 'value' => sandbox_instance, 'encode' => false },
+        'uat_instance' => { 'value' => uat_instance, 'encode' => false }
+      }
+      APIHelper.append_url_with_template_parameters(
+        ENVIRONMENTS[environment][server], parameters
+      )
+    end
+
+    # Builds a Configuration instance using environment variables.
+    def self.build_default_config_from_env
+      # === Core environment ===
+      environment = Environment.from_value(ENV.fetch('ENVIRONMENT', 'sandbox'))
+      sandbox_instance = SandboxInstance.from_value(ENV.fetch('SANDBOX_INSTANCE', 'sandbox'))
+      uat_instance = UatInstance.from_value(ENV.fetch('UAT_INSTANCE', 'uat1'))
+      x_my_pay_quicker_version = ENV.fetch('X_MY_PAY_QUICKER_VERSION',
+                                           '2026.02.01')
+      timeout = (ENV['TIMEOUT'] || 60).to_f
+      max_retries = (ENV['MAX_RETRIES'] || 0).to_i
+      retry_interval = (ENV['RETRY_INTERVAL'] || 1).to_f
+      backoff_factor = (ENV['BACKOFF_FACTOR'] || 2).to_f
+      retry_statuses = ENV.fetch('RETRY_STATUSES',
+                                 '[408, 413, 429, 500, 502, 503, 504, 521, 522, 524]').gsub(/[\[\]]/, '')
+                                          .split(',')
+                                          .map(&:strip)
+                                          .map do |item|
+                                            item.match?(/\A\d+\z/) ? item.to_i : item.downcase
+                                          end
+      retry_methods = ENV.fetch('RETRY_METHODS', '%i[get put]').gsub(/[\[\]]/, '')
+                                          .split(',')
+                                          .map(&:strip)
+                                          .map do |item|
+                                            item.match?(/\A\d+\z/) ? item.to_i : item.downcase
+                                          end
+
+      # === Authentication credentials ===
+      server_credentials = ServerCredentials.from_env
+      clientside_credentials = ClientsideCredentials.from_env
+
+      # === Proxy settings ===
+      proxy_settings = ProxySettings.from_env
+      # === Logging Configuration ===
+      logging_configuration = LoggingConfiguration.from_env if LoggingConfiguration.any_logging_configured?
+
+      Configuration.new(
+        environment: environment,
+        sandbox_instance: sandbox_instance,
+        uat_instance: uat_instance,
+        x_my_pay_quicker_version: x_my_pay_quicker_version,
+        timeout: timeout,
+        max_retries: max_retries,
+        retry_interval: retry_interval,
+        backoff_factor: backoff_factor,
+        retry_statuses: retry_statuses,
+        retry_methods: retry_methods,
+        server_credentials: server_credentials,
+        clientside_credentials: clientside_credentials,
+        proxy_settings: proxy_settings,
+        logging_configuration: logging_configuration
+      )
+    end
+  end
+end

data/lib/pay_quicker_sdk/controllers/agreements_controller.rb

@@ -0,0 +1,129 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # AgreementsController
+  class AgreementsController < BaseController
+    # Retrieve a list of program [agreements](page:resources/agreements) that
+    # supports filtering, sorting, and pagination through existing mechanisms.
+    # @param [String] program_token Required parameter: Auto-generated unique
+    # identifier representing a program, prefixed with `prog-`.
+    # @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 [AgreementListResultJson] Response from the API call.
+    def list_agreements(program_token,
+                        page,
+                        page_size,
+                        filter: nil,
+                        sort: nil,
+                        language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{program-token}/agreements',
+                                     Server::API)
+                   .template_param(new_parameter(program_token, key: 'program-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(AgreementListResultJson.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a single program [agreement](page:resources/agreements).
+    # @param [String] program_token Required parameter: Auto-generated unique
+    # identifier representing a program, prefixed with `prog-`.
+    # @param [String] agreement_token Required parameter: Auto-generated unique
+    # identifier representing a program agreement, prefixed with `agmt-`.
+    # @return [AgreementResult] Response from the API call.
+    def retrieve_program_agreement(program_token,
+                                   agreement_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{program-token}/agreements/{agreement-token}',
+                                     Server::API)
+                   .template_param(new_parameter(program_token, key: 'program-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(agreement_token, key: 'agreement-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(AgreementResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Accept a single program [agreement](page:resources/agreements).
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] agreement_token Required parameter: Auto-generated unique
+    # identifier representing a program agreement, prefixed with `agmt-`.
+    # @return [void] Response from the API call.
+    def accept_agreement(user_token,
+                         agreement_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/users/{user-token}/agreements/{agreement-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(agreement_token, key: 'agreement-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .is_response_void(true)
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+  end
+end

data/lib/pay_quicker_sdk/controllers/balances_controller.rb

@@ -0,0 +1,156 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # BalancesController
+  class BalancesController < BaseController
+    # Retrieve a list of bank account [balances](page:resources/balances) 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 [BalanceListResult] Response from the API call.
+    def list_account_balances(account_token,
+                              page,
+                              page_size,
+                              filter: nil,
+                              sort: nil,
+                              language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/accounts/{account-token}/balances',
+                                     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(BalanceListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a list of user [balances](page:resources/balances) 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 [BalanceListResult] Response from the API call.
+    def list_user_balances(user_token,
+                           page,
+                           page_size,
+                           filter: nil,
+                           sort: nil,
+                           language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/balances',
+                                     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(BalanceListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a [prepaid card](page:resources/prepaid-cards)
+    # [balances](page:resources/balances) by destination token 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 [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 [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [BalanceResult] Response from the API call.
+    def retrieve_card_balance(user_token,
+                              destination_token,
+                              language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/prepaid-cards/{destination-token}/balances',
+                                     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(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(BalanceResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+  end
+end