dodopayments 1.52.4 → 1.53.2

data/rbi/dodopayments/models/refund.rbi

@@ -16,6 +16,15 @@ module Dodopayments
       sig { returns(Time) }
       attr_accessor :created_at
 
+      # Details about the customer for this refund (from the associated payment)
+      sig { returns(Dodopayments::CustomerLimitedDetails) }
+      attr_reader :customer
+
+      sig do
+        params(customer: Dodopayments::CustomerLimitedDetails::OrHash).void
+      end
+      attr_writer :customer
+
       # If true the refund is a partial refund
       sig { returns(T::Boolean) }
       attr_accessor :is_partial
@@ -48,6 +57,7 @@ module Dodopayments
         params(
           business_id: String,
           created_at: Time,
+          customer: Dodopayments::CustomerLimitedDetails::OrHash,
           is_partial: T::Boolean,
           payment_id: String,
           refund_id: String,
@@ -62,6 +72,8 @@ module Dodopayments
         business_id:,
         # The timestamp of when the refund was created in UTC.
         created_at:,
+        # Details about the customer for this refund (from the associated payment)
+        customer:,
         # If true the refund is a partial refund
         is_partial:,
         # The unique identifier of the payment associated with the refund.
@@ -84,6 +96,7 @@ module Dodopayments
           {
             business_id: String,
             created_at: Time,
+            customer: Dodopayments::CustomerLimitedDetails,
             is_partial: T::Boolean,
             payment_id: String,
             refund_id: String,

data/rbi/dodopayments/models/refund_list_response.rbi

@@ -0,0 +1,104 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class RefundListResponse < Dodopayments::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::Models::RefundListResponse,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      # The unique identifier of the business issuing the refund.
+      sig { returns(String) }
+      attr_accessor :business_id
+
+      # The timestamp of when the refund was created in UTC.
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # If true the refund is a partial refund
+      sig { returns(T::Boolean) }
+      attr_accessor :is_partial
+
+      # The unique identifier of the payment associated with the refund.
+      sig { returns(String) }
+      attr_accessor :payment_id
+
+      # The unique identifier of the refund.
+      sig { returns(String) }
+      attr_accessor :refund_id
+
+      # The current status of the refund.
+      sig { returns(Dodopayments::RefundStatus::TaggedSymbol) }
+      attr_accessor :status
+
+      # The refunded amount.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :amount
+
+      # The currency of the refund, represented as an ISO 4217 currency code.
+      sig { returns(T.nilable(Dodopayments::Currency::TaggedSymbol)) }
+      attr_accessor :currency
+
+      # The reason provided for the refund, if any. Optional.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :reason
+
+      sig do
+        params(
+          business_id: String,
+          created_at: Time,
+          is_partial: T::Boolean,
+          payment_id: String,
+          refund_id: String,
+          status: Dodopayments::RefundStatus::OrSymbol,
+          amount: T.nilable(Integer),
+          currency: T.nilable(Dodopayments::Currency::OrSymbol),
+          reason: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The unique identifier of the business issuing the refund.
+        business_id:,
+        # The timestamp of when the refund was created in UTC.
+        created_at:,
+        # If true the refund is a partial refund
+        is_partial:,
+        # The unique identifier of the payment associated with the refund.
+        payment_id:,
+        # The unique identifier of the refund.
+        refund_id:,
+        # The current status of the refund.
+        status:,
+        # The refunded amount.
+        amount: nil,
+        # The currency of the refund, represented as an ISO 4217 currency code.
+        currency: nil,
+        # The reason provided for the refund, if any. Optional.
+        reason: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            business_id: String,
+            created_at: Time,
+            is_partial: T::Boolean,
+            payment_id: String,
+            refund_id: String,
+            status: Dodopayments::RefundStatus::TaggedSymbol,
+            amount: T.nilable(Integer),
+            currency: T.nilable(Dodopayments::Currency::TaggedSymbol),
+            reason: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/subscription.rbi

@@ -44,6 +44,10 @@ module Dodopayments
       sig { returns(T::Hash[Symbol, String]) }
       attr_accessor :metadata
 
+      # Meters associated with this subscription (for usage-based billing)
+      sig { returns(T::Array[Dodopayments::Subscription::Meter]) }
+      attr_accessor :meters
+
       # Timestamp of the next scheduled billing. Indicates the end of current billing
       # period
       sig { returns(Time) }
@@ -128,6 +132,7 @@ module Dodopayments
           currency: Dodopayments::Currency::OrSymbol,
           customer: Dodopayments::CustomerLimitedDetails::OrHash,
           metadata: T::Hash[Symbol, String],
+          meters: T::Array[Dodopayments::Subscription::Meter::OrHash],
           next_billing_date: Time,
           on_demand: T::Boolean,
           payment_frequency_count: Integer,
@@ -163,6 +168,8 @@ module Dodopayments
         customer:,
         # Additional custom data associated with the subscription
         metadata:,
+        # Meters associated with this subscription (for usage-based billing)
+        meters:,
         # Timestamp of the next scheduled billing. Indicates the end of current billing
         # period
         next_billing_date:,
@@ -214,6 +221,7 @@ module Dodopayments
             currency: Dodopayments::Currency::TaggedSymbol,
             customer: Dodopayments::CustomerLimitedDetails,
             metadata: T::Hash[Symbol, String],
+            meters: T::Array[Dodopayments::Subscription::Meter],
             next_billing_date: Time,
             on_demand: T::Boolean,
             payment_frequency_count: Integer,
@@ -239,6 +247,76 @@ module Dodopayments
       end
       def to_hash
       end
+
+      class Meter < Dodopayments::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Dodopayments::Subscription::Meter,
+              Dodopayments::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Dodopayments::Currency::TaggedSymbol) }
+        attr_accessor :currency
+
+        sig { returns(Integer) }
+        attr_accessor :free_threshold
+
+        sig { returns(String) }
+        attr_accessor :measurement_unit
+
+        sig { returns(String) }
+        attr_accessor :meter_id
+
+        sig { returns(String) }
+        attr_accessor :name
+
+        sig { returns(String) }
+        attr_accessor :price_per_unit
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :description
+
+        # Response struct representing usage-based meter cart details for a subscription
+        sig do
+          params(
+            currency: Dodopayments::Currency::OrSymbol,
+            free_threshold: Integer,
+            measurement_unit: String,
+            meter_id: String,
+            name: String,
+            price_per_unit: String,
+            description: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          currency:,
+          free_threshold:,
+          measurement_unit:,
+          meter_id:,
+          name:,
+          price_per_unit:,
+          description: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              currency: Dodopayments::Currency::TaggedSymbol,
+              free_threshold: Integer,
+              measurement_unit: String,
+              meter_id: String,
+              name: String,
+              price_per_unit: String,
+              description: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
     end
   end
 end

data/rbi/dodopayments/models/subscription_charge_params.rbi

@@ -25,6 +25,26 @@ module Dodopayments
       sig { returns(T.nilable(T::Boolean)) }
       attr_accessor :adaptive_currency_fees_inclusive
 
+      # Specify how customer balance is used for the payment
+      sig do
+        returns(
+          T.nilable(
+            Dodopayments::SubscriptionChargeParams::CustomerBalanceConfig
+          )
+        )
+      end
+      attr_reader :customer_balance_config
+
+      sig do
+        params(
+          customer_balance_config:
+            T.nilable(
+              Dodopayments::SubscriptionChargeParams::CustomerBalanceConfig::OrHash
+            )
+        ).void
+      end
+      attr_writer :customer_balance_config
+
       # Metadata for the payment. If not passed, the metadata of the subscription will
       # be taken
       sig { returns(T.nilable(T::Hash[Symbol, String])) }
@@ -44,6 +64,10 @@ module Dodopayments
         params(
           product_price: Integer,
           adaptive_currency_fees_inclusive: T.nilable(T::Boolean),
+          customer_balance_config:
+            T.nilable(
+              Dodopayments::SubscriptionChargeParams::CustomerBalanceConfig::OrHash
+            ),
           metadata: T.nilable(T::Hash[Symbol, String]),
           product_currency: T.nilable(Dodopayments::Currency::OrSymbol),
           product_description: T.nilable(String),
@@ -58,6 +82,8 @@ module Dodopayments
         # added on top (false). This field is ignored if adaptive pricing is not enabled
         # for the business.
         adaptive_currency_fees_inclusive: nil,
+        # Specify how customer balance is used for the payment
+        customer_balance_config: nil,
         # Metadata for the payment. If not passed, the metadata of the subscription will
         # be taken
         metadata: nil,
@@ -76,6 +102,10 @@ module Dodopayments
           {
             product_price: Integer,
             adaptive_currency_fees_inclusive: T.nilable(T::Boolean),
+            customer_balance_config:
+              T.nilable(
+                Dodopayments::SubscriptionChargeParams::CustomerBalanceConfig
+              ),
             metadata: T.nilable(T::Hash[Symbol, String]),
             product_currency: T.nilable(Dodopayments::Currency::OrSymbol),
             product_description: T.nilable(String),
@@ -85,6 +115,50 @@ module Dodopayments
       end
       def to_hash
       end
+
+      class CustomerBalanceConfig < Dodopayments::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Dodopayments::SubscriptionChargeParams::CustomerBalanceConfig,
+              Dodopayments::Internal::AnyHash
+            )
+          end
+
+        # Allows Customer Credit to be purchased to settle payments
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :allow_customer_credits_purchase
+
+        # Allows Customer Credit Balance to be used to settle payments
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :allow_customer_credits_usage
+
+        # Specify how customer balance is used for the payment
+        sig do
+          params(
+            allow_customer_credits_purchase: T.nilable(T::Boolean),
+            allow_customer_credits_usage: T.nilable(T::Boolean)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Allows Customer Credit to be purchased to settle payments
+          allow_customer_credits_purchase: nil,
+          # Allows Customer Credit Balance to be used to settle payments
+          allow_customer_credits_usage: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              allow_customer_credits_purchase: T.nilable(T::Boolean),
+              allow_customer_credits_usage: T.nilable(T::Boolean)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
     end
   end
 end

data/rbi/dodopayments/resources/customers/wallets/ledger_entries.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+module Dodopayments
+  module Resources
+    class Customers
+      class Wallets
+        class LedgerEntries
+          sig do
+            params(
+              customer_id: String,
+              amount: Integer,
+              currency: Dodopayments::Currency::OrSymbol,
+              entry_type:
+                Dodopayments::Customers::Wallets::LedgerEntryCreateParams::EntryType::OrSymbol,
+              idempotency_key: T.nilable(String),
+              reason: T.nilable(String),
+              request_options: Dodopayments::RequestOptions::OrHash
+            ).returns(Dodopayments::Customers::CustomerWallet)
+          end
+          def create(
+            # Customer ID
+            customer_id,
+            amount:,
+            # Currency of the wallet to adjust
+            currency:,
+            # Type of ledger entry - credit or debit
+            entry_type:,
+            # Optional idempotency key to prevent duplicate entries
+            idempotency_key: nil,
+            reason: nil,
+            request_options: {}
+          )
+          end
+
+          sig do
+            params(
+              customer_id: String,
+              currency: Dodopayments::Currency::OrSymbol,
+              page_number: Integer,
+              page_size: Integer,
+              request_options: Dodopayments::RequestOptions::OrHash
+            ).returns(
+              Dodopayments::Internal::DefaultPageNumberPagination[
+                Dodopayments::Customers::Wallets::CustomerWalletTransaction
+              ]
+            )
+          end
+          def list(
+            # Customer ID
+            customer_id,
+            # Optional currency filter
+            currency: nil,
+            page_number: nil,
+            page_size: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Dodopayments::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/dodopayments/resources/customers/wallets.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Dodopayments
+  module Resources
+    class Customers
+      class Wallets
+        sig do
+          returns(Dodopayments::Resources::Customers::Wallets::LedgerEntries)
+        end
+        attr_reader :ledger_entries
+
+        sig do
+          params(
+            customer_id: String,
+            request_options: Dodopayments::RequestOptions::OrHash
+          ).returns(Dodopayments::Models::Customers::WalletListResponse)
+        end
+        def list(
+          # Customer ID
+          customer_id,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Dodopayments::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/dodopayments/resources/customers.rbi

@@ -6,6 +6,9 @@ module Dodopayments
       sig { returns(Dodopayments::Resources::Customers::CustomerPortal) }
       attr_reader :customer_portal
 
+      sig { returns(Dodopayments::Resources::Customers::Wallets) }
+      attr_reader :wallets
+
       sig do
         params(
           email: String,

data/rbi/dodopayments/resources/licenses.rbi

@@ -8,7 +8,7 @@ module Dodopayments
           license_key: String,
           name: String,
           request_options: Dodopayments::RequestOptions::OrHash
-        ).returns(Dodopayments::LicenseKeyInstance)
+        ).returns(Dodopayments::Models::LicenseActivateResponse)
       end
       def activate(license_key:, name:, request_options: {})
       end

data/rbi/dodopayments/resources/refunds.rbi

@@ -47,7 +47,7 @@ module Dodopayments
           request_options: Dodopayments::RequestOptions::OrHash
         ).returns(
           Dodopayments::Internal::DefaultPageNumberPagination[
-            Dodopayments::Refund
+            Dodopayments::Models::RefundListResponse
           ]
         )
       end

data/rbi/dodopayments/resources/subscriptions.rbi

@@ -181,6 +181,10 @@ module Dodopayments
           subscription_id: String,
           product_price: Integer,
           adaptive_currency_fees_inclusive: T.nilable(T::Boolean),
+          customer_balance_config:
+            T.nilable(
+              Dodopayments::SubscriptionChargeParams::CustomerBalanceConfig::OrHash
+            ),
           metadata: T.nilable(T::Hash[Symbol, String]),
           product_currency: T.nilable(Dodopayments::Currency::OrSymbol),
           product_description: T.nilable(String),
@@ -197,6 +201,8 @@ module Dodopayments
         # added on top (false). This field is ignored if adaptive pricing is not enabled
         # for the business.
         adaptive_currency_fees_inclusive: nil,
+        # Specify how customer balance is used for the payment
+        customer_balance_config: nil,
         # Metadata for the payment. If not passed, the metadata of the subscription will
         # be taken
         metadata: nil,

data/sig/dodopayments/models/customers/customer_wallet.rbs

@@ -0,0 +1,44 @@
+module Dodopayments
+  module Models
+    class CustomerWallet = Customers::CustomerWallet
+
+    module Customers
+      type customer_wallet =
+        {
+          balance: Integer,
+          created_at: Time,
+          currency: Dodopayments::Models::currency,
+          customer_id: String,
+          updated_at: Time
+        }
+
+      class CustomerWallet < Dodopayments::Internal::Type::BaseModel
+        attr_accessor balance: Integer
+
+        attr_accessor created_at: Time
+
+        attr_accessor currency: Dodopayments::Models::currency
+
+        attr_accessor customer_id: String
+
+        attr_accessor updated_at: Time
+
+        def initialize: (
+          balance: Integer,
+          created_at: Time,
+          currency: Dodopayments::Models::currency,
+          customer_id: String,
+          updated_at: Time
+        ) -> void
+
+        def to_hash: -> {
+          balance: Integer,
+          created_at: Time,
+          currency: Dodopayments::Models::currency,
+          customer_id: String,
+          updated_at: Time
+        }
+      end
+    end
+  end
+end

data/sig/dodopayments/models/customers/wallet_list_params.rbs

@@ -0,0 +1,17 @@
+module Dodopayments
+  module Models
+    module Customers
+      type wallet_list_params =
+        {  } & Dodopayments::Internal::Type::request_parameters
+
+      class WalletListParams < Dodopayments::Internal::Type::BaseModel
+        extend Dodopayments::Internal::Type::RequestParameters::Converter
+        include Dodopayments::Internal::Type::RequestParameters
+
+        def initialize: (?request_options: Dodopayments::request_opts) -> void
+
+        def to_hash: -> { request_options: Dodopayments::RequestOptions }
+      end
+    end
+  end
+end

data/sig/dodopayments/models/customers/wallet_list_response.rbs

@@ -0,0 +1,27 @@
+module Dodopayments
+  module Models
+    module Customers
+      type wallet_list_response =
+        {
+          items: ::Array[Dodopayments::Customers::CustomerWallet],
+          total_balance_usd: Integer
+        }
+
+      class WalletListResponse < Dodopayments::Internal::Type::BaseModel
+        attr_accessor items: ::Array[Dodopayments::Customers::CustomerWallet]
+
+        attr_accessor total_balance_usd: Integer
+
+        def initialize: (
+          items: ::Array[Dodopayments::Customers::CustomerWallet],
+          total_balance_usd: Integer
+        ) -> void
+
+        def to_hash: -> {
+          items: ::Array[Dodopayments::Customers::CustomerWallet],
+          total_balance_usd: Integer
+        }
+      end
+    end
+  end
+end