dodopayments 2.26.0 → 2.28.0

data/rbi/dodopayments/models/customers/email_policies.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    module Customers
+      class EmailPolicies < Dodopayments::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Dodopayments::Customers::EmailPolicies,
+              Dodopayments::Internal::AnyHash
+            )
+          end
+
+        # A permanent failure was recorded, so the same address would be a no-op.
+        sig { returns(T::Boolean) }
+        attr_accessor :requires_different_address
+
+        # The row was delivered and may be sent again.
+        sig { returns(T::Boolean) }
+        attr_accessor :resend_allowed
+
+        # How many sends are left in this email's chain.
+        sig { returns(Integer) }
+        attr_accessor :resends_remaining
+
+        # The row failed and may be sent again.
+        sig { returns(T::Boolean) }
+        attr_accessor :retry_allowed
+
+        # What the merchant may do with one row. The server decides; the client never
+        # derives eligibility itself.
+        sig do
+          params(
+            requires_different_address: T::Boolean,
+            resend_allowed: T::Boolean,
+            resends_remaining: Integer,
+            retry_allowed: T::Boolean
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A permanent failure was recorded, so the same address would be a no-op.
+          requires_different_address:,
+          # The row was delivered and may be sent again.
+          resend_allowed:,
+          # How many sends are left in this email's chain.
+          resends_remaining:,
+          # The row failed and may be sent again.
+          retry_allowed:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              requires_different_address: T::Boolean,
+              resend_allowed: T::Boolean,
+              resends_remaining: Integer,
+              retry_allowed: T::Boolean
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/customers/email_retrieve_body_params.rbi

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

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/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