lago-ruby-client 1.40.0 → 1.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37c60d46c38643113860ccaa8eea0beb2e9ff735c84c494575458729ba4e1340
-  data.tar.gz: 17259c33488215f546afb8d5a0fd4541a67a3812486233a417223d1e484a6a6c
+  metadata.gz: 7e05c7adf2d8d5d2dd6d5e8e9263908f415013356761245b1f22878b0fd0c7a2
+  data.tar.gz: d89d43c70f055b2363ef08cb063d5910f1335257846292400b4e1f88e0ab882f
 SHA512:
-  metadata.gz: c85b6545df50a21700f6392ee592944cc873961c9ecb7b553c0447b26a40de6697c634f14a0a2e1cfabd3ade4e76026bf1c14c32ead3de3e02e55fc6ce9ef13c
-  data.tar.gz: a36624870091a68b739c7e112a7c8be41bb79b36a51800fae1b06c17c0bb73145451785c99f5bc40e97b75fb3a6a46d1136b12b645dea782110ee6dbdd297716
+  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'
@@ -15,9 +16,14 @@ require 'lago/api/resources/customers/applied_coupon'
 require 'lago/api/resources/customers/credit_note'
 require 'lago/api/resources/customers/invoice'
 require 'lago/api/resources/customers/payment'
+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'
@@ -122,6 +128,10 @@ module Lago
         Resources::Customers::Payment.new(self, resource_id)
       end
 
+      def customer_payment_methods(resource_id)
+        Resources::Customers::PaymentMethod.new(self, resource_id)
+      end
+
       def customer_payment_requests(resource_id)
         Resources::Customers::PaymentRequest.new(self, resource_id)
       end

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/payment_method.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'lago/api/resources/customers/base'
+
+module Lago
+  module Api
+    module Resources
+      module Customers
+        class PaymentMethod < Base
+          def api_resource
+            "#{base_api_resource}/payment_methods"
+          end
+
+          def root_name
+            'payment_method'
+          end
+
+          def destroy(id, options: nil)
+            response = connection.destroy(identifier: id, options:)[root_name]
+
+            JSON.parse(response.to_json, object_class: OpenStruct)
+          end
+
+          # rubocop:disable Naming/AccessorMethodName
+          def set_as_default(payment_method_id)
+            path = "/api/v1/#{api_resource}/#{payment_method_id}/set_as_default"
+            response = connection.put(path, identifier: nil, body: {})[root_name]
+
+            JSON.parse(response.to_json, object_class: OpenStruct)
+          end
+          # rubocop:enable Naming/AccessorMethodName
+        end
+      end
+    end
+  end
+end

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

@@ -59,9 +59,12 @@ module Lago
           JSON.parse(response.to_json, object_class: OpenStruct).invoice
         end
 
-        def retry_payment(invoice_id)
+        def retry_payment(invoice_id, params = {})
           path = "/api/v1/invoices/#{invoice_id}/retry_payment"
-          response = connection.post({}, path)
+          payment_method_params = whitelist_payment_method_params(params[:payment_method])
+          payload = { payment_method: payment_method_params }.compact
+
+          response = connection.post(payload, path)
 
           JSON.parse(response.to_json, object_class: OpenStruct)
         end
@@ -128,6 +131,12 @@ module Lago
           fees = whitelist_fees(params[:fees])
           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
+
+          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
 
@@ -161,6 +170,16 @@ module Lago
             credit_amount: params[:credit_amount]
           }.compact
         end
+
+        private
+
+        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/plan.rb

@@ -54,6 +54,117 @@ module Lago
           JSON.parse(response.to_json, object_class: OpenStruct).entitlement
         end
 
