lago-ruby-client 1.43.0 → 1.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1cd4e9ed7d1b0f3eac5940fb37ea3b7b2616ceda00c5e3e4e42e0e80b0d0b3ba
-  data.tar.gz: 761ed874e1fb31e466ae0a5309132853ded262940f0504fcb6dc827a3af05c87
+  metadata.gz: 7e05c7adf2d8d5d2dd6d5e8e9263908f415013356761245b1f22878b0fd0c7a2
+  data.tar.gz: d89d43c70f055b2363ef08cb063d5910f1335257846292400b4e1f88e0ab882f
 SHA512:
-  metadata.gz: 21a3cb1cd0b107edb3ac23e4a08738dd4c9f6ae96a8dee6ed07267a72b48cafdeb5d580afc631519961974c761dc44da151358ad9e3951f88c8a8f42e57f7c65
-  data.tar.gz: 87d47fc5d9f9039ca63975f697b30f1300314bc2448967e180944c1e68c0fc8576f8ddef53055e8c092cd0f28581fad43640ffeac638f3dcc3c6ca2f79f8d13d
+  metadata.gz: fdab377ffb956c42aec999bd2ca63fa4ceeb895f656497175b955b93d2d2adfa60e2b088ff3deedbf039fef3ca01fb4ecb2d98aa2afb27d74bcf9f9710737ace
+  data.tar.gz: 0e52ca90f164179ac5e28c90e48a37ef1d0f57ffe47f35ba105df18857ed4035a4969fa9aff93de0291143bfd0bb5e2d23efb052b5db7e17cebd3502cbf46f9a

data/lib/lago/api/client.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'lago/api/resources/base'
+require 'lago/api/resources/nested'
 require 'lago/api/resources/activity_log'
 require 'lago/api/resources/add_on'
 require 'lago/api/resources/api_log'
@@ -19,6 +20,10 @@ require 'lago/api/resources/customers/payment_method'
 require 'lago/api/resources/customers/payment_request'
 require 'lago/api/resources/customers/subscription'
 require 'lago/api/resources/customers/wallet'
+require 'lago/api/resources/customers/wallets'
+require 'lago/api/resources/customers/wallets/base'
+require 'lago/api/resources/customers/wallets/alert'
+require 'lago/api/resources/customers/wallets/metadata'
 require 'lago/api/resources/event'
 require 'lago/api/resources/feature'
 require 'lago/api/resources/fee'

data/lib/lago/api/resources/customer.rb

@@ -14,9 +14,20 @@ module Lago
           'customer'
         end
 
-        def current_usage(external_customer_id, external_subscription_id, apply_taxes: nil)
+        def wallets
+          Customers::Wallets.new(client)
+        end
+
+        def current_usage( # rubocop:disable Metrics/ParameterLists
+          external_customer_id, external_subscription_id, apply_taxes: nil,
+          filter_by_charge_id: nil, filter_by_charge_code: nil, filter_by_group: nil, full_usage: nil
+        )
           query_params = { external_subscription_id: external_subscription_id }
           query_params[:apply_taxes] = apply_taxes unless apply_taxes.nil?
+          query_params[:filter_by_charge_id] = filter_by_charge_id unless filter_by_charge_id.nil?
+          query_params[:filter_by_charge_code] = filter_by_charge_code unless filter_by_charge_code.nil?
+          filter_by_group&.each { |k, v| query_params[:"filter_by_group[#{k}]"] = v }
+          query_params[:full_usage] = full_usage unless full_usage.nil?
           query_string = URI.encode_www_form(query_params)
 
           uri = URI("#{client.base_api_url}#{api_resource}/#{external_customer_id}/current_usage?#{query_string}")

