voltaria_sdk 2.34.5

data/lib/voltaria/clients/client.rb

@@ -0,0 +1,557 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Clients
+    class Client
+      # @param client [Voltaria::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Retrieve a list of all clients associated with your partner account.
+      #
+      # @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::PaginatedResponseClientResponse]
+      def 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/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::PaginatedResponseClientResponse.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 new client under your partner account. The client will remain in a pending state until reviewed by
+      # Winyield.
+      #
+      # @param request_options [Hash]
+      # @param params [Voltaria::Clients::Types::ClientCreatePayload]
+      # @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
+      #
+      # @return [Voltaria::Types::ClientResponse]
+      def create_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: "POST",
+          path: "v2/clients",
+          body: Voltaria::Clients::Types::ClientCreatePayload.new(params).to_h,
+          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::ClientResponse.load(response.body)
+        else
+          error_class = Voltaria::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Upload supplementary client information, such as bank account balance, accounting figures, or other relevant
+      # details.
+      #
+      # @param request_options [Hash]
+      # @param params [Voltaria::Clients::Types::ClientDataCreatePayload]
+      # @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
+      #
+      # @return [Voltaria::Types::ClientDataResponse]
+      def create_client_data(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        request = Voltaria::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v2/clients/data",
+          body: Voltaria::Clients::Types::ClientDataCreatePayload.new(params).to_h,
+          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::ClientDataResponse.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 list of all limit requests associated with your partner account.
+      #
+      # @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 [Integer, nil] :page
+      # @option params [Integer, nil] :page_size
+      # @option params [String, nil] :order_by
+      # @option params [String, nil] :q
+      #
+      # @return [Voltaria::Types::PaginatedResponseLimitRequestResponse]
+      def list_limit_requests(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[client_id page page_size order_by q]
+        query_params = {}
+        query_params["client_id"] = params[:client_id] if params.key?(:client_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/clients/limit-requests",
+          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::PaginatedResponseLimitRequestResponse.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 limit review request for a client. The request will remain in a pending state until reviewed by
+      # Winyield.
+      #
+      # @param request_options [Hash]
+      # @param params [Voltaria::Clients::Types::LimitRequestCreatePayload]
+      # @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
+      #
+      # @return [Voltaria::Types::LimitRequestResponse]
+      def create_limit_request(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        request = Voltaria::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v2/clients/limit-requests",
+          body: Voltaria::Clients::Types::LimitRequestCreatePayload.new(params).to_h,
+          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::LimitRequestResponse.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 limit request by its ID.
+      #
+      # @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] :request_id
+      #
+      # @return [Voltaria::Types::LimitRequestResponse]
+      def get_limit_request(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/limit-requests/#{URI.encode_uri_component(params[:request_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::LimitRequestResponse.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 clients that have self-registered via the portal and are awaiting partner approval.
+      #
+      # @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
+      #
+      # @return [Voltaria::Types::PaginatedResponseClientResponse]
+      def list_onboarding_clients(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[page page_size]
+        query_params = {}
+        query_params["page"] = params[:page] if params.key?(:page)
+        query_params["page_size"] = params[:page_size] if params.key?(:page_size)
+        params.except(*query_param_names)
+
+        request = Voltaria::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v2/clients/onboarding",
+          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::PaginatedResponseClientResponse.load(response.body)
+        else
+          error_class = Voltaria::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Accept a self-onboarded client. The client status moves to 'pending' and the owner's portal account is activated
+      # so they can begin submitting documents.
+      #
+      # @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::ClientResponse]
+      def approve_onboarding(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        request = Voltaria::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v2/clients/onboarding/#{URI.encode_uri_component(params[:client_id].to_s)}/approve",
+          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::ClientResponse.load(response.body)
+        else
+          error_class = Voltaria::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Reject a self-onboarded client. The client record is kept with 'rejected' status for audit history and is not
+      # deleted.
+      #
+      # @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::ClientResponse]
+      def reject_onboarding(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        request = Voltaria::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v2/clients/onboarding/#{URI.encode_uri_component(params[:client_id].to_s)}/reject",
+          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::ClientResponse.load(response.body)
+        else
+          error_class = Voltaria::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Invite a new user to a client's portal account. The invited user will receive an email with a one-time link to
+      # set their password. Partner can assign any role: 'owner', 'admin', or 'viewer'.
+      #
+      # @param request_options [Hash]
+      # @param params [Voltaria::Clients::Types::ClientUserInviteRequest]
+      # @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::ClientUserResponse]
+      def add_client_portal_user(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        request_data = Voltaria::Clients::Types::ClientUserInviteRequest.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)}/users",
+          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::ClientUserResponse.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 waivers associated with a specific client.
+      #
+      # @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
+      # @option params [String, nil] :q
+      #
+      # @return [Voltaria::Types::PaginatedResponseWaiverResponse]
+      def list_client_waivers(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 = 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)}/waivers",
+          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::PaginatedResponseWaiverResponse.load(response.body)
+        else
+          error_class = Voltaria::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Retrieve detailed information for a specific client using their client ID.
+      #
+      # @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::ClientResponse]
+      def get_client_by_id(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)}",
+          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::ClientResponse.load(response.body)
+        else
+          error_class = Voltaria::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Delete a client by ID. Only clients with 'pending' status can be deleted. All client's loans must also be in
+      # 'pending' status.
+      #
+      # @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, Object], nil]
+      def delete_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: "DELETE",
+          path: "v2/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
+        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 the checklist summaries for one of your clients, including the AI description and item completion
+      # counts.
+      #
+      # @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
+      #
+      # @return [Voltaria::Types::PaginatedResponseChecklistSummaryPartnerResponse]
+      def list_client_checklist_summaries(request_options: {}, **params)
+        params = Voltaria::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[page page_size]
+        query_params = {}
+        query_params["page"] = params[:page] if params.key?(:page)
+        query_params["page_size"] = params[:page_size] if params.key?(:page_size)
+        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)}/checklist-summaries",
+          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::PaginatedResponseChecklistSummaryPartnerResponse.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/clients/types/approve_onboarding_request.rb

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

data/lib/voltaria/clients/types/client_create_payload.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Clients
+    module Types
+      class ClientCreatePayload < Internal::Types::Model
+        field :correlation_id, -> { String }, optional: true, nullable: false
+        field :name, -> { String }, optional: false, nullable: false
+        field :type, -> { Voltaria::Types::ClientTypeEnum }, optional: true, nullable: false
+        field :jurisdiction, -> { Voltaria::Types::JurisdictionEnum }, optional: false, nullable: false
+        field :company_number, -> { String }, optional: true, nullable: false
+        field :data, -> { Internal::Types::Hash[String, Object] }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/voltaria/clients/types/client_data_create_payload.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Clients
+    module Types
+      class ClientDataCreatePayload < Internal::Types::Model
+        field :client_id, -> { String }, optional: false, nullable: false
+        field :data, -> { Internal::Types::Hash[String, Object] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/voltaria/clients/types/client_user_invite_request.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Clients
+    module Types
+      class ClientUserInviteRequest < Internal::Types::Model
+        field :client_id, -> { String }, optional: false, nullable: false
+        field :first_name, -> { String }, optional: false, nullable: false
+        field :last_name, -> { String }, optional: false, nullable: false
+        field :email, -> { String }, optional: false, nullable: false
+        field :phone, -> { String }, optional: true, nullable: false
+        field :role_type, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/voltaria/clients/types/delete_client_request.rb

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

data/lib/voltaria/clients/types/get_client_by_id_request.rb

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

data/lib/voltaria/clients/types/get_limit_request_request.rb

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

data/lib/voltaria/clients/types/limit_request_create_payload.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Clients
+    module Types
+      class LimitRequestCreatePayload < Internal::Types::Model
+        field :client_id, -> { String }, optional: false, nullable: false
+        field :requested_limit, -> { Voltaria::Clients::Types::LimitRequestCreatePayloadRequestedLimit }, optional: false, nullable: false
+        field :reason, -> { String }, optional: false, nullable: false
+        field :waiver_request, -> { Internal::Types::Boolean }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/voltaria/clients/types/limit_request_create_payload_requested_limit.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Voltaria
+  module Clients
+    module Types
+      # The requested credit limit amount
+      class LimitRequestCreatePayloadRequestedLimit < Internal::Types::Model
+        extend Voltaria::Internal::Types::Union
+
+        member -> { Integer }
+        member -> { String }
+      end
+    end
+  end
+end