+        # Charges
+        def get_all_charges(plan_code, options = {})
+          response = connection.get_all(options, charges_uri(plan_code))
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        def get_charge(plan_code, charge_code)
+          response = connection.get(charges_uri(plan_code, charge_code), identifier: nil)
+          JSON.parse(response.to_json, object_class: OpenStruct).charge
+        end
+
+        def create_charge(plan_code, params)
+          response = connection.post(
+            whitelist_charge_params(params),
+            charges_uri(plan_code),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).charge
+        end
+
+        def update_charge(plan_code, charge_code, params)
+          response = connection.put(
+            charges_uri(plan_code, charge_code),
+            identifier: nil,
+            body: whitelist_charge_params(params),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).charge
+        end
+
+        def destroy_charge(plan_code, charge_code, params = {})
+          response = connection.destroy(
+            charges_uri(plan_code, charge_code),
+            identifier: nil,
+            options: params.empty? ? nil : params,
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).charge
+        end
+
+        # Fixed Charges
+        def get_all_fixed_charges(plan_code, options = {})
+          response = connection.get_all(options, fixed_charges_uri(plan_code))
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        def get_fixed_charge(plan_code, fixed_charge_code)
+          response = connection.get(fixed_charges_uri(plan_code, fixed_charge_code), identifier: nil)
+          JSON.parse(response.to_json, object_class: OpenStruct).fixed_charge
+        end
+
+        def create_fixed_charge(plan_code, params)
+          response = connection.post(
+            whitelist_fixed_charge_params(params),
+            fixed_charges_uri(plan_code),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).fixed_charge
+        end
+
+        def update_fixed_charge(plan_code, fixed_charge_code, params)
+          response = connection.put(
+            fixed_charges_uri(plan_code, fixed_charge_code),
+            identifier: nil,
+            body: whitelist_fixed_charge_params(params),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).fixed_charge
+        end
+
+        def destroy_fixed_charge(plan_code, fixed_charge_code, params = {})
+          response = connection.destroy(
+            fixed_charges_uri(plan_code, fixed_charge_code),
+            identifier: nil,
+            options: params.empty? ? nil : params,
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).fixed_charge
+        end
+
+        # Charge Filters
+        def get_all_charge_filters(plan_code, charge_code, options = {})
+          response = connection.get_all(options, charge_filters_uri(plan_code, charge_code))
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        def get_charge_filter(plan_code, charge_code, filter_id)
+          response = connection.get(charge_filters_uri(plan_code, charge_code, filter_id), identifier: nil)
+          JSON.parse(response.to_json, object_class: OpenStruct).filter
+        end
+
+        def create_charge_filter(plan_code, charge_code, params)
+          response = connection.post(
+            whitelist_charge_filter_params(params),
+            charge_filters_uri(plan_code, charge_code),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).filter
+        end
+
+        def update_charge_filter(plan_code, charge_code, filter_id, params)
+          response = connection.put(
+            charge_filters_uri(plan_code, charge_code, filter_id),
+            identifier: nil,
+            body: whitelist_charge_filter_params(params),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).filter
+        end
+
+        def destroy_charge_filter(plan_code, charge_code, filter_id, params = {})
+          response = connection.destroy(
+            charge_filters_uri(plan_code, charge_code, filter_id),
+            identifier: nil,
+            options: params.empty? ? nil : params,
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).filter
+        end
+
         def whitelist_params(params)
           result_hash = {
             name: params[:name],
@@ -119,6 +230,7 @@ module Lago
               :filters,
               :tax_codes,
               :applied_pricing_unit,
+              :accepts_target_wallet,
             )
 
             processed_charges << result unless result.empty?
@@ -216,6 +328,76 @@ module Lago
           url += "/#{action}" if action
           URI(url)
         end
