lago-ruby-client 1.37.0 → 1.43.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 600a30a440f5566e5d00ac7cf7ed11cd892549687f84f7101b3efa123344ed09
-  data.tar.gz: acf19141562235fbb7fb9b2ebd122c31daa8affcb835ea44a48a28af604f40ed
+  metadata.gz: 1cd4e9ed7d1b0f3eac5940fb37ea3b7b2616ceda00c5e3e4e42e0e80b0d0b3ba
+  data.tar.gz: 761ed874e1fb31e466ae0a5309132853ded262940f0504fcb6dc827a3af05c87
 SHA512:
-  metadata.gz: 41a39e59ded39792a643aa24ee1daa2d844c2f5d054aa984a880df8f9014d976d0c0f0cb47d82e48ebb9b4dfea305b827e17532ac22516556982a7239626361a
-  data.tar.gz: 7528982c6f111e71c028957cfe039b9802cb86accb28639b0691233184385888534865a5da02b4f0b7cf3d8ef7d2a35b6ac06572098700bb445ddfb1c0fe01d1
+  metadata.gz: 21a3cb1cd0b107edb3ac23e4a08738dd4c9f6ae96a8dee6ed07267a72b48cafdeb5d580afc631519961974c761dc44da151358ad9e3951f88c8a8f42e57f7c65
+  data.tar.gz: 87d47fc5d9f9039ca63975f697b30f1300314bc2448967e180944c1e68c0fc8576f8ddef53055e8c092cd0f28581fad43640ffeac638f3dcc3c6ca2f79f8d13d

data/lib/lago/api/client.rb

@@ -15,6 +15,7 @@ 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'
@@ -122,6 +123,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/connection.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'cgi'
+
 module Lago
   module Api
     class Connection
@@ -99,7 +101,7 @@ module Lago
       def handle_response(response)
         raise_error(response) unless RESPONSE_SUCCESS_CODES.include?(response.code.to_i)
 
-        response.body.empty? ? true : JSON.parse(response.body)
+        response.body.empty? || JSON.parse(response.body)
       rescue JSON::ParserError
         response.body
       end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'cgi'
+
 require 'lago/api/resources/base'
 
 module Lago
@@ -15,7 +17,7 @@ module Lago
         end
 
         def destroy(external_customer_id, applied_coupon_id)
-          path = "/api/v1/customers/#{external_customer_id}/applied_coupons"
+          path = "/api/v1/customers/#{CGI.escapeURIComponent(external_customer_id)}/applied_coupons"
           response = connection.destroy(path, identifier: applied_coupon_id)[root_name]
 
           JSON.parse(response.to_json, object_class: OpenStruct)

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

@@ -21,15 +21,23 @@ module Lago
             refund_status: params[:refund_status],
             credit_amount_cents: params[:credit_amount_cents],
             refund_amount_cents: params[:refund_amount_cents],
+            offset_amount_cents: params[:offset_amount_cents],
           }.compact
 
           whitelist_items(params[:items] || []).tap do |items|
             result_hash[:items] = items unless items.empty?
           end
 
+          metadata = whitelist_metadata(params[:metadata])
+          result_hash[:metadata] = metadata if metadata
+
           { root_name => result_hash }
         end
 
+        def whitelist_metadata(metadata)
+          metadata&.to_h&.transform_keys(&:to_s)&.transform_values { |v| v&.to_s }
+        end
+
         def whitelist_items(items)
           items.each_with_object([]) do |item, result|
             filtered_item = (item || {}).slice(
@@ -78,6 +86,36 @@ module Lago
 
           { root_name => result_hash }
         end
+
+        def replace_metadata(credit_note_id, metadata)
+          path = "/api/v1/credit_notes/#{credit_note_id}/metadata"
+          payload = { metadata: whitelist_metadata(metadata) }
+          response = connection.post(payload, path)
+
+          response['metadata']
+        end
+
+        def merge_metadata(credit_note_id, metadata)
+          path = "/api/v1/credit_notes/#{credit_note_id}/metadata"
+          payload = { metadata: whitelist_metadata(metadata) }
+          response = connection.patch(path, identifier: nil, body: payload)
+
+          response['metadata']
+        end
+
+        def delete_all_metadata(credit_note_id)
+          path = "/api/v1/credit_notes/#{credit_note_id}/metadata"
+          response = connection.destroy(path, identifier: nil)
+
+          response['metadata']
+        end
+
+        def delete_metadata_key(credit_note_id, key)
+          path = "/api/v1/credit_notes/#{credit_note_id}/metadata/#{key}"
+          response = connection.destroy(path, identifier: nil)
+
+          response['metadata']
+        end
       end
     end
   end

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

@@ -54,14 +54,17 @@ module Lago
 
         def lose_dispute(invoice_id)
           path = "/api/v1/invoices/#{invoice_id}/lose_dispute"
-          response = connection.put(path, identifier: nil, body: {})
+          response = connection.post({}, path)
 
           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,9 @@ 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.present?
+
           { root_name => result }
         end
 
@@ -161,6 +167,12 @@ 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
       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],
