voltaria_sdk 2.34.5

data/lib/voltaria/internal/types/union.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Internal
+    module Types
+      # Define a union between two types
+      module Union
+        include Voltaria::Internal::Types::Type
+
+        def members
+          @members ||= []
+        end
+
+        # Add a member to this union
+        #
+        # @param type [Object]
+        # @option key [Symbol, String]
+        # @return [void]
+        def member(type, key: nil)
+          members.push([key, Utils.wrap_type(type)])
+          self
+        end
+
+        def type_member?(type)
+          members.any? { |_key, type_fn| type == type_fn.call }
+        end
+
+        # Set the discriminant for this union
+        #
+        # @param key [Symbol, String]
+        # @return [void]
+        def discriminant(key)
+          @discriminant = key
+        end
+
+        # @api private
+        private def discriminated?
+          !@discriminant.nil?
+        end
+
+        # Check if value matches a type, handling type wrapper instances
+        # (Internal::Types::Hash and Internal::Types::Array instances)
+        #
+        # @param value [Object]
+        # @param member_type [Object]
+        # @return [Boolean]
+        private def type_matches?(value, member_type)
+          case member_type
+          when Voltaria::Internal::Types::Hash
+            value.is_a?(::Hash)
+          when Voltaria::Internal::Types::Array
+            value.is_a?(::Array)
+          when Class, Module
+            value.is_a?(member_type)
+          else
+            false
+          end
+        end
+
+        # Resolves the type of a value to be one of the members
+        #
+        # @param value [Object]
+        # @return [Class]
+        private def resolve_member(value)
+          if discriminated? && value.is_a?(::Hash)
+            # Try both symbol and string keys for the discriminant
+            discriminant_value = value.fetch(@discriminant, nil) || value.fetch(@discriminant.to_s, nil)
+
+            return if discriminant_value.nil?
+
+            # Convert to string for consistent comparison
+            discriminant_str = discriminant_value.to_s
+
+            # First try exact match
+            members_hash = members.to_h
+            result = members_hash[discriminant_str]&.call
+            return result if result
+
+            # Try case-insensitive match as fallback
+            discriminant_lower = discriminant_str.downcase
+            matching_keys = members_hash.keys.select { |k| k.to_s.downcase == discriminant_lower }
+
+            # Only use case-insensitive match if exactly one key matches (avoid ambiguity)
+            return members_hash[matching_keys.first]&.call if matching_keys.length == 1
+
+            nil
+          else
+            # First try exact type matching
+            result = members.find do |_key, mem|
+              member_type = Utils.unwrap_type(mem)
+              type_matches?(value, member_type)
+            end&.last&.call
+
+            return result if result
+
+            # For Hash values, try to coerce into Model member types
+            if value.is_a?(::Hash)
+              members.find do |_key, mem|
+                member_type = Utils.unwrap_type(mem)
+                # Check if member_type is a Model class
+                next unless member_type.is_a?(Class) && member_type <= Model
+
+                # Try to coerce the hash into this model type with strict mode
+                begin
+                  candidate = Utils.coerce(member_type, value, strict: true)
+
+                  # Validate that all required (non-optional) fields are present
+                  # This ensures undiscriminated unions properly distinguish between member types
+                  member_type.fields.each do |field_name, field|
+                    raise Errors::TypeError, "Required field `#{field_name}` missing for union member #{member_type.name}" if candidate.instance_variable_get(:@data)[field_name].nil? && !field.optional
+                  end
+
+                  true
+                rescue Errors::TypeError
+                  false
+                end
+              end&.last&.call
+            end
+          end
+        end
+
+        def coerce(value, strict: strict?)
+          type = resolve_member(value)
+
+          unless type
+            return value unless strict
+
+            if discriminated?
+              raise Errors::TypeError,
+                    "value of type `#{value.class}` not member of union #{self}"
+            end
+
+            raise Errors::TypeError, "could not resolve to member of union #{self}"
+          end
+
+          coerced = Utils.coerce(type, value, strict: strict)
+
+          # For discriminated unions, store the discriminant info on the coerced instance
+          # so it can be injected back during serialization (to_h)
+          if discriminated? && value.is_a?(::Hash) && coerced.is_a?(Model)
+            discriminant_value = value.fetch(@discriminant, nil) || value.fetch(@discriminant.to_s, nil)
+            if discriminant_value
+              coerced.instance_variable_set(:@_fern_union_discriminant_key, @discriminant.to_s)
+              coerced.instance_variable_set(:@_fern_union_discriminant_value, discriminant_value)
+            end
+          end
+
+          coerced
+        end
+
+        # Parse JSON string and coerce to the correct union member type
+        #
+        # @param str [String] JSON string to parse
+        # @return [Object] Coerced value matching a union member
+        def load(str)
+          coerce(::JSON.parse(str, symbolize_names: true))
+        end
+      end
+    end
+  end
+end