data/lib/lago/api/resources/customers/wallets/alert.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Lago
+  module Api
+    module Resources
+      module Customers
+        class Wallets < Lago::Api::Resources::Nested
+          class Alert < Base
+            def create_batch(customer_id, wallet_code, params)
+              response = connection.post(
+                whitelist_create_batch_params(params),
+                api_resource(customer_id, wallet_code),
+              )
+
+              JSON.parse(response.to_json, object_class: OpenStruct).alerts
+            end
+
+            def destroy_all(customer_id, wallet_code)
+              connection.destroy(
+                api_resource(customer_id, wallet_code),
+                identifier: nil,
+              )
+
+              nil
+            end
+
+            private
+
+            def api_resource(customer_id, wallet_code)
+              "#{base_api_resource(customer_id, wallet_code)}/alerts"
+            end
+
+            def root_name
+              'alert'
+            end
+
+            def whitelist_create_params(params)
+              { alert: create_alert_params(params) }
+            end
+
+            def whitelist_update_params(params)
+              {
+                alert: {
+                  name: params[:name],
+                  code: params[:code],
+                  thresholds: params[:thresholds],
+                }.compact,
+              }
+            end
+
+            def whitelist_create_batch_params(params)
+              params = params.is_a?(Hash) ? params[:alerts] : params
+
+              { alerts: (params || []).map { |alert| create_alert_params(alert) } }
+            end
+
+            def create_alert_params(params)
+              {
+                alert_type: params[:alert_type],
+                name: params[:name],
+                code: params[:code],
+                thresholds: params[:thresholds],
+              }.compact
+            end
+
+            def whitelist_thresholds(params)
+              (params || []).map do |p|
+                (p || {}).slice(:code, :value, :recurring)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lago/api/resources/customers/wallets/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lago
+  module Api
+    module Resources
+      module Customers
+        class Wallets < Lago::Api::Resources::Nested
+          class Base < Lago::Api::Resources::Nested
+            def base_api_resource(customer_id, wallet_code)
+              URI.join(client.base_api_url, "customers/#{customer_id}/wallets/#{wallet_code}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lago/api/resources/customers/wallets/metadata.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Lago
+  module Api
+    module Resources
+      module Customers
+        class Wallets < Lago::Api::Resources::Nested
+          class Metadata < Base
+            def api_resource(customer_id, wallet_code)
+              "#{base_api_resource(customer_id, wallet_code)}/metadata"
+            end
+
+            def replace(customer_id, wallet_code, metadata)
+              path = api_resource(customer_id, wallet_code)
+              payload = { metadata: whitelist_params(metadata) }
+              response = connection.post(payload, path)
+
+              response['metadata']
+            end
+
+            def merge(customer_id, wallet_code, metadata)
+              path = api_resource(customer_id, wallet_code)
+              payload = { metadata: whitelist_params(metadata) }
+              response = connection.patch(path, identifier: nil, body: payload)
+
+              response['metadata']
+            end
+
+            def delete_all(customer_id, wallet_code)
+              path = api_resource(customer_id, wallet_code)
+              response = connection.destroy(path, identifier: nil)
+
+              response['metadata']
+            end
+
+            def delete_key(customer_id, wallet_code, key)
+              path = api_resource(customer_id, wallet_code)
+              response = connection.destroy(path, identifier: key)
+
+              response['metadata']
+            end
+
+            def whitelist_params(params)
+              WhitelistParams.new.metadata(params)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lago/api/resources/customers/wallets/whitelist_params.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Lago
+  module Api
+    module Resources
+      module Customers
+        class Wallets < Lago::Api::Resources::Nested
+          class WhitelistParams
+            def wallet(params)
+              result_hash = params.compact.slice(
+                :external_customer_id,
+                :rate_amount,
+                :name,
+                :code,
+                :priority,
+                :paid_credits,
+                :granted_credits,
+                :currency,
+                :expiration_at,
+                :transaction_metadata,
+                :invoice_requires_successful_payment,
+                :ignore_paid_top_up_limits_on_creation,
+                :transaction_name,
+                :paid_top_up_min_amount_cents,
+                :paid_top_up_max_amount_cents,
+              )
+
+              recurring_rules = recurring_rules_params(params[:recurring_transaction_rules])
+              result_hash[:recurring_transaction_rules] = recurring_rules if recurring_rules.any?
+
+              applies_to = applies_to_params(params[:applies_to])
+              result_hash[:applies_to] = applies_to if applies_to.any?
+
+              metadata = metadata(params[:metadata])
+              result_hash[:metadata] = metadata if metadata
+
+              payment_method = payment_method_params(params[:payment_method])
+              result_hash[:payment_method] = payment_method if payment_method.any?
+
+              invoice_custom_section = invoice_custom_section_params(params[:invoice_custom_section])
+              result_hash[:invoice_custom_section] = invoice_custom_section if invoice_custom_section
+
+              { 'wallet' => result_hash }
+            end
+
+            def metadata(params)
+              return unless params
+
+              params.to_h.transform_keys(&:to_s).transform_values(&:to_s)
+            end
+
+            private
+
+            def recurring_rules_params(rules)
+              processed_rules = []
+
+              (rules || []).each do |r|
+                result = (r || {}).slice(
+                  :lago_id,
+                  :paid_credits,
+                  :granted_credits,
+                  :threshold_credits,
+                  :invoice_requires_successful_payment,
+                  :trigger,
+                  :interval,
+                  :method,
+                  :started_at,
+                  :expiration_at,
+                  :target_ongoing_balance,
+                  :transaction_metadata,
+                  :transaction_name,
+                  :ignore_paid_top_up_limits,
+                )
+
+                payment_method = payment_method_params(r[:payment_method])
+                result[:payment_method] = payment_method if payment_method.any?
+
+                invoice_custom_section = invoice_custom_section_params(r[:invoice_custom_section])
+                result[:invoice_custom_section] = invoice_custom_section if invoice_custom_section
+
+                processed_rules << result unless result.empty?
+              end
+
+              processed_rules
+            end
+
+            def applies_to_params(applies_to)
+              (applies_to || {}).slice(:fee_types, :billable_metric_codes)
+            end
+
+            def payment_method_params(payment_method)
+              (payment_method || {}).slice(:payment_method_type, :payment_method_id)
+            end
+
+            def invoice_custom_section_params(invoice_custom_section)
+              invoice_custom_section&.slice(:skip_invoice_custom_sections, :invoice_custom_section_codes)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lago/api/resources/customers/wallets.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'lago/api/resources/nested'
+require 'lago/api/resources/customers/wallets/whitelist_params'
+
+module Lago
+  module Api
+    module Resources
+      module Customers
+        class Wallets < Lago::Api::Resources::Nested
+          def api_resource(customer_id)
+            "#{client.base_api_url}customers/#{customer_id}/wallets"
+          end
+
+          def root_name
+            'wallet'
+          end
+
+          def whitelist_params(params)
+            Wallets::WhitelistParams.new.wallet(params)
+          end
+
+          def alerts
+            Wallets::Alert.new(client)
+          end
+
+          def metadata
+            Wallets::Metadata.new(client)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lago/api/resources/invoice.rb

@@ -132,7 +132,10 @@ module Lago
           result[:fees] = fees unless fees.empty?
 
           payment_method_params = whitelist_payment_method_params(params[:payment_method])
-          result[:payment_method] = payment_method_params if payment_method_params.present?
+          result[:payment_method] = payment_method_params if payment_method_params
+
+          invoice_custom_section = whitelist_invoice_custom_section_params(params[:invoice_custom_section])
+          result[:invoice_custom_section] = invoice_custom_section if invoice_custom_section
 
           { root_name => result }
         end
@@ -173,6 +176,10 @@ module Lago
         def whitelist_payment_method_params(payment_method_param)
           payment_method_param&.slice(:payment_method_type, :payment_method_id)
         end
+
+        def whitelist_invoice_custom_section_params(invoice_custom_section_param)
+          invoice_custom_section_param&.slice(:skip_invoice_custom_sections, :invoice_custom_section_codes)
+        end
       end
     end
   end

data/lib/lago/api/resources/nested.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'lago/api/resources/base'
+
+module Lago
+  module Api
+    module Resources
+      class Nested < Base
+        def initialize(client)
+          super(client)
+          @connection = Lago::Api::Connection.new(client.api_key, client.base_api_url)
+        end
+
+        def create(*parent_ids, params)
+          path = api_resource(*parent_ids)
+          payload = whitelist_create_params(params)
+          response = connection.post(payload, path)[root_name]
+
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        def get(*parent_ids, resource_id)
+          path = api_resource(*parent_ids)
+          response = connection.get(path, identifier: resource_id)[root_name]
+
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        def update(*parent_ids, resource_id, params)
+          path = api_resource(*parent_ids)
+          payload = whitelist_update_params(params)
+          response = connection.put(path, identifier: resource_id, body: payload)[root_name]
+
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        def destroy(*parent_ids, resource_id)
+          path = api_resource(*parent_ids)
+          response = connection.destroy(path, identifier: resource_id)[root_name]
+
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        def get_all(*parent_ids, **options)
+          path = api_resource(*parent_ids)
+          response = connection.get_all(options, path)
+
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        private
+
+        attr_reader :connection
+
+        def whitelist_update_params(params)
+          whitelist_params(params)
+        end
+
+        def whitelist_create_params(params)
+          whitelist_params(params)
+        end
+      end
+    end
+  end
+end

data/lib/lago/api/resources/subscription.rb

@@ -35,75 +35,89 @@ module Lago
           JSON.parse(response.to_json, object_class: OpenStruct).lifetime_usage
         end
 
-        def get_entitlements(external_subscription_id)
-          response = connection.get(entitlements_uri(external_subscription_id), identifier: nil)
+        def get_entitlements(external_subscription_id, subscription_status: nil)
+          response = connection.get(entitlements_uri(external_subscription_id, subscription_status:), identifier: nil)
           JSON.parse(response.to_json, object_class: OpenStruct).entitlements
         end
 
-        def update_entitlements(external_subscription_id, params)
+        def update_entitlements(external_subscription_id, params, subscription_status: nil)
           response = connection.patch(
-            entitlements_uri(external_subscription_id),
+            entitlements_uri(external_subscription_id, subscription_status:),
             identifier: nil,
             body: whitelist_entitlements_update_params(params),
           )
           JSON.parse(response.to_json, object_class: OpenStruct)
         end
 
-        def delete_entitlement(external_subscription_id, feature_code)
-          response = connection.destroy(entitlements_uri(external_subscription_id, feature_code), identifier: nil)
+        def delete_entitlement(external_subscription_id, feature_code, subscription_status: nil)
+          response = connection.destroy(
+            entitlements_uri(external_subscription_id, feature_code, subscription_status:),
+            identifier: nil,
+          )
           JSON.parse(response.to_json, object_class: OpenStruct)
         end
 
-        def delete_entitlement_privilege(external_subscription_id, entitlement_code, privilege_code)
+        def delete_entitlement_privilege(
+          external_subscription_id, entitlement_code, privilege_code,
+          subscription_status: nil
+        )
           response = connection.destroy(
-            entitlements_uri(external_subscription_id, entitlement_code, "privileges/#{privilege_code}"),
+            entitlements_uri(
+              external_subscription_id,
+              entitlement_code,
+              "privileges/#{privilege_code}",
+              subscription_status:,
+            ),
             identifier: nil,
           )
           JSON.parse(response.to_json, object_class: OpenStruct)
         end
 
-        def get_alert(external_subscription_id, code)
-          response = connection.get(alert_uri(external_subscription_id, code), identifier: nil)
+        def get_alert(external_subscription_id, code, subscription_status: nil)
+          response = connection.get(alert_uri(external_subscription_id, code, subscription_status:), identifier: nil)
           JSON.parse(response.to_json, object_class: OpenStruct).alert
         end
 
-        def update_alert(external_subscription_id, code, params)
+        def update_alert(external_subscription_id, code, params, subscription_status: nil)
           response = connection.put(
-            alert_uri(external_subscription_id, code),
+            alert_uri(external_subscription_id, code, subscription_status:),
             identifier: nil,
             body: whitelist_alert_update_params(params),
           )
           JSON.parse(response.to_json, object_class: OpenStruct).alert
         end
 
-        def delete_alert(external_subscription_id, code)
-          response = connection.destroy(alert_uri(external_subscription_id, code), identifier: nil)
+        def delete_alert(external_subscription_id, code, subscription_status: nil)
+          response = connection.destroy(
+            alert_uri(external_subscription_id, code, subscription_status:),
+            identifier: nil,
+          )
           JSON.parse(response.to_json, object_class: OpenStruct).alert
         end
 
-        def get_alerts(external_subscription_id)
-          response = connection.get(alert_uri(external_subscription_id), identifier: nil)
+        def get_alerts(external_subscription_id, subscription_status: nil)
+          response = connection.get(alert_uri(external_subscription_id, subscription_status:), identifier: nil)
           JSON.parse(response.to_json, object_class: OpenStruct).alerts
         end
 
-        def create_alert(external_subscription_id, params)
+        def create_alert(external_subscription_id, params, subscription_status: nil)
           response = connection.post(
             whitelist_alert_create_params(params),
-            alert_uri(external_subscription_id),
+            alert_uri(external_subscription_id, subscription_status:),
           )
           JSON.parse(response.to_json, object_class: OpenStruct).alert
         end
 
-        def create_alerts(external_subscription_id, params)
+        def create_alerts(external_subscription_id, params, subscription_status: nil)
           response = connection.post(
             whitelist_alert_batch_create_params(params),
-            alert_uri(external_subscription_id),
+            alert_uri(external_subscription_id, subscription_status:),
           )
           JSON.parse(response.to_json, object_class: OpenStruct).alerts
         end
 
-        def delete_alerts(external_subscription_id)
-          connection.destroy(alert_uri(external_subscription_id), identifier: nil)
+        def delete_alerts(external_subscription_id, subscription_status: nil)
+          connection.destroy(alert_uri(external_subscription_id, subscription_status:), identifier: nil)
         end
 
         # Charges
@@ -112,14 +126,14 @@ module Lago
           JSON.parse(response.to_json, object_class: OpenStruct)
         end
 
-        def get_charge(external_id, charge_code)
-          response = connection.get(charges_uri(external_id, charge_code), identifier: nil)
+        def get_charge(external_id, charge_code, subscription_status: nil)
+          response = connection.get(charges_uri(external_id, charge_code, subscription_status:), identifier: nil)
           JSON.parse(response.to_json, object_class: OpenStruct).charge
         end
 
-        def update_charge(external_id, charge_code, params)
+        def update_charge(external_id, charge_code, params, subscription_status: nil)
           response = connection.put(
-            charges_uri(external_id, charge_code),
+            charges_uri(external_id, charge_code, subscription_status:),
             identifier: nil,
             body: whitelist_subscription_charge_params(params),
           )
@@ -132,14 +146,17 @@ module Lago
           JSON.parse(response.to_json, object_class: OpenStruct)
         end
 
-        def get_fixed_charge(external_id, fixed_charge_code)
-          response = connection.get(fixed_charges_uri(external_id, fixed_charge_code), identifier: nil)
+        def get_fixed_charge(external_id, fixed_charge_code, subscription_status: nil)
+          response = connection.get(
+            fixed_charges_uri(external_id, fixed_charge_code, subscription_status:),
+            identifier: nil,
+          )
           JSON.parse(response.to_json, object_class: OpenStruct).fixed_charge
         end
 
-        def update_fixed_charge(external_id, fixed_charge_code, params)
+        def update_fixed_charge(external_id, fixed_charge_code, params, subscription_status: nil)
           response = connection.put(
-            fixed_charges_uri(external_id, fixed_charge_code),
+            fixed_charges_uri(external_id, fixed_charge_code, subscription_status:),
             identifier: nil,
             body: whitelist_subscription_fixed_charge_params(params),
           )
@@ -152,31 +169,34 @@ module Lago
           JSON.parse(response.to_json, object_class: OpenStruct)
         end
 
-        def get_charge_filter(external_id, charge_code, filter_id)
-          response = connection.get(charge_filters_uri(external_id, charge_code, filter_id), identifier: nil)
+        def get_charge_filter(external_id, charge_code, filter_id, subscription_status: nil)
+          response = connection.get(
+            charge_filters_uri(external_id, charge_code, filter_id, subscription_status:),
+            identifier: nil,
+          )
           JSON.parse(response.to_json, object_class: OpenStruct).filter
         end
 
-        def create_charge_filter(external_id, charge_code, params)
+        def create_charge_filter(external_id, charge_code, params, subscription_status: nil)
           response = connection.post(
             whitelist_subscription_charge_filter_params(params),
-            charge_filters_uri(external_id, charge_code),
+            charge_filters_uri(external_id, charge_code, subscription_status:),
           )
           JSON.parse(response.to_json, object_class: OpenStruct).filter
         end
 
-        def update_charge_filter(external_id, charge_code, filter_id, params)
+        def update_charge_filter(external_id, charge_code, filter_id, params, subscription_status: nil)
           response = connection.put(
-            charge_filters_uri(external_id, charge_code, filter_id),
+            charge_filters_uri(external_id, charge_code, filter_id, subscription_status:),
             identifier: nil,
             body: whitelist_subscription_charge_filter_params(params),
           )
           JSON.parse(response.to_json, object_class: OpenStruct).filter
         end
 
-        def destroy_charge_filter(external_id, charge_code, filter_id)
+        def destroy_charge_filter(external_id, charge_code, filter_id, subscription_status: nil)
           response = connection.destroy(
-            charge_filters_uri(external_id, charge_code, filter_id),
+            charge_filters_uri(external_id, charge_code, filter_id, subscription_status:),
             identifier: nil,
           )
           JSON.parse(response.to_json, object_class: OpenStruct).filter
@@ -195,7 +215,10 @@ module Lago
           }.compact
 
           payment_method_params = whitelist_payment_method_params(params[:payment_method])