@@ -66,6 +177,7 @@ module Lago
             trial_period: params[:trial_period],
             pay_in_advance: params[:pay_in_advance],
             bill_charges_monthly: params[:bill_charges_monthly],
+            bill_fixed_charges_monthly: params[:bill_fixed_charges_monthly],
             tax_codes: params[:tax_codes],
             cascade_updates: params[:cascade_updates],
           }.compact
@@ -82,6 +194,13 @@ module Lago
             result_hash[:usage_thresholds] = usage_thresholds unless usage_thresholds.empty?
           end
 
+          whitelist_fixed_charges(params[:fixed_charges]).tap do |fixed_charges|
+            result_hash[:fixed_charges] = fixed_charges unless fixed_charges.empty?
+          end
+
+          metadata = whitelist_metadata(params[:metadata])
+          result_hash[:metadata] = metadata if metadata
+
           { root_name => result_hash }
         end
 
@@ -106,10 +225,12 @@ module Lago
               :regroup_paid_fees,
               :invoice_display_name,
               :min_amount_cents,
+              :prorated,
               :properties,
               :filters,
               :tax_codes,
               :applied_pricing_unit,
+              :accepts_target_wallet,
             )
 
             processed_charges << result unless result.empty?
@@ -135,12 +256,70 @@ module Lago
           processed_usage_thresholds
         end
 
+        def whitelist_fixed_charges(fixed_charges)
+          processed_fixed_charges = []
+
+          fixed_charges&.each do |fc|
+            result = (fc || {}).slice(
+              :id,
+              :add_on_id,
+              :charge_model,
+              :code,
+              :invoice_display_name,
+              :units,
+              :pay_in_advance,
+              :prorated,
+              :properties,
+              :tax_codes,
+              :apply_units_immediately,
+            )
+
+            processed_fixed_charges << result unless result.empty?
+          end
+
+          processed_fixed_charges
+        end
+
+        def whitelist_metadata(metadata)
+          metadata&.to_h&.transform_keys(&:to_s)&.transform_values { |v| v&.to_s }
+        end
+
         def whitelist_entitlements_params(params)
           {
             entitlements: params,
           }
         end
 
+        def replace_metadata(plan_code, metadata)
+          path = "/api/v1/plans/#{plan_code}/metadata"
+          payload = { metadata: whitelist_metadata(metadata) }
+          response = connection.post(payload, path)
+
+          response['metadata']
+        end
+
+        def merge_metadata(plan_code, metadata)
+          path = "/api/v1/plans/#{plan_code}/metadata"
+          payload = { metadata: whitelist_metadata(metadata) }
+          response = connection.patch(path, identifier: nil, body: payload)
+
+          response['metadata']
+        end
+
+        def delete_all_metadata(plan_code)
+          path = "/api/v1/plans/#{plan_code}/metadata"
+          response = connection.destroy(path, identifier: nil)
+
+          response['metadata']
+        end
+
+        def delete_metadata_key(plan_code, key)
+          path = "/api/v1/plans/#{plan_code}/metadata/#{key}"
+          response = connection.destroy(path, identifier: nil)
+
+          response['metadata']
+        end
+
         private
 
         def entitlements_uri(plan_code, feature_code = nil, action = nil)
@@ -149,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

@@ -94,19 +94,110 @@ module Lago
           JSON.parse(response.to_json, object_class: OpenStruct).alert
         end
 
