voltaria_sdk 2.34.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7323267929d363a6ed23706221d2733e2fd02bbd16fd399f88114c704cda41f3
+  data.tar.gz: 0e3e178f4802b5b34998b5d71a16672cf6f004d8c4b89d7dba07aa222e82b4b5
+SHA512:
+  metadata.gz: 8cf08fb7772427072cb4d94bea6841886fa2aee3aba9df689e0d2fd987969c99feed56d12b4f4fca01bc499ac37dca94f2508270881beb9d9fbb7d0775aaf3e6
+  data.tar.gz: 6c6251ab6926ff847e6b7b3371052137150047b4a9e54fd4804fa60cb3f0fd696c17d51229bb8bfd266e3f1c0e1f7d5044ec7f6b770680c525d28278beae64f0

data/.rubocop.yml

@@ -0,0 +1,69 @@
+plugins:
+  - rubocop-minitest
+
+AllCops:
+  TargetRubyVersion: 3.3
+  NewCops: enable
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/AccessModifierDeclarations:
+  Enabled: false
+
+Lint/ConstantDefinitionInBlock:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Layout/LineLength:
+  Enabled: false
+
+Naming/VariableNumber:
+  EnforcedStyle: normalcase
+
+Style/Documentation:
+  Enabled: false
+
+Style/Lambda:
+  EnforcedStyle: literal
+
+Minitest/MultipleAssertions:
+  Enabled: false
+
+Minitest/UselessAssertion:
+  Enabled: false
+
+# Dynamic snippets are code samples for documentation, not standalone Ruby files.
+Style/FrozenStringLiteralComment:
+  Exclude:
+    - "dynamic-snippets/**/*"
+
+Layout/FirstHashElementIndentation:
+  Exclude:
+    - "dynamic-snippets/**/*"

data/README.md