-          result[:payment_method] = payment_method_params if payment_method_params.present?
+          result[:payment_method] = payment_method_params if payment_method_params
+
+          invoice_custom_section = whitelist_invoice_custom_section_params(params[:invoice_custom_section])
+          result[:invoice_custom_section] = invoice_custom_section if invoice_custom_section
 
           { root_name => result }
         end
@@ -263,33 +286,45 @@ module Lago
           payment_method_param&.slice(:payment_method_type, :payment_method_id)
         end
 
-        def entitlements_uri(external_subscription_id, feature_code = nil, action = nil)
+        def whitelist_invoice_custom_section_params(invoice_custom_section_param)
+          invoice_custom_section_param&.slice(:skip_invoice_custom_sections, :invoice_custom_section_codes)
+        end
+
+        def append_status_query(url, subscription_status)
+          return url if subscription_status.nil?
+
+          separator = url.include?('?') ? '&' : '?'
+          "#{url}#{separator}subscription_status=#{subscription_status}"
+        end
+
+        def entitlements_uri(external_subscription_id, feature_code = nil, action = nil, subscription_status: nil)
           url = "#{client.base_api_url}#{api_resource}/#{external_subscription_id}/entitlements"
           url += "/#{feature_code}" if feature_code
           url += "/#{action}" if action