+        def create_alerts(external_subscription_id, params)
+          response = connection.post(
+            whitelist_alert_batch_create_params(params),
+            alert_uri(external_subscription_id),
+          )
+          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)
+        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)
+          response = connection.get(charges_uri(external_id, charge_code), identifier: nil)
+          JSON.parse(response.to_json, object_class: OpenStruct).charge
+        end
+
+        def update_charge(external_id, charge_code, params)
+          response = connection.put(
+            charges_uri(external_id, charge_code),
+            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)
+          response = connection.get(fixed_charges_uri(external_id, fixed_charge_code), identifier: nil)
+          JSON.parse(response.to_json, object_class: OpenStruct).fixed_charge
+        end
+
+        def update_fixed_charge(external_id, fixed_charge_code, params)
+          response = connection.put(
+            fixed_charges_uri(external_id, fixed_charge_code),
+            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)
+          response = connection.get(charge_filters_uri(external_id, charge_code, filter_id), identifier: nil)
+          JSON.parse(response.to_json, object_class: OpenStruct).filter
+        end
+
+        def create_charge_filter(external_id, charge_code, params)
+          response = connection.post(
+            whitelist_subscription_charge_filter_params(params),
+            charge_filters_uri(external_id, charge_code),
+          )
+          JSON.parse(response.to_json, object_class: OpenStruct).filter
+        end
+
+        def update_charge_filter(external_id, charge_code, filter_id, params)
+          response = connection.put(
+            charge_filters_uri(external_id, charge_code, filter_id),
+            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)
+          response = connection.destroy(
+            charge_filters_uri(external_id, charge_code, filter_id),
+            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.present?
+
+          { root_name => result }
         end
 
         def whitelist_lifetime_usage_params(params)
@@ -129,6 +220,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: {
@@ -154,6 +259,10 @@ module Lago
 
         private
 
+        def whitelist_payment_method_params(payment_method_param)
+          payment_method_param&.slice(:payment_method_type, :payment_method_id)
+        end
+
         def entitlements_uri(external_subscription_id, feature_code = nil, action = nil)
           url = "#{client.base_api_url}#{api_resource}/#{external_subscription_id}/entitlements"
           url += "/#{feature_code}" if feature_code
@@ -164,6 +273,59 @@ module Lago
         def alert_uri(external_subscription_id, code = nil)
           URI("#{client.base_api_url}#{api_resource}/#{external_subscription_id}/alerts#{code ? "/#{code}" : ''}")
         end
+
+        def charges_uri(external_id, charge_code = nil)
+          url = "#{client.base_api_url}#{api_resource}/#{external_id}/charges"
+          url += "/#{charge_code}" if charge_code
+          URI(url)
+        end
+
+        def fixed_charges_uri(external_id, fixed_charge_code = nil)
+          url = "#{client.base_api_url}#{api_resource}/#{external_id}/fixed_charges"
+          url += "/#{fixed_charge_code}" if fixed_charge_code
+          URI(url)
+        end
+
+        def charge_filters_uri(external_id, charge_code, filter_id = nil)
+          url = "#{client.base_api_url}#{api_resource}/#{external_id}/charges/#{charge_code}/filters"
+          url += "/#{filter_id}" if filter_id
+          URI(url)
+        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
   end

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

@@ -19,6 +19,8 @@ module Lago
             :external_customer_id,
             :rate_amount,
             :name,
+            :code,
+            :priority,
             :paid_credits,
             :granted_credits,
             :currency,
@@ -37,6 +39,12 @@ module Lago
           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
 
@@ -61,6 +69,9 @@ module Lago
               :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
 
@@ -70,6 +81,46 @@ module Lago
         def whitelist_applies_to(applies_to_params)
           (applies_to_params || {}).slice(:fee_types, :billable_metric_codes)
         end
+
+        def whitelist_metadata(metadata)
+          metadata&.to_h&.transform_keys(&:to_s)&.transform_values { |v| v&.to_s }
+        end
+
+        def replace_metadata(wallet_id, metadata)
+          path = "/api/v1/wallets/#{wallet_id}/metadata"
+          payload = { metadata: whitelist_metadata(metadata) }
+          response = connection.post(payload, path)
+
+          response['metadata']
+        end
+
+        def merge_metadata(wallet_id, metadata)
+          path = "/api/v1/wallets/#{wallet_id}/metadata"
+          payload = { metadata: whitelist_metadata(metadata) }
+          response = connection.patch(path, identifier: nil, body: payload)
+
+          response['metadata']
+        end
+
+        def delete_all_metadata(wallet_id)
+          path = "/api/v1/wallets/#{wallet_id}/metadata"
+          response = connection.destroy(path, identifier: nil)
+
+          response['metadata']
+        end
+
+        def delete_metadata_key(wallet_id, key)
+          path = "/api/v1/wallets/#{wallet_id}/metadata/#{key}"
+          response = connection.destroy(path, identifier: nil)
+
+          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

@@ -29,18 +29,27 @@ module Lago
         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.present?
+
+          { 'wallet_transaction' => result }
+        end
+
+        private
+
+        def whitelist_payment_method_params(payment_method_param)
+          payment_method_param&.slice(:payment_method_type, :payment_method_id)
         end
       end
     end

data/lib/lago/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lago-ruby-client
 version: !ruby/object:Gem::Version
-  version: 1.37.0
+  version: 1.43.0
 platform: ruby
 authors:
 - Lovro Colic
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-09 00:00:00.000000000 Z
+date: 2026-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jwt
@@ -302,6 +302,7 @@ 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