data/lib/voltaria/internal/types/unknown.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Internal
+    module Types
+      module Unknown
+        include Voltaria::Internal::Types::Type
+
+        def coerce(value)
+          value
+        end
+      end
+    end
+  end
+end

data/lib/voltaria/internal/types/utils.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Internal
+    module Types
+      # Utilities for dealing with and checking types
+      module Utils
+        # Wraps a type into a type function
+        #
+        # @param type [Proc, Object]
+        # @return [Proc]
+        def self.wrap_type(type)
+          case type
+          when Proc
+            type
+          else
+            -> { type }
+          end
+        end
+
+        # Resolves a type or type function into a type
+        #
+        # @param type [Proc, Object]
+        # @return [Object]
+        def self.unwrap_type(type)
+          type.is_a?(Proc) ? type.call : type
+        end
+
+        def self.coerce(target, value, strict: false)
+          type = unwrap_type(target)
+
+          case type
+          in Array
+            case value
+            when ::Array
+              return type.coerce(value, strict: strict)
+            when Set, ::Hash
+              return coerce(type, value.to_a)
+            end
+          in Hash
+            case value
+            when ::Hash
+              return type.coerce(value, strict: strict)
+            when ::Array
+              return coerce(type, value.to_h)
+            end
+          in ->(t) { t <= NilClass }
+            return nil
+          in ->(t) { t <= String }
+            case value
+            when String, Symbol, Numeric, TrueClass, FalseClass
+              return value.to_s
+            end
+          in ->(t) { t <= Symbol }
+            case value
+            when Symbol, String
+              return value.to_sym
+            end
+          in ->(t) { t <= Integer }
+            case value
+            when Numeric, String, Time
+              return value.to_i
+            end
+          in ->(t) { t <= Float }
+            case value
+            when Numeric, Time, String
+              return value.to_f
+            end
+          in ->(t) { t <= Model }
+            case value
+            when type
+              return value
+            when ::Hash
+              return type.coerce(value, strict: strict)
+            end
+          in Module
+            case type
+            in ->(t) {
+                 t.singleton_class.include?(Enum) ||
+                   t.singleton_class.include?(Union)
+               }
+              return type.coerce(value, strict: strict)
+            else
+              value # rubocop:disable Lint/Void
+            end
+          else
+            value # rubocop:disable Lint/Void
+          end
+
+          raise Errors::TypeError, "cannot coerce value of type `#{value.class}` to `#{target}`" if strict
+
+          value
+        end
+
+        def self.symbolize_keys(hash)
+          hash.transform_keys(&:to_sym)
+        end
+
+        # Converts camelCase keys to snake_case symbols
+        # This allows SDK methods to accept both snake_case and camelCase keys
+        # e.g., { refundMethod: ... } becomes { refund_method: ... }
+        #
+        # @param hash [Hash]
+        # @return [Hash]
+        def self.normalize_keys(hash)
+          hash.transform_keys do |key|
+            key_str = key.to_s
+            # Convert camelCase to snake_case
+            snake_case = key_str.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+            snake_case.to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/voltaria/investors/client.rb

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Investors
+    class Client
+      # @param client [Voltaria::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Retrieve all clients with at least one loan funded by this investor.
+      #
+      # @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 [Integer, nil] :page
+      # @option params [Integer, nil] :page_size
+      # @option params [String, nil] :order_by
+      # @option params [String, nil] :q
+      #
+      # @return [Voltaria::Types::PaginatedResponseClientInvestorResponse]
+      def investor_list_clients(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[page page_size order_by q]
+        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)
+        query_params["q"] = params[:q] if params.key?(:q)
+        params.except(*query_param_names)
+
+        request = Voltaria::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v2/investors/clients",
+          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::PaginatedResponseClientInvestorResponse.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 client that has a loan funded by this investor.
+      #
+      # @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 [Voltaria::Types::ClientInvestorResponse]
+      def investor_get_client(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/investors/clients/#{URI.encode_uri_component(params[:client_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::ClientInvestorResponse.load(response.body)
+        else
+          error_class = Voltaria::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Retrieve all loans funded by the current investor.
+      #
+      # @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 [Integer, nil] :page
+      # @option params [Integer, nil] :page_size
+      # @option params [String, nil] :client_id
+      # @option params [String, nil] :order_by
+      # @option params [String, nil] :q
+      #
+      # @return [Voltaria::Types::PaginatedResponseLoanInvestorResponse]
+      def investor_list_loans(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[page page_size client_id order_by q]
+        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["client_id"] = params[:client_id] if params.key?(:client_id)
+        query_params["order_by"] = params[:order_by] if params.key?(:order_by)
+        query_params["q"] = params[:q] if params.key?(:q)
+        params.except(*query_param_names)
+
+        request = Voltaria::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v2/investors/loans",
+          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::PaginatedResponseLoanInvestorResponse.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 loan funded by the current investor, with its installments.
+      #
+      # @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] :loan_id
+      #
+      # @return [Voltaria::Types::LoanResponseWithInstallments]
+      def investor_get_loan(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/investors/loans/#{URI.encode_uri_component(params[:loan_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::LoanResponseWithInstallments.load(response.body)
+        else
+          error_class = Voltaria::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Retrieve all installments for loans funded by the current investor.
+      #
+      # @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 [Integer, nil] :page
+      # @option params [Integer, nil] :page_size
+      # @option params [String, nil] :client_id
+      # @option params [String, nil] :loan_id
+      # @option params [String, nil] :order_by
+      # @option params [String, nil] :q
+      #
+      # @return [Voltaria::Types::PaginatedResponseInstallmentResponseWithClientInfo]
+      def investor_list_installments(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[page page_size client_id loan_id order_by q]
+        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["client_id"] = params[:client_id] if params.key?(:client_id)
+        query_params["loan_id"] = params[:loan_id] if params.key?(:loan_id)
+        query_params["order_by"] = params[:order_by] if params.key?(:order_by)
+        query_params["q"] = params[:q] if params.key?(:q)
+        params.except(*query_param_names)
+
+        request = Voltaria::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v2/investors/installments",
+          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::PaginatedResponseInstallmentResponseWithClientInfo.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 installment for a loan funded by the current investor.
+      #
+      # @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] :installment_id
+      #
+      # @return [Voltaria::Types::InstallmentResponse]
+      def investor_get_installment(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/investors/installments/#{URI.encode_uri_component(params[:installment_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::InstallmentResponse.load(response.body)
+        else
+          error_class = Voltaria::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Retrieve all repayment logs for loans funded by the current investor.
+      #
+      # @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, nil] :client_id
+      # @option params [String, nil] :loan_id
+      # @option params [String, nil] :installment_id
+      # @option params [Integer, nil] :page
+      # @option params [Integer, nil] :page_size
+      # @option params [String, nil] :order_by
+      # @option params [String, nil] :q
+      #
+      # @return [Voltaria::Types::PaginatedResponseRepaymentResponseWithClientInfo]
+      def investor_list_repayments(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[client_id loan_id installment_id page page_size order_by q]
+        query_params = {}
+        query_params["client_id"] = params[:client_id] if params.key?(:client_id)
+        query_params["loan_id"] = params[:loan_id] if params.key?(:loan_id)
+        query_params["installment_id"] = params[:installment_id] if params.key?(:installment_id)
+        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)
+        query_params["q"] = params[:q] if params.key?(:q)
+        params.except(*query_param_names)
+
+        request = Voltaria::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v2/investors/repayments",
+          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::PaginatedResponseRepaymentResponseWithClientInfo.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/investors/types/investor_get_client_request.rb

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

data/lib/voltaria/investors/types/investor_get_installment_request.rb

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

data/lib/voltaria/investors/types/investor_get_loan_request.rb

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

data/lib/voltaria/investors/types/investor_list_clients_request.rb

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

data/lib/voltaria/investors/types/investor_list_installments_request.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Investors
+    module Types
+      class InvestorListInstallmentsRequest < Internal::Types::Model
+        field :page, -> { Integer }, optional: true, nullable: false
+        field :page_size, -> { Integer }, optional: true, nullable: false
+        field :client_id, -> { String }, optional: true, nullable: false
+        field :loan_id, -> { String }, optional: true, nullable: false
+        field :order_by, -> { String }, optional: true, nullable: false
+        field :q, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/voltaria/investors/types/investor_list_loans_request.rb

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