@@ -0,0 +1,202 @@
+<!-- voltaria-readme-assembled -->
+# Voltaria Ruby Library
+
+## Quickstart
+
+Install the gem:
+
+```bash
+gem install voltaria_sdk
+```
+
+Then load it with `require "voltaria"`.
+
+Construct a client with `Voltaria.new`, passing your API key. The base URL is derived automatically from the key prefix:
+
+```ruby
+require "voltaria"
+
+# Production
+client = Voltaria.new("live_...")
+
+# Sandbox
+# client = Voltaria.new("sandbox_...")
+
+# List loans
+loans = client.loans.list_loans
+```
+
+| Key prefix | Environment | Base URL                          |
+| ---------- | ----------- | --------------------------------- |
+| `live_`    | Production  | `https://api.voltaria.io`         |
+| `sandbox_` | Sandbox     | `https://api.sandbox.voltaria.io` |
+
+Passing an explicit `base_url:` overrides prefix routing.
+
+See [reference.md](./reference.md) for the full API reference.
+
+---
+
+[![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-Built%20with%20Fern-brightgreen)](https://buildwithfern.com?utm_source=github&utm_medium=github&utm_campaign=readme&utm_source=Voltaria%2FRuby)
+
+The Voltaria Ruby library provides convenient access to the Voltaria APIs from Ruby.
+
+## Table of Contents
+
+- [Reference](#reference)
+- [Usage](#usage)
+- [Environments](#environments)
+- [Errors](#errors)
+- [Advanced](#advanced)
+  - [Retries](#retries)
+  - [Timeouts](#timeouts)
+  - [Additional Headers](#additional-headers)
+  - [Additional Query Parameters](#additional-query-parameters)
+- [Contributing](#contributing)
+
+## Reference
+
+A full reference for this library is available [here](./reference.md).
+
+## Usage
+
+Instantiate and use the client with the following:
+
+```ruby
+require "voltaria"
+
+client = Voltaria::Client.new(token: "<token>")
+
+client.clients.create_client(
+  name: "ACME Corp",
+  jurisdiction: "eu"
+)
+```
+
+## Environments
+
+This SDK allows you to configure different environments or custom URLs for API requests. You can either use the predefined environments or specify your own custom URL.
+### Environments
+```ruby
+require "voltaria"
+
+voltaria = Voltaria::Client.new(
+    base_url: Voltaria::Environment::SANDBOX
+)
+```
+
+### Custom URL
+```ruby
+require "voltaria"
+
+client = Voltaria::Client.new(
+    base_url: "https://example.com"
+)
+```
+
+## Errors
+
+Failed API calls will raise errors that can be rescued from granularly.
+
+```ruby
+require "voltaria"
+
+client = Voltaria::Client.new(
+    base_url: "https://example.com"
+)
+
+begin
+    result = client.clients.create_client
+rescue Voltaria::Errors::TimeoutError
+    puts "API didn't respond before our timeout elapsed"
+rescue Voltaria::Errors::ServiceUnavailableError
+    puts "API returned status 503, is probably overloaded, try again later"
+rescue Voltaria::Errors::ServerError
+    puts "API returned some other 5xx status, this is probably a bug"
+rescue Voltaria::Errors::ResponseError => e
+    puts "API returned an unexpected status other than 5xx: #{e.code} #{e.message}"
+rescue Voltaria::Errors::ApiError => e
+    puts "Some other error occurred when calling the API: #{e.message}"
+end
+```
+
+## Advanced
+
+### Retries
+
+The SDK is instrumented with automatic retries. A request will be retried as long as the request is deemed
+retryable and the number of retry attempts has not grown larger than the configured retry limit (default: 2).
+
+A request is deemed retryable when any of the following HTTP status codes is returned:
+
+- [408](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/408) (Timeout)
+- [429](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429) (Too Many Requests)
+- [5XX](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500) (Internal Server Errors)
+
+Use the `max_retries` option to configure this behavior.
+
+```ruby
+require "voltaria"
+
+client = Voltaria::Client.new(
+    base_url: "https://example.com",
+    max_retries: 3  # Configure max retries (default is 2)
+)
+```
+
+### Timeouts
+
+The SDK defaults to a 60 second timeout. Use the `timeout` option to configure this behavior.
+
+```ruby
+require "voltaria"
+
+response = client.clients.create_client(
+    ...,
+    timeout: 30  # 30 second timeout
+)
+```
+
+### Additional Headers
+
+If you would like to send additional headers as part of the request, use the `additional_headers` request option.
+
+```ruby
+require "voltaria"
+
+response = client.clients.create_client(
+    ...,
+    request_options: {
+        additional_headers: {
+            "X-Custom-Header" => "custom-value"
+        }
+    }
+)
+```
+
+### Additional Query Parameters
+
+If you would like to send additional query parameters as part of the request, use the `additional_query_parameters` request option.
+
+```ruby
+require "voltaria"
+
+response = client.clients.create_client(
+    ...,
+    request_options: {
+        additional_query_parameters: {
+            "custom_param" => "custom-value"
+        }
+    }
+)
+```
+
+## Contributing
+
+While we value open-source contributions to this SDK, this library is generated programmatically.
+Additions made directly to this library would have to be moved over to our generation code,
+otherwise they would be overwritten upon the next generated release. Feel free to open a PR as
+a proof of concept, but know that we will not be able to merge it as-is. We suggest opening
+an issue first to discuss with us!
+
+On the other hand, contributions to the README are always very welcome!

data/Rakefile

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test]
+
+task lint: %i[rubocop]
+
+# Run only the custom test file
+Minitest::TestTask.create(:customtest) do |t|
+  t.libs << "test"
+  t.test_globs = ["test/custom.test.rb"]
+end

data/custom.gemspec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Custom gemspec configuration file
+# This file is automatically loaded by the main gemspec file. The 'spec' variable is available
+# in this context from the main gemspec file. You can modify this file to add custom metadata,
+# dependencies, or other gemspec configurations. If you do make changes to this file, you will
+# need to add it to the .fernignore file to prevent your changes from being overwritten.
+
+def add_custom_gemspec_data(spec)
+  # Example custom configurations (uncomment and modify as needed)
+
+  # spec.authors = ["Your name"]
+  # spec.email = ["your.email@example.com"]
+  # spec.homepage = "https://github.com/your-org/voltaria-ruby"
+  # spec.license = "Your license"
+end

data/lib/voltaria/accounts/client.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Accounts
+    class Client
+      # @param client [Voltaria::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Return the required and optional bank account fields for each supported currency. Fetch once and cache; use it
+      # to build the create-account request.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :client_id
+      #
+      # @return [Hash[String, Voltaria::Types::CurrencyFieldSpec]]
+      def list_client_account_fields(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        request = Voltaria::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v2/clients/#{URI.encode_uri_component(params[:client_id].to_s)}/accounts/fields",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Voltaria::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        return if code.between?(200, 299)
+
+        error_class = Voltaria::Errors::ResponseError.subclass_for_code(code)
+        raise error_class.new(response.body, code: code)
+      end
+
+      # Retrieve all bank accounts for one of your clients.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :client_id
+      # @option params [Integer, nil] :page
+      # @option params [Integer, nil] :page_size
+      # @option params [String, nil] :order_by
+      #
+      # @return [Voltaria::Types::PaginatedResponseClientAccountResponse]
+      def list_client_accounts(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[page page_size order_by]
+        query_params = {}
+        query_params["page"] = params[:page] if params.key?(:page)
+        query_params["page_size"] = params[:page_size] if params.key?(:page_size)
+        query_params["order_by"] = params[:order_by] if params.key?(:order_by)
+        params = params.except(*query_param_names)
+
+        request = Voltaria::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v2/clients/#{URI.encode_uri_component(params[:client_id].to_s)}/accounts",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Voltaria::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Voltaria::Types::PaginatedResponseClientAccountResponse.load(response.body)
+        else
+          error_class = Voltaria::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Create a bank account for one of your clients. The account is registered with the payment provider immediately.
+      # Use the `status` field to create it as `active` (default; demotes any existing active account in the same
+      # currency to `passive`) or `passive`.
+      #
+      # @param request_options [Hash]
+      # @param params [Voltaria::Accounts::Types::PartnerClientAccountCreateRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :client_id
+      #
+      # @return [Voltaria::Types::ClientAccountResponse]
+      def create_client_account(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        request_data = Voltaria::Accounts::Types::PartnerClientAccountCreateRequest.new(params).to_h
+        non_body_param_names = ["client_id"]
+        body = request_data.except(*non_body_param_names)
+
+        request = Voltaria::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v2/clients/#{URI.encode_uri_component(params[:client_id].to_s)}/accounts",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Voltaria::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Voltaria::Types::ClientAccountResponse.load(response.body)
+        else
+          error_class = Voltaria::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Retrieve a specific bank account for one of your clients.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :client_id
+      # @option params [String] :account_id
+      #
+      # @return [Voltaria::Types::ClientAccountResponse]
+      def get_client_account(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        request = Voltaria::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v2/clients/#{URI.encode_uri_component(params[:client_id].to_s)}/accounts/#{URI.encode_uri_component(params[:account_id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Voltaria::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Voltaria::Types::ClientAccountResponse.load(response.body)
+        else
+          error_class = Voltaria::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+    end
+  end
+end

data/lib/voltaria/accounts/types/get_client_account_request.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Accounts
+    module Types
+      class GetClientAccountRequest < Internal::Types::Model
+        field :client_id, -> { String }, optional: false, nullable: false
+        field :account_id, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/voltaria/accounts/types/list_client_account_fields_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Accounts
+    module Types
+      class ListClientAccountFieldsRequest < Internal::Types::Model
+        field :client_id, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/voltaria/accounts/types/list_client_accounts_request.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Accounts
+    module Types
+      class ListClientAccountsRequest < Internal::Types::Model
+        field :client_id, -> { String }, optional: false, nullable: false
+        field :page, -> { Integer }, optional: true, nullable: false
+        field :page_size, -> { Integer }, optional: true, nullable: false
+        field :order_by, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/voltaria/accounts/types/partner_client_account_create_request.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Accounts
+    module Types
+      class PartnerClientAccountCreateRequest < Internal::Types::Model
+        field :client_id, -> { String }, optional: false, nullable: false
+        field :account_holder_name, -> { String }, optional: false, nullable: false
+        field :label, -> { String }, optional: true, nullable: false
+        field :account_holder_type, -> { Voltaria::Types::AccountHolderTypeEnum }, optional: false, nullable: false
+        field :currency, -> { Voltaria::Types::CurrencyEnum }, optional: false, nullable: false
+        field :sort_code, -> { String }, optional: true, nullable: false
+        field :account_number, -> { String }, optional: true, nullable: false
+        field :iban, -> { String }, optional: true, nullable: false
+        field :bic, -> { String }, optional: true, nullable: false
+        field :routing_number, -> { String }, optional: true, nullable: false
+        field :account_type, -> { String }, optional: true, nullable: false
+        field :address, -> { Voltaria::Types::AccountAddress }, optional: true, nullable: false
+        field :status, -> { Voltaria::Accounts::Types::PartnerClientAccountCreateRequestStatus }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/voltaria/accounts/types/partner_client_account_create_request_status.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Accounts
+    module Types
+      module PartnerClientAccountCreateRequestStatus
+        extend Voltaria::Internal::Types::Enum
+
+        ACTIVE = "active"
+        PASSIVE = "passive"
+      end
+    end
+  end
+end

data/lib/voltaria/client.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Voltaria
+  class Client
+    # @param base_url [String, nil]
+    # @param token [String]
+    #
+    # @return [void]
+    def initialize(token:, base_url: nil)
+      @raw_client = Voltaria::Internal::Http::RawClient.new(
+        base_url: base_url || Voltaria::Environment::SANDBOX,
+        headers: {
+          "X-Fern-Language" => "Ruby",
+          Authorization: "Bearer #{token}"
+        }
+      )
+    end
+
+    # @return [Voltaria::Clients::Client]
+    def clients
+      @clients ||= Voltaria::Clients::Client.new(client: @raw_client)
+    end
+
+    # @return [Voltaria::Sandbox::Client]
+    def sandbox
+      @sandbox ||= Voltaria::Sandbox::Client.new(client: @raw_client)
+    end
+
+    # @return [Voltaria::Accounts::Client]
+    def accounts
+      @accounts ||= Voltaria::Accounts::Client.new(client: @raw_client)
+    end
+
+    # @return [Voltaria::Documents::Client]
+    def documents
+      @documents ||= Voltaria::Documents::Client.new(client: @raw_client)
+    end
+
+    # @return [Voltaria::Investors::Client]
+    def investors
+      @investors ||= Voltaria::Investors::Client.new(client: @raw_client)
+    end
+
+    # @return [Voltaria::Installments::Client]
+    def installments
+      @installments ||= Voltaria::Installments::Client.new(client: @raw_client)
+    end
+
+    # @return [Voltaria::Loans::Client]
+    def loans
+      @loans ||= Voltaria::Loans::Client.new(client: @raw_client)
+    end
+
+    # @return [Voltaria::Partners::Client]
+    def partners
+      @partners ||= Voltaria::Partners::Client.new(client: @raw_client)
+    end
+
+    # @return [Voltaria::Webhooks::Client]
+    def webhooks
+      @webhooks ||= Voltaria::Webhooks::Client.new(client: @raw_client)
+    end
+
+    # @return [Voltaria::Repayments::Client]
+    def repayments
+      @repayments ||= Voltaria::Repayments::Client.new(client: @raw_client)
+    end
+
+    # @return [Voltaria::Drawdowns::Client]
+    def drawdowns
+      @drawdowns ||= Voltaria::Drawdowns::Client.new(client: @raw_client)
+    end
+  end
+end