dodopayments 2.25.0 → 2.27.0

data/rbi/dodopayments/models/blocklist/customers/note_update_params.rbi

@@ -0,0 +1,50 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    module Blocklist
+      module Customers
+        class NoteUpdateParams < Dodopayments::Models::Blocklist::Customers::NoteRequest
+          extend Dodopayments::Internal::Type::RequestParameters::Converter
+          include Dodopayments::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Dodopayments::Blocklist::Customers::NoteUpdateParams,
+                Dodopayments::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :entry_id
+
+          sig { returns(String) }
+          attr_accessor :note_id
+
+          sig do
+            params(
+              entry_id: String,
+              note_id: String,
+              request_options: Dodopayments::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(entry_id:, note_id:, request_options: {})
+          end
+
+          sig do
+            override.returns(
+              {
+                entry_id: String,
+                note_id: String,
+                request_options: Dodopayments::RequestOptions
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/customer.rbi

@@ -23,6 +23,16 @@ module Dodopayments
       sig { returns(String) }
       attr_accessor :name
 
+      # When the merchant blocked this customer. The dashboard shows the "Blocked" badge
+      # and the unblock action from it. The list route leaves it empty; only the
+      # single-customer route resolves it.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :blocked_at
+
+      # Blocklist entry behind `blocked_at`, so the dashboard can link to it.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :blocklist_entry_id
+
       # Additional metadata for the customer
       sig do
         returns(
@@ -48,6 +58,8 @@ module Dodopayments
           customer_id: String,
           email: String,
           name: String,
+          blocked_at: T.nilable(Time),
+          blocklist_entry_id: T.nilable(String),
           metadata: T::Hash[Symbol, Dodopayments::MetadataItem::Variants],
           phone_number: T.nilable(String)
         ).returns(T.attached_class)
@@ -58,6 +70,12 @@ module Dodopayments
         customer_id:,
         email:,
         name:,
+        # When the merchant blocked this customer. The dashboard shows the "Blocked" badge
+        # and the unblock action from it. The list route leaves it empty; only the
+        # single-customer route resolves it.
+        blocked_at: nil,
+        # Blocklist entry behind `blocked_at`, so the dashboard can link to it.
+        blocklist_entry_id: nil,
         # Additional metadata for the customer
         metadata: nil,
         phone_number: nil
@@ -72,6 +90,8 @@ module Dodopayments
             customer_id: String,
             email: String,
             name: String,
+            blocked_at: T.nilable(Time),
+            blocklist_entry_id: T.nilable(String),
             metadata: T::Hash[Symbol, Dodopayments::MetadataItem::Variants],
             phone_number: T.nilable(String)
           }

data/rbi/dodopayments/models/dunning_recovered_webhook_event.rbi

@@ -211,6 +211,11 @@ module Dodopayments
               :cancelled,
               Dodopayments::DunningRecoveredWebhookEvent::Data::TriggerState::TaggedSymbol
             )
+          PAST_DUE =
+            T.let(
+              :past_due,
+              Dodopayments::DunningRecoveredWebhookEvent::Data::TriggerState::TaggedSymbol
+            )
 
           sig do
             override.returns(

data/rbi/dodopayments/models/dunning_started_webhook_event.rbi

@@ -211,6 +211,11 @@ module Dodopayments
               :cancelled,
               Dodopayments::DunningStartedWebhookEvent::Data::TriggerState::TaggedSymbol
             )
+          PAST_DUE =
+            T.let(
+              :past_due,
+              Dodopayments::DunningStartedWebhookEvent::Data::TriggerState::TaggedSymbol
+            )
 
           sig do
             override.returns(

data/rbi/dodopayments/models/entitlements/license_key_grant.rbi

@@ -12,7 +12,12 @@ module Dodopayments
             )
           end
 
-        # Number of activations consumed so far.
+        # Identifier of the issued license key.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # Number of instances currently active. Activation increments it and deactivation
+        # decrements it, so it is a live count and not a total.
         sig { returns(Integer) }
         attr_accessor :activations_used
 
@@ -20,6 +25,11 @@ module Dodopayments
         sig { returns(String) }
         attr_accessor :key
 
+        # Current status of the license key. Activation fails unless it is `active`, so a
+        # client can warn before the customer tries.
+        sig { returns(Dodopayments::LicenseKeyStatus::TaggedSymbol) }
+        attr_accessor :status
+
         # Maximum activations allowed by the entitlement, when set.
         sig { returns(T.nilable(Integer)) }
         attr_accessor :activations_limit
@@ -32,17 +42,25 @@ module Dodopayments
         # The grant's top-level `status` is the source of truth for the grant's lifecycle.
         sig do
           params(
+            id: String,
             activations_used: Integer,
             key: String,
+            status: Dodopayments::LicenseKeyStatus::OrSymbol,
             activations_limit: T.nilable(Integer),
             expires_at: T.nilable(Time)
           ).returns(T.attached_class)
         end
         def self.new(
-          # Number of activations consumed so far.
+          # Identifier of the issued license key.
+          id:,
+          # Number of instances currently active. Activation increments it and deactivation
+          # decrements it, so it is a live count and not a total.
           activations_used:,
           # Issued license key.
           key:,
+          # Current status of the license key. Activation fails unless it is `active`, so a
+          # client can warn before the customer tries.
+          status:,
           # Maximum activations allowed by the entitlement, when set.
           activations_limit: nil,
           # When the license key expires, when applicable.
@@ -53,8 +71,10 @@ module Dodopayments
         sig do
           override.returns(
             {
+              id: String,
               activations_used: Integer,
               key: String,
+              status: Dodopayments::LicenseKeyStatus::TaggedSymbol,
               activations_limit: T.nilable(Integer),
               expires_at: T.nilable(Time)
             }

data/rbi/dodopayments/models/manual_retry.rbi

@@ -0,0 +1,93 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class ManualRetry < Dodopayments::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Dodopayments::ManualRetry, Dodopayments::Internal::AnyHash)
+        end
+
+      # The invoice the send charged.
+      sig { returns(String) }
+      attr_accessor :invoice_id
+
+      # Always true on this route. Tells the row apart from an automatic attempt.
+      sig { returns(T::Boolean) }
+      attr_accessor :is_manual_retry
+
+      # The payment row this send created.
+      sig { returns(String) }
+      attr_accessor :payment_id
+
+      # Which attempt this send is, counting manual sends on the invoice.
+      sig { returns(Integer) }
+      attr_accessor :retry_attempt
+
+      sig { returns(Integer) }
+      attr_accessor :sends_allowed
+
+      # Manual sends spent on this invoice, including this one.
+      sig { returns(Integer) }
+      attr_accessor :sends_used
+
+      # When the next send becomes available. Null when no send is left.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :retry_available_at
+
+      # Outcome of the charge. `processing` means the processor has not settled it yet,
+      # and the payment webhooks report the result.
+      sig { returns(T.nilable(Dodopayments::IntentStatus::TaggedSymbol)) }
+      attr_accessor :status
+
+      sig do
+        params(
+          invoice_id: String,
+          is_manual_retry: T::Boolean,
+          payment_id: String,
+          retry_attempt: Integer,
+          sends_allowed: Integer,
+          sends_used: Integer,
+          retry_available_at: T.nilable(Time),
+          status: T.nilable(Dodopayments::IntentStatus::OrSymbol)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The invoice the send charged.
+        invoice_id:,
+        # Always true on this route. Tells the row apart from an automatic attempt.
+        is_manual_retry:,
+        # The payment row this send created.
+        payment_id:,
+        # Which attempt this send is, counting manual sends on the invoice.
+        retry_attempt:,
+        sends_allowed:,
+        # Manual sends spent on this invoice, including this one.
+        sends_used:,
+        # When the next send becomes available. Null when no send is left.
+        retry_available_at: nil,
+        # Outcome of the charge. `processing` means the processor has not settled it yet,
+        # and the payment webhooks report the result.
+        status: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            invoice_id: String,
+            is_manual_retry: T::Boolean,
+            payment_id: String,
+            retry_attempt: Integer,
+            sends_allowed: Integer,
+            sends_used: Integer,
+            retry_available_at: T.nilable(Time),
+            status: T.nilable(Dodopayments::IntentStatus::TaggedSymbol)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/manual_retry_state.rbi

@@ -0,0 +1,65 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class ManualRetryState < Dodopayments::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Dodopayments::ManualRetryState, Dodopayments::Internal::AnyHash)
+        end
+
+      sig { returns(T::Boolean) }
+      attr_accessor :can_retry
+
+      sig { returns(Integer) }
+      attr_accessor :sends_allowed
+
+      sig { returns(Integer) }
+      attr_accessor :sends_used
+
+      # The code `POST` would fail with. Null when `can_retry` is true.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :reason
+
+      # When the next send becomes available. Null when no send is left, or when the
+      # block has nothing to do with the cooldown.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :retry_available_at
+
+      sig do
+        params(
+          can_retry: T::Boolean,
+          sends_allowed: Integer,
+          sends_used: Integer,
+          reason: T.nilable(String),
+          retry_available_at: T.nilable(Time)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        can_retry:,
+        sends_allowed:,
+        sends_used:,
+        # The code `POST` would fail with. Null when `can_retry` is true.
+        reason: nil,
+        # When the next send becomes available. Null when no send is left, or when the
+        # block has nothing to do with the cooldown.
+        retry_available_at: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            can_retry: T::Boolean,
+            sends_allowed: Integer,
+            sends_used: Integer,
+            reason: T.nilable(String),
+            retry_available_at: T.nilable(Time)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/payment_retrieve_retry_state_params.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class PaymentRetrieveRetryStateParams < Dodopayments::Internal::Type::BaseModel
+      extend Dodopayments::Internal::Type::RequestParameters::Converter
+      include Dodopayments::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::PaymentRetrieveRetryStateParams,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :payment_id
+
+      sig do
+        params(
+          payment_id: String,
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(payment_id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { payment_id: String, request_options: Dodopayments::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/payment_retry_params.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class PaymentRetryParams < Dodopayments::Internal::Type::BaseModel
+      extend Dodopayments::Internal::Type::RequestParameters::Converter
+      include Dodopayments::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::PaymentRetryParams,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :payment_id
+
+      sig do
+        params(
+          payment_id: String,
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(payment_id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { payment_id: String, request_options: Dodopayments::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/price.rbi

@@ -40,11 +40,6 @@ module Dodopayments
         sig { returns(Integer) }
         attr_accessor :price
 
-        # Indicates if purchasing power parity adjustments are applied to the price.
-        # Purchasing power parity feature is not available as of now.
-        sig { returns(T::Boolean) }
-        attr_accessor :purchasing_power_parity
-
         sig { returns(Symbol) }
         attr_accessor :type
 
@@ -56,6 +51,15 @@ module Dodopayments
         sig { params(pay_what_you_want: T::Boolean).void }
         attr_writer :pay_what_you_want
 
+        # Opts this price in to purchasing power parity. The business must also enable
+        # purchasing power parity. The discount percentage per country is always
+        # business-wide. Defaults to `false`.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :purchasing_power_parity
+
+        sig { params(purchasing_power_parity: T::Boolean).void }
+        attr_writer :purchasing_power_parity
+
         # A suggested price for the user to pay. This value is only considered if
         # [`pay_what_you_want`](Self::pay_what_you_want) is `true`. Otherwise, it is
         # ignored.
@@ -72,8 +76,8 @@ module Dodopayments
             currency: Dodopayments::Currency::OrSymbol,
             discount: Integer,
             price: Integer,
-            purchasing_power_parity: T::Boolean,
             pay_what_you_want: T::Boolean,
+            purchasing_power_parity: T::Boolean,
             suggested_price: T.nilable(Integer),
             tax_inclusive: T.nilable(T::Boolean),
             type: Symbol
@@ -90,12 +94,13 @@ module Dodopayments
           # If [`pay_what_you_want`](Self::pay_what_you_want) is set to `true`, this field
           # represents the **minimum** amount the customer must pay.
           price:,
-          # Indicates if purchasing power parity adjustments are applied to the price.
-          # Purchasing power parity feature is not available as of now.
-          purchasing_power_parity:,
           # Indicates whether the customer can pay any amount they choose. If set to `true`,
           # the [`price`](Self::price) field is the minimum amount.
           pay_what_you_want: nil,
+          # Opts this price in to purchasing power parity. The business must also enable
+          # purchasing power parity. The discount percentage per country is always
+          # business-wide. Defaults to `false`.
+          purchasing_power_parity: nil,
           # A suggested price for the user to pay. This value is only considered if
           # [`pay_what_you_want`](Self::pay_what_you_want) is `true`. Otherwise, it is
           # ignored.
@@ -112,9 +117,9 @@ module Dodopayments
               currency: Dodopayments::Currency::OrSymbol,
               discount: Integer,
               price: Integer,
-              purchasing_power_parity: T::Boolean,
               type: Symbol,
               pay_what_you_want: T::Boolean,
+              purchasing_power_parity: T::Boolean,
               suggested_price: T.nilable(Integer),
               tax_inclusive: T.nilable(T::Boolean)
             }
@@ -155,11 +160,6 @@ module Dodopayments
         sig { returns(Integer) }
         attr_accessor :price
 
-        # Indicates if purchasing power parity adjustments are applied to the price.
-        # Purchasing power parity feature is not available as of now
-        sig { returns(T::Boolean) }
-        attr_accessor :purchasing_power_parity
-
         # Number of units for the subscription period. For example, a value of `12` with a
         # `subscription_period_interval` of `month` represents a one-year subscription.
         sig { returns(Integer) }
@@ -172,6 +172,15 @@ module Dodopayments
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # Opts this price in to purchasing power parity. The business must also enable
+        # purchasing power parity. The discount percentage per country is always
+        # business-wide. Defaults to `false`.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :purchasing_power_parity
+
+        sig { params(purchasing_power_parity: T::Boolean).void }
+        attr_writer :purchasing_power_parity
+
         # Indicates if the price is tax inclusive
         sig { returns(T.nilable(T::Boolean)) }
         attr_accessor :tax_inclusive
@@ -201,9 +210,9 @@ module Dodopayments
             payment_frequency_count: Integer,
             payment_frequency_interval: Dodopayments::TimeInterval::OrSymbol,
             price: Integer,
-            purchasing_power_parity: T::Boolean,
             subscription_period_count: Integer,
             subscription_period_interval: Dodopayments::TimeInterval::OrSymbol,
+            purchasing_power_parity: T::Boolean,
             tax_inclusive: T.nilable(T::Boolean),
             trial_amount: T.nilable(Integer),
             trial_apply_discounts: T.nilable(T::Boolean),
@@ -224,14 +233,15 @@ module Dodopayments
           # The payment amount. Represented in the lowest denomination of the currency
           # (e.g., cents for USD). For example, to charge $1.00, pass `100`.
           price:,
-          # Indicates if purchasing power parity adjustments are applied to the price.
-          # Purchasing power parity feature is not available as of now
-          purchasing_power_parity:,
           # Number of units for the subscription period. For example, a value of `12` with a
           # `subscription_period_interval` of `month` represents a one-year subscription.
           subscription_period_count:,
           # The time interval for the subscription period (e.g., day, month, year).
           subscription_period_interval:,
+          # Opts this price in to purchasing power parity. The business must also enable
+          # purchasing power parity. The discount percentage per country is always
+          # business-wide. Defaults to `false`.
+          purchasing_power_parity: nil,
           # Indicates if the price is tax inclusive
           tax_inclusive: nil,
           # Amount charged today for a paid trial, in the price currency's minor units.
@@ -254,11 +264,11 @@ module Dodopayments
               payment_frequency_count: Integer,
               payment_frequency_interval: Dodopayments::TimeInterval::OrSymbol,
               price: Integer,
-              purchasing_power_parity: T::Boolean,
               subscription_period_count: Integer,
               subscription_period_interval:
                 Dodopayments::TimeInterval::OrSymbol,
               type: Symbol,
+              purchasing_power_parity: T::Boolean,
               tax_inclusive: T.nilable(T::Boolean),
               trial_amount: T.nilable(Integer),
               trial_apply_discounts: T.nilable(T::Boolean),
@@ -301,11 +311,6 @@ module Dodopayments
         sig { returns(Dodopayments::TimeInterval::OrSymbol) }
         attr_accessor :payment_frequency_interval
 
-        # Indicates if purchasing power parity adjustments are applied to the price.
-        # Purchasing power parity feature is not available as of now
-        sig { returns(T::Boolean) }
-        attr_accessor :purchasing_power_parity
-
         # Number of units for the subscription period. For example, a value of `12` with a
         # `subscription_period_interval` of `month` represents a one-year subscription.
         sig { returns(Integer) }
@@ -321,6 +326,16 @@ module Dodopayments
         sig { returns(T.nilable(T::Array[Dodopayments::AddMeterToPrice])) }
         attr_accessor :meters
 
+        # Opts this price in to purchasing power parity. The business must also enable
+        # purchasing power parity. The discount percentage per country is always
+        # business-wide. Applies to the fixed fee only, never to metered usage. Defaults
+        # to `false`.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :purchasing_power_parity
+
+        sig { params(purchasing_power_parity: T::Boolean).void }
+        attr_writer :purchasing_power_parity
+
         # Indicates if the price is tax inclusive
         sig { returns(T.nilable(T::Boolean)) }
         attr_accessor :tax_inclusive
@@ -333,10 +348,10 @@ module Dodopayments
             fixed_price: Integer,
             payment_frequency_count: Integer,
             payment_frequency_interval: Dodopayments::TimeInterval::OrSymbol,
-            purchasing_power_parity: T::Boolean,
             subscription_period_count: Integer,
             subscription_period_interval: Dodopayments::TimeInterval::OrSymbol,
             meters: T.nilable(T::Array[Dodopayments::AddMeterToPrice::OrHash]),
+            purchasing_power_parity: T::Boolean,
             tax_inclusive: T.nilable(T::Boolean),
             type: Symbol
           ).returns(T.attached_class)
@@ -354,15 +369,17 @@ module Dodopayments
           payment_frequency_count:,
           # The time interval for the payment frequency (e.g., day, month, year).
           payment_frequency_interval:,
-          # Indicates if purchasing power parity adjustments are applied to the price.
-          # Purchasing power parity feature is not available as of now
-          purchasing_power_parity:,
           # Number of units for the subscription period. For example, a value of `12` with a
           # `subscription_period_interval` of `month` represents a one-year subscription.
           subscription_period_count:,
           # The time interval for the subscription period (e.g., day, month, year).
           subscription_period_interval:,
           meters: nil,
+          # Opts this price in to purchasing power parity. The business must also enable
+          # purchasing power parity. The discount percentage per country is always
+          # business-wide. Applies to the fixed fee only, never to metered usage. Defaults
+          # to `false`.
+          purchasing_power_parity: nil,
           # Indicates if the price is tax inclusive
           tax_inclusive: nil,
           type: :usage_based_price
@@ -377,12 +394,12 @@ module Dodopayments
               fixed_price: Integer,
               payment_frequency_count: Integer,
               payment_frequency_interval: Dodopayments::TimeInterval::OrSymbol,
-              purchasing_power_parity: T::Boolean,
               subscription_period_count: Integer,
               subscription_period_interval:
                 Dodopayments::TimeInterval::OrSymbol,
               type: Symbol,
               meters: T.nilable(T::Array[Dodopayments::AddMeterToPrice]),
+              purchasing_power_parity: T::Boolean,
               tax_inclusive: T.nilable(T::Boolean)
             }
           )