+
+        def charges_uri(plan_code, charge_code = nil)
+          url = "#{client.base_api_url}#{api_resource}/#{plan_code}/charges"
+          url += "/#{charge_code}" if charge_code
+          URI(url)
+        end
+
+        def fixed_charges_uri(plan_code, fixed_charge_code = nil)
+          url = "#{client.base_api_url}#{api_resource}/#{plan_code}/fixed_charges"
+          url += "/#{fixed_charge_code}" if fixed_charge_code
+          URI(url)
+        end
+
+        def charge_filters_uri(plan_code, charge_code, filter_id = nil)
+          url = "#{client.base_api_url}#{api_resource}/#{plan_code}/charges/#{charge_code}/filters"
+          url += "/#{filter_id}" if filter_id
+          URI(url)
+        end
+
+        def whitelist_charge_params(params)
+          {
+            charge: (params || {}).slice(
+              :billable_metric_id,
+              :code,
+              :invoice_display_name,
+              :charge_model,
+              :pay_in_advance,
+              :prorated,
+              :invoiceable,
+              :regroup_paid_fees,
+              :min_amount_cents,
+              :accepts_target_wallet,
+              :properties,
+              :filters,
+              :tax_codes,
+              :applied_pricing_unit,
+              :cascade_updates,
+            ),
+          }
+        end
+
+        def whitelist_fixed_charge_params(params)
+          {
+            fixed_charge: (params || {}).slice(
+              :add_on_id,
+              :add_on_code,
+              :code,
+              :invoice_display_name,
+              :charge_model,
+              :pay_in_advance,
+              :prorated,
+              :units,
+              :apply_units_immediately,
+              :properties,
+              :tax_codes,
+              :cascade_updates,
+            ),
+          }
+        end
+
+        def whitelist_charge_filter_params(params)
+          {
+            filter: (params || {}).slice(
+              :invoice_display_name,
+              :properties,
+              :values,
+              :cascade_updates,
+            ),
+          }
+        end
       end
     end
   end

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

@@ -35,86 +35,192 @@ 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 fixed_charges(external_subscription_id)
-          uri = URI(
-            "#{client.base_api_url}#{api_resource}/#{external_subscription_id}/fixed_charges",
+        def create_alert(external_subscription_id, params, subscription_status: nil)
+          response = connection.post(
+            whitelist_alert_create_params(params),
+            alert_uri(external_subscription_id, subscription_status:),
           )
-          response = connection.get(uri, identifier: nil)
-          JSON.parse(response.to_json, object_class: OpenStruct).fixed_charges
+          JSON.parse(response.to_json, object_class: OpenStruct).alert
         end
 
-        def create_alert(external_subscription_id, params)
+        def create_alerts(external_subscription_id, params, subscription_status: nil)
           response = connection.post(
-            whitelist_alert_create_params(params),
-            alert_uri(external_subscription_id),
+            whitelist_alert_batch_create_params(params),
+            alert_uri(external_subscription_id, subscription_status:),
           )
-          JSON.parse(response.to_json, object_class: OpenStruct).alert
+          JSON.parse(response.to_json, object_class: OpenStruct).alerts
+        end
+
+        def delete_alerts(external_subscription_id, subscription_status: nil)
+          connection.destroy(alert_uri(external_subscription_id, subscription_status:), identifier: nil)
+        end
+
+        # Charges
+        def get_all_charges(external_id, options = {})
+          response = connection.get_all(options, charges_uri(external_id))
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        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, subscription_status: nil)
+          response = connection.put(
+            charges_uri(external_id, charge_code, subscription_status:),
+            identifier: nil,
+            body: whitelist_subscription_charge_params(params),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).charge
+        end
+
+        # Fixed Charges
+        def get_all_fixed_charges(external_id, options = {})
+          response = connection.get_all(options, fixed_charges_uri(external_id))
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        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, subscription_status: nil)
+          response = connection.put(
+            fixed_charges_uri(external_id, fixed_charge_code, subscription_status:),
+            identifier: nil,
+            body: whitelist_subscription_fixed_charge_params(params),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).fixed_charge
+        end
+
+        # Charge Filters
+        def get_all_charge_filters(external_id, charge_code, options = {})
+          response = connection.get_all(options, charge_filters_uri(external_id, charge_code))
+          JSON.parse(response.to_json, object_class: OpenStruct)
+        end
+
+        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, subscription_status: nil)
+          response = connection.post(
+            whitelist_subscription_charge_filter_params(params),
+            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, subscription_status: nil)
+          response = connection.put(
+            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, subscription_status: nil)
+          response = connection.destroy(
+            charge_filters_uri(external_id, charge_code, filter_id, subscription_status:),
+            identifier: nil,
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).filter
         end
 
         def whitelist_params(params)
