dodopayments 1.52.5 → 1.53.2

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/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
@@ -160,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,
@@ -271,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,
@@ -300,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

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