dodopayments 1.52.4 → 1.53.2

data/rbi/dodopayments/models/customers/wallets/customer_wallet_transaction.rbi

@@ -0,0 +1,173 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    module Customers
+      module Wallets
+        class CustomerWalletTransaction < Dodopayments::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Dodopayments::Customers::Wallets::CustomerWalletTransaction,
+                Dodopayments::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig { returns(Integer) }
+          attr_accessor :after_balance
+
+          sig { returns(Integer) }
+          attr_accessor :amount
+
+          sig { returns(Integer) }
+          attr_accessor :before_balance
+
+          sig { returns(String) }
+          attr_accessor :business_id
+
+          sig { returns(Time) }
+          attr_accessor :created_at
+
+          sig { returns(Dodopayments::Currency::TaggedSymbol) }
+          attr_accessor :currency
+
+          sig { returns(String) }
+          attr_accessor :customer_id
+
+          sig do
+            returns(
+              Dodopayments::Customers::Wallets::CustomerWalletTransaction::EventType::TaggedSymbol
+            )
+          end
+          attr_accessor :event_type
+
+          sig { returns(T::Boolean) }
+          attr_accessor :is_credit
+
+          sig { returns(T.nilable(String)) }
+          attr_accessor :reason
+
+          sig { returns(T.nilable(String)) }
+          attr_accessor :reference_object_id
+
+          sig do
+            params(
+              id: String,
+              after_balance: Integer,
+              amount: Integer,
+              before_balance: Integer,
+              business_id: String,
+              created_at: Time,
+              currency: Dodopayments::Currency::OrSymbol,
+              customer_id: String,
+              event_type:
+                Dodopayments::Customers::Wallets::CustomerWalletTransaction::EventType::OrSymbol,
+              is_credit: T::Boolean,
+              reason: T.nilable(String),
+              reference_object_id: T.nilable(String)
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            id:,
+            after_balance:,
+            amount:,
+            before_balance:,
+            business_id:,
+            created_at:,
+            currency:,
+            customer_id:,
+            event_type:,
+            is_credit:,
+            reason: nil,
+            reference_object_id: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                after_balance: Integer,
+                amount: Integer,
+                before_balance: Integer,
+                business_id: String,
+                created_at: Time,
+                currency: Dodopayments::Currency::TaggedSymbol,
+                customer_id: String,
+                event_type:
+                  Dodopayments::Customers::Wallets::CustomerWalletTransaction::EventType::TaggedSymbol,
+                is_credit: T::Boolean,
+                reason: T.nilable(String),
+                reference_object_id: T.nilable(String)
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module EventType
+            extend Dodopayments::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Dodopayments::Customers::Wallets::CustomerWalletTransaction::EventType
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            PAYMENT =
+              T.let(
+                :payment,
+                Dodopayments::Customers::Wallets::CustomerWalletTransaction::EventType::TaggedSymbol
+              )
+            PAYMENT_REVERSAL =
+              T.let(
+                :payment_reversal,
+                Dodopayments::Customers::Wallets::CustomerWalletTransaction::EventType::TaggedSymbol
+              )
+            REFUND =
+              T.let(
+                :refund,
+                Dodopayments::Customers::Wallets::CustomerWalletTransaction::EventType::TaggedSymbol
+              )
+            REFUND_REVERSAL =
+              T.let(
+                :refund_reversal,
+                Dodopayments::Customers::Wallets::CustomerWalletTransaction::EventType::TaggedSymbol
+              )
+            DISPUTE =
+              T.let(
+                :dispute,
+                Dodopayments::Customers::Wallets::CustomerWalletTransaction::EventType::TaggedSymbol
+              )
+            DISPUTE_REVERSAL =
+              T.let(
+                :dispute_reversal,
+                Dodopayments::Customers::Wallets::CustomerWalletTransaction::EventType::TaggedSymbol
+              )
+            MERCHANT_ADJUSTMENT =
+              T.let(
+                :merchant_adjustment,
+                Dodopayments::Customers::Wallets::CustomerWalletTransaction::EventType::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Dodopayments::Customers::Wallets::CustomerWalletTransaction::EventType::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/customers/wallets/ledger_entry_create_params.rbi

@@ -0,0 +1,119 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    module Customers
+      module Wallets
+        class LedgerEntryCreateParams < Dodopayments::Internal::Type::BaseModel
+          extend Dodopayments::Internal::Type::RequestParameters::Converter
+          include Dodopayments::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Dodopayments::Customers::Wallets::LedgerEntryCreateParams,
+                Dodopayments::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Integer) }
+          attr_accessor :amount
+
+          # Currency of the wallet to adjust
+          sig { returns(Dodopayments::Currency::OrSymbol) }
+          attr_accessor :currency
+
+          # Type of ledger entry - credit or debit
+          sig do
+            returns(
+              Dodopayments::Customers::Wallets::LedgerEntryCreateParams::EntryType::OrSymbol
+            )
+          end
+          attr_accessor :entry_type
+
+          # Optional idempotency key to prevent duplicate entries
+          sig { returns(T.nilable(String)) }
+          attr_accessor :idempotency_key
+
+          sig { returns(T.nilable(String)) }
+          attr_accessor :reason
+
+          sig do
+            params(
+              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(T.attached_class)
+          end
+          def self.new(
+            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
+            override.returns(
+              {
+                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
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # Type of ledger entry - credit or debit
+          module EntryType
+            extend Dodopayments::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Dodopayments::Customers::Wallets::LedgerEntryCreateParams::EntryType
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            CREDIT =
+              T.let(
+                :credit,
+                Dodopayments::Customers::Wallets::LedgerEntryCreateParams::EntryType::TaggedSymbol
+              )
+            DEBIT =
+              T.let(
+                :debit,
+                Dodopayments::Customers::Wallets::LedgerEntryCreateParams::EntryType::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Dodopayments::Customers::Wallets::LedgerEntryCreateParams::EntryType::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/customers/wallets/ledger_entry_list_params.rbi

@@ -0,0 +1,71 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    module Customers
+      module Wallets
+        class LedgerEntryListParams < Dodopayments::Internal::Type::BaseModel
+          extend Dodopayments::Internal::Type::RequestParameters::Converter
+          include Dodopayments::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Dodopayments::Customers::Wallets::LedgerEntryListParams,
+                Dodopayments::Internal::AnyHash
+              )
+            end
+
+          # Optional currency filter
+          sig { returns(T.nilable(Dodopayments::Currency::OrSymbol)) }
+          attr_reader :currency
+
+          sig { params(currency: Dodopayments::Currency::OrSymbol).void }
+          attr_writer :currency
+
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :page_number
+
+          sig { params(page_number: Integer).void }
+          attr_writer :page_number
+
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :page_size
+
+          sig { params(page_size: Integer).void }
+          attr_writer :page_size
+
+          sig do
+            params(
+              currency: Dodopayments::Currency::OrSymbol,
+              page_number: Integer,
+              page_size: Integer,
+              request_options: Dodopayments::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Optional currency filter
+            currency: nil,
+            page_number: nil,
+            page_size: nil,
+            request_options: {}
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                currency: Dodopayments::Currency::OrSymbol,
+                page_number: Integer,
+                page_size: Integer,
+                request_options: Dodopayments::RequestOptions
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/license_activate_response.rbi

@@ -0,0 +1,140 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class LicenseActivateResponse < Dodopayments::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::Models::LicenseActivateResponse,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      # License key instance ID
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Business ID
+      sig { returns(String) }
+      attr_accessor :business_id
+
+      # Creation timestamp
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # Limited customer details associated with the license key.
+      sig { returns(Dodopayments::CustomerLimitedDetails) }
+      attr_reader :customer
+
+      sig do
+        params(customer: Dodopayments::CustomerLimitedDetails::OrHash).void
+      end
+      attr_writer :customer
+
+      # Associated license key ID
+      sig { returns(String) }
+      attr_accessor :license_key_id
+
+      # Instance name
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Related product info. Present if the license key is tied to a product.
+      sig { returns(Dodopayments::Models::LicenseActivateResponse::Product) }
+      attr_reader :product
+
+      sig do
+        params(
+          product:
+            Dodopayments::Models::LicenseActivateResponse::Product::OrHash
+        ).void
+      end
+      attr_writer :product
+
+      sig do
+        params(
+          id: String,
+          business_id: String,
+          created_at: Time,
+          customer: Dodopayments::CustomerLimitedDetails::OrHash,
+          license_key_id: String,
+          name: String,
+          product:
+            Dodopayments::Models::LicenseActivateResponse::Product::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # License key instance ID
+        id:,
+        # Business ID
+        business_id:,
+        # Creation timestamp
+        created_at:,
+        # Limited customer details associated with the license key.
+        customer:,
+        # Associated license key ID
+        license_key_id:,
+        # Instance name
+        name:,
+        # Related product info. Present if the license key is tied to a product.
+        product:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            business_id: String,
+            created_at: Time,
+            customer: Dodopayments::CustomerLimitedDetails,
+            license_key_id: String,
+            name: String,
+            product: Dodopayments::Models::LicenseActivateResponse::Product
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Product < Dodopayments::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Dodopayments::Models::LicenseActivateResponse::Product,
+              Dodopayments::Internal::AnyHash
+            )
+          end
+
+        # Unique identifier for the product.
+        sig { returns(String) }
+        attr_accessor :product_id
+
+        # Name of the product, if set by the merchant.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :name
+
+        # Related product info. Present if the license key is tied to a product.
+        sig do
+          params(product_id: String, name: T.nilable(String)).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # Unique identifier for the product.
+          product_id:,
+          # Name of the product, if set by the merchant.
+          name: nil
+        )
+        end
+
+        sig do
+          override.returns({ product_id: String, name: T.nilable(String) })
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/meter_aggregation.rbi

@@ -52,11 +52,6 @@ module Dodopayments
         COUNT =
           T.let(:count, Dodopayments::MeterAggregation::Type::TaggedSymbol)
         SUM = T.let(:sum, Dodopayments::MeterAggregation::Type::TaggedSymbol)
-        UNIQUE_COUNT =
-          T.let(
-            :unique_count,
-            Dodopayments::MeterAggregation::Type::TaggedSymbol
-          )
         MAX = T.let(:max, Dodopayments::MeterAggregation::Type::TaggedSymbol)
         LAST = T.let(:last, Dodopayments::MeterAggregation::Type::TaggedSymbol)
 

data/rbi/dodopayments/models/payment.rbi

@@ -57,7 +57,7 @@ module Dodopayments
       attr_accessor :payment_id
 
       # List of refunds issued for this payment
-      sig { returns(T::Array[Dodopayments::Refund]) }
+      sig { returns(T::Array[Dodopayments::Payment::Refund]) }
       attr_accessor :refunds
 
       # The amount that will be credited to your Dodo balance after currency conversion
@@ -93,6 +93,11 @@ module Dodopayments
       sig { returns(T.nilable(String)) }
       attr_accessor :card_type
 
+      # If payment is made using a checkout session, this field is set to the id of the
+      # session.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :checkout_session_id
+
       # The discount id if discount is applied
       sig { returns(T.nilable(String)) }
       attr_accessor :discount_id
@@ -155,7 +160,7 @@ module Dodopayments
           disputes: T::Array[Dodopayments::Dispute::OrHash],
           metadata: T::Hash[Symbol, String],
           payment_id: String,
-          refunds: T::Array[Dodopayments::Refund::OrHash],
+          refunds: T::Array[Dodopayments::Payment::Refund::OrHash],
           settlement_amount: Integer,
           settlement_currency: Dodopayments::Currency::OrSymbol,
           total_amount: Integer,
@@ -163,6 +168,7 @@ module Dodopayments
           card_last_four: T.nilable(String),
           card_network: T.nilable(String),
           card_type: T.nilable(String),
+          checkout_session_id: T.nilable(String),
           discount_id: T.nilable(String),
           error_code: T.nilable(String),
           error_message: T.nilable(String),
@@ -220,6 +226,9 @@ module Dodopayments
         card_network: nil,
         # The type of card DEBIT or CREDIT
         card_type: nil,
+        # If payment is made using a checkout session, this field is set to the id of the
+        # session.
+        checkout_session_id: nil,
         # The discount id if discount is applied
         discount_id: nil,
         # An error code if the payment failed
@@ -262,7 +271,7 @@ module Dodopayments
             disputes: T::Array[Dodopayments::Dispute],
             metadata: T::Hash[Symbol, String],
             payment_id: String,
-            refunds: T::Array[Dodopayments::Refund],
+            refunds: T::Array[Dodopayments::Payment::Refund],
             settlement_amount: Integer,
             settlement_currency: Dodopayments::Currency::TaggedSymbol,
             total_amount: Integer,
@@ -271,6 +280,7 @@ module Dodopayments
             card_last_four: T.nilable(String),
             card_network: T.nilable(String),
             card_type: T.nilable(String),
+            checkout_session_id: T.nilable(String),
             discount_id: T.nilable(String),
             error_code: T.nilable(String),
             error_message: T.nilable(String),
@@ -290,6 +300,105 @@ module Dodopayments
       def to_hash
       end
 
+      class Refund < Dodopayments::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Dodopayments::Payment::Refund,
+              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
+
       class ProductCart < Dodopayments::Internal::Type::BaseModel
         OrHash =
           T.type_alias do