-          {
-            root_name => {
-              external_customer_id: params[:external_customer_id],
-              plan_code: params[:plan_code],
-              name: params[:name],
-              external_id: params[:external_id],
-              billing_time: params[:billing_time],
-              subscription_at: params[:subscription_at],
-              ending_at: params[:ending_at],
-              plan_overrides: params[:plan_overrides],
-            }.compact,
-          }
+          result = {
+            external_customer_id: params[:external_customer_id],
+            plan_code: params[:plan_code],
+            name: params[:name],
+            external_id: params[:external_id],
+            billing_time: params[:billing_time],
+            subscription_at: params[:subscription_at],
+            ending_at: params[:ending_at],
+            plan_overrides: params[:plan_overrides],
+          }.compact
+
+          payment_method_params = whitelist_payment_method_params(params[:payment_method])
+          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
 
         def whitelist_lifetime_usage_params(params)
@@ -137,6 +243,20 @@ module Lago
           }
         end
 
+        def whitelist_alert_batch_create_params(params)
+          {
+            alerts: (params[:alerts] || []).map do |alert|
+              {
+                alert_type: alert[:alert_type],
+                name: alert[:name],
+                code: alert[:code],
+                billable_metric_code: alert[:billable_metric_code],
+                thresholds: alert[:thresholds],
+              }.compact
+            end,
+          }
+        end
+
         def whitelist_alert_update_params(params)
           {
             alert: {
@@ -162,15 +282,84 @@ module Lago
 
         private
 
-        def entitlements_uri(external_subscription_id, feature_code = nil, action = nil)
+        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
+
+        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, 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, subscription_status: nil)
+          url = "#{client.base_api_url}#{api_resource}/#{external_id}/charges"
+          url += "/#{charge_code}" if charge_code
+          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 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(append_status_query(url, subscription_status))
+        end
+
+        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(append_status_query(url, subscription_status))
+        end
+
+        def whitelist_subscription_charge_params(params)
+          {
+            charge: (params || {}).slice(
+              :invoice_display_name,
+              :min_amount_cents,
+              :properties,
+              :filters,
+              :tax_codes,
+              :applied_pricing_unit,
+            ),
+          }
+        end
+
+        def whitelist_subscription_fixed_charge_params(params)
+          {
+            fixed_charge: (params || {}).slice(
+              :invoice_display_name,
+              :units,
+              :apply_units_immediately,
+              :properties,
+              :tax_codes,
+            ),
+          }
+        end
+
+        def whitelist_subscription_charge_filter_params(params)
+          {
+            filter: (params || {}).slice(
+              :invoice_display_name,
+              :properties,
+              :values,
+            ),
+          }
         end
       end
     end

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,64 +16,7 @@ module Lago
         end
 
         def whitelist_params(params)
-          result_hash = params.compact.slice(
-            :external_customer_id,
-            :rate_amount,
-            :name,
-            :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
-
-          { 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
-            )
-
-            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)
@@ -108,6 +52,12 @@ module Lago
 
           response['metadata']
         end
+
+        private
+
+        def whitelist_payment_method_params(payment_method_param)
+          payment_method_param&.slice(:payment_method_type, :payment_method_id)
+        end
       end
     end
   end

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

@@ -28,19 +28,49 @@ 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)
-          {
-            'wallet_transaction' => params.compact.slice(
-              :wallet_id,
-              :name,
-              :paid_credits,
-              :granted_credits,
-              :voided_credits,
-              :invoice_requires_successful_payment,
-              :ignore_paid_top_up_limits,
-              :metadata,
-            )
-          }
+          result = params.compact.slice(
+            :wallet_id,
+            :name,
+            :paid_credits,
+            :granted_credits,
+            :voided_credits,
+            :invoice_requires_successful_payment,
+            :ignore_paid_top_up_limits,
+            :metadata,
+          )
+
+          payment_method_params = whitelist_payment_method_params(params[:payment_method])
+          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
+
+        private
+
+        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

data/lib/lago/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lago
-  VERSION = '1.40.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.40.0
+  version: 1.44.0
 platform: ruby
 authors:
 - Lovro Colic
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-26 00:00:00.000000000 Z
+date: 2026-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jwt
@@ -302,9 +302,15 @@ files:
 - lib/lago/api/resources/customers/credit_note.rb
 - lib/lago/api/resources/customers/invoice.rb
 - lib/lago/api/resources/customers/payment.rb
+- lib/lago/api/resources/customers/payment_method.rb
 - 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
@@ -313,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