-          URI(url)
+          URI(append_status_query(url, subscription_status))
         end
 
-        def alert_uri(external_subscription_id, code = nil)
-          URI("#{client.base_api_url}#{api_resource}/#{external_subscription_id}/alerts#{code ? "/#{code}" : ''}")
+        def alert_uri(external_subscription_id, code = nil, subscription_status: nil)
+          url = "#{client.base_api_url}#{api_resource}/#{external_subscription_id}/alerts#{code ? "/#{code}" : ''}"
+          URI(append_status_query(url, subscription_status))
         end
 
-        def charges_uri(external_id, charge_code = nil)
+        def charges_uri(external_id, charge_code = nil, subscription_status: nil)
           url = "#{client.base_api_url}#{api_resource}/#{external_id}/charges"
           url += "/#{charge_code}" if charge_code
-          URI(url)
+          URI(append_status_query(url, subscription_status))
         end
 
-        def fixed_charges_uri(external_id, fixed_charge_code = nil)
+        def fixed_charges_uri(external_id, fixed_charge_code = nil, subscription_status: nil)
           url = "#{client.base_api_url}#{api_resource}/#{external_id}/fixed_charges"
           url += "/#{fixed_charge_code}" if fixed_charge_code
-          URI(url)
+          URI(append_status_query(url, subscription_status))
         end
 
-        def charge_filters_uri(external_id, charge_code, filter_id = nil)
+        def charge_filters_uri(external_id, charge_code, filter_id = nil, subscription_status: nil)
           url = "#{client.base_api_url}#{api_resource}/#{external_id}/charges/#{charge_code}/filters"
           url += "/#{filter_id}" if filter_id
-          URI(url)
+          URI(append_status_query(url, subscription_status))
         end
 
         def whitelist_subscription_charge_params(params)

data/lib/lago/api/resources/wallet.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'lago/api/resources/base'
+require 'lago/api/resources/customers/wallets/whitelist_params'
 
 module Lago
   module Api
@@ -15,71 +16,7 @@ module Lago
         end
 
         def whitelist_params(params)
-          result_hash = params.compact.slice(
-            :external_customer_id,
-            :rate_amount,
-            :name,
-            :code,
-            :priority,
-            :paid_credits,
-            :granted_credits,
-            :currency,
-            :expiration_at,
-            :transaction_metadata,
-            :invoice_requires_successful_payment,
-            :ignore_paid_top_up_limits_on_creation,
-            :transaction_name,
-            :paid_top_up_min_amount_cents,
-            :paid_top_up_max_amount_cents
-          )
-
-          recurring_rules = whitelist_recurring_rules(params[:recurring_transaction_rules])
-          result_hash[:recurring_transaction_rules] = recurring_rules if recurring_rules.any?
-
-          applies_to = whitelist_applies_to(params[:applies_to])
-          result_hash[:applies_to] = applies_to if applies_to.any?
-
-          metadata = whitelist_metadata(params[:metadata])
-          result_hash[:metadata] = metadata if metadata
-
-          payment_method_params = whitelist_payment_method_params(params[:payment_method])
-          result_hash[:payment_method] = payment_method_params if payment_method_params.present?
-
-          { root_name => result_hash }
-        end
-
-        def whitelist_recurring_rules(rules)
-          processed_rules = []
-
-          (rules || []).each do |r|
-            result = (r || {}).slice(
-              :lago_id,
-              :paid_credits,
-              :granted_credits,
-              :threshold_credits,
-              :invoice_requires_successful_payment,
-              :trigger,
-              :interval,
-              :method,
-              :started_at,
-              :expiration_at,
-              :target_ongoing_balance,
-              :transaction_metadata,
-              :transaction_name,
-              :ignore_paid_top_up_limits
-            )
-
-            payment_method_params = whitelist_payment_method_params(r[:payment_method])
-            result[:payment_method] = payment_method_params if payment_method_params.present?
-
-            processed_rules << result unless result.empty?
-          end
-
-          processed_rules
-        end
-
-        def whitelist_applies_to(applies_to_params)
-          (applies_to_params || {}).slice(:fee_types, :billable_metric_codes)
+          Customers::Wallets::WhitelistParams.new.wallet(params)
         end
 
         def whitelist_metadata(metadata)

data/lib/lago/api/resources/wallet_transaction.rb

@@ -28,6 +28,20 @@ module Lago
           JSON.parse(response.to_json, object_class: OpenStruct)
         end
 
+        def consumptions(wallet_transaction_id, options = {})
+          path = "/api/v1/wallet_transactions/#{wallet_transaction_id}/consumptions"
+          response = connection.get_all(options, path)
+
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        def fundings(wallet_transaction_id, options = {})
+          path = "/api/v1/wallet_transactions/#{wallet_transaction_id}/fundings"
+          response = connection.get_all(options, path)
+
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
         def whitelist_params(params)
           result = params.compact.slice(
             :wallet_id,
@@ -41,7 +55,10 @@ module Lago
           )
 
           payment_method_params = whitelist_payment_method_params(params[:payment_method])
-          result[:payment_method] = payment_method_params if payment_method_params.present?
+          result[:payment_method] = payment_method_params if payment_method_params
+
+          invoice_custom_section = whitelist_invoice_custom_section_params(params[:invoice_custom_section])
+          result[:invoice_custom_section] = invoice_custom_section if invoice_custom_section
 
           { 'wallet_transaction' => result }
         end
@@ -51,6 +68,10 @@ module Lago
         def whitelist_payment_method_params(payment_method_param)
           payment_method_param&.slice(:payment_method_type, :payment_method_id)
         end
+
+        def whitelist_invoice_custom_section_params(invoice_custom_section_param)
+          invoice_custom_section_param&.slice(:skip_invoice_custom_sections, :invoice_custom_section_codes)
+        end
       end
     end
   end

data/lib/lago/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lago
-  VERSION = '1.43.0'
+  VERSION = '1.44.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lago-ruby-client
 version: !ruby/object:Gem::Version
-  version: 1.43.0
+  version: 1.44.0
 platform: ruby
 authors:
 - Lovro Colic
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-27 00:00:00.000000000 Z
+date: 2026-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jwt
@@ -306,6 +306,11 @@ files:
 - lib/lago/api/resources/customers/payment_request.rb
 - lib/lago/api/resources/customers/subscription.rb
 - lib/lago/api/resources/customers/wallet.rb
+- lib/lago/api/resources/customers/wallets.rb
+- lib/lago/api/resources/customers/wallets/alert.rb
+- lib/lago/api/resources/customers/wallets/base.rb
+- lib/lago/api/resources/customers/wallets/metadata.rb
+- lib/lago/api/resources/customers/wallets/whitelist_params.rb
 - lib/lago/api/resources/event.rb
 - lib/lago/api/resources/feature.rb
 - lib/lago/api/resources/fee.rb
@@ -314,6 +319,7 @@ files:
 - lib/lago/api/resources/invoice_collection.rb
 - lib/lago/api/resources/invoiced_usage.rb
 - lib/lago/api/resources/mrr.rb
+- lib/lago/api/resources/nested.rb
 - lib/lago/api/resources/organization.rb
 - lib/lago/api/resources/overdue_balance.rb
 - lib/lago/api/resources/payment.rb