dodopayments 2.29.0 → 2.31.0

data/rbi/dodopayments/models/moderation_screen_response.rbi

@@ -0,0 +1,135 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class ModerationScreenResponse < Dodopayments::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::Models::ModerationScreenResponse,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      # The probability, from 0 to 1, that the screen falls in each category.
+      sig { returns(Dodopayments::ModerationCategoryScores) }
+      attr_reader :categories
+
+      sig do
+        params(categories: Dodopayments::ModerationCategoryScores::OrHash).void
+      end
+      attr_writer :categories
+
+      # True when real-person likeness and sexual content together crossed their
+      # combined threshold, the pattern of a sexual deepfake.
+      sig { returns(T::Boolean) }
+      attr_accessor :compound_triggered
+
+      # The verdict. `allow` means the content passed. `deny` means block the content.
+      # `flag` means apply your own judgement. It is not a soft deny.
+      sig { returns(Dodopayments::ModerationDecision::TaggedSymbol) }
+      attr_accessor :decision
+
+      # The time the screen took, in milliseconds.
+      sig { returns(Integer) }
+      attr_accessor :latency_ms
+
+      # True when the text was also screened in a normalized form, with obfuscation such
+      # as invisible or look-alike characters removed.
+      sig { returns(T::Boolean) }
+      attr_accessor :normalized_applied
+
+      # Human-readable reasons for the decision. The wording can change, so do not parse
+      # it.
+      sig { returns(T::Array[String]) }
+      attr_accessor :notes
+
+      # The number of yes/no questions the model answered for this screen.
+      sig { returns(Integer) }
+      attr_accessor :passes
+
+      # How each score in `categories` was measured.
+      sig { returns(Dodopayments::ModerationCategoryProvenance) }
+      attr_reader :provenance
+
+      sig do
+        params(
+          provenance: Dodopayments::ModerationCategoryProvenance::OrHash
+        ).void
+      end
+      attr_writer :provenance
+
+      # The `request_id` you sent, or null.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :request_id
+
+      # The categories whose score crossed the threshold of the category. It can be
+      # empty on a `flag` from the general check. `notes` then gives the reason.
+      sig { returns(T::Array[Dodopayments::ModerationCategory::TaggedSymbol]) }
+      attr_accessor :triggered
+
+      # The verdict of one screen.
+      sig do
+        params(
+          categories: Dodopayments::ModerationCategoryScores::OrHash,
+          compound_triggered: T::Boolean,
+          decision: Dodopayments::ModerationDecision::OrSymbol,
+          latency_ms: Integer,
+          normalized_applied: T::Boolean,
+          notes: T::Array[String],
+          passes: Integer,
+          provenance: Dodopayments::ModerationCategoryProvenance::OrHash,
+          request_id: T.nilable(String),
+          triggered: T::Array[Dodopayments::ModerationCategory::OrSymbol]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The probability, from 0 to 1, that the screen falls in each category.
+        categories:,
+        # True when real-person likeness and sexual content together crossed their
+        # combined threshold, the pattern of a sexual deepfake.
+        compound_triggered:,
+        # The verdict. `allow` means the content passed. `deny` means block the content.
+        # `flag` means apply your own judgement. It is not a soft deny.
+        decision:,
+        # The time the screen took, in milliseconds.
+        latency_ms:,
+        # True when the text was also screened in a normalized form, with obfuscation such
+        # as invisible or look-alike characters removed.
+        normalized_applied:,
+        # Human-readable reasons for the decision. The wording can change, so do not parse
+        # it.
+        notes:,
+        # The number of yes/no questions the model answered for this screen.
+        passes:,
+        # How each score in `categories` was measured.
+        provenance:,
+        # The `request_id` you sent, or null.
+        request_id:,
+        # The categories whose score crossed the threshold of the category. It can be
+        # empty on a `flag` from the general check. `notes` then gives the reason.
+        triggered:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            categories: Dodopayments::ModerationCategoryScores,
+            compound_triggered: T::Boolean,
+            decision: Dodopayments::ModerationDecision::TaggedSymbol,
+            latency_ms: Integer,
+            normalized_applied: T::Boolean,
+            notes: T::Array[String],
+            passes: Integer,
+            provenance: Dodopayments::ModerationCategoryProvenance,
+            request_id: T.nilable(String),
+            triggered: T::Array[Dodopayments::ModerationCategory::TaggedSymbol]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/payment.rbi

@@ -48,6 +48,12 @@ module Dodopayments
       sig { returns(T::Array[Dodopayments::Dispute]) }
       attr_accessor :disputes
 
+      # True when one payment starts more than one subscription. Read this field to find
+      # the payment type. Do not read the length of `subscription_ids`. Do not read
+      # `subscription_id` for null.
+      sig { returns(T::Boolean) }
+      attr_accessor :is_multi_subscription
+
       # Whether this payment was created solely to update a subscription's payment
       # method (a zero-/setup-amount charge). `false` for normal charges.
       sig { returns(T::Boolean) }
@@ -88,6 +94,12 @@ module Dodopayments
       sig { returns(Dodopayments::Currency::TaggedSymbol) }
       attr_accessor :settlement_currency
 
+      # Every subscription that this payment starts or charges, in a stable order. It is
+      # empty for a one-time payment. It holds the value of `subscription_id` when the
+      # payment names one subscription.
+      sig { returns(T::Array[String]) }
+      attr_accessor :subscription_ids
+
       # Total amount charged to the customer including tax, in the currency's smallest
       # unit (e.g. cents for USD, yen for JPY, fils for KWD — see the currency's decimal
       # places)
@@ -186,7 +198,9 @@ module Dodopayments
       sig { returns(T.nilable(Dodopayments::IntentStatus::TaggedSymbol)) }
       attr_accessor :status
 
-      # Identifier of the subscription if payment is part of a subscription
+      # Identifier of the subscription if payment is part of a subscription. A
+      # multi-subscription payment leaves this null, because no single subscription owns
+      # the payment. Read `subscription_ids` for those.
       sig { returns(T.nilable(String)) }
       attr_accessor :subscription_id
 
@@ -209,6 +223,7 @@ module Dodopayments
           customer: Dodopayments::CustomerLimitedDetails::OrHash,
           digital_products_delivered: T::Boolean,
           disputes: T::Array[Dodopayments::Dispute::OrHash],
+          is_multi_subscription: T::Boolean,
           is_update_payment_method: T::Boolean,
           metadata: T::Hash[Symbol, Dodopayments::MetadataItem::Variants],
           payment_id: String,
@@ -217,6 +232,7 @@ module Dodopayments
           retry_attempt: Integer,
           settlement_amount: Integer,
           settlement_currency: Dodopayments::Currency::OrSymbol,
+          subscription_ids: T::Array[String],
           total_amount: Integer,
           card_holder_name: T.nilable(String),
           card_issuing_country: T.nilable(Dodopayments::CountryCode::OrSymbol),
@@ -263,6 +279,10 @@ module Dodopayments
         digital_products_delivered:,
         # List of disputes associated with this payment
         disputes:,
+        # True when one payment starts more than one subscription. Read this field to find
+        # the payment type. Do not read the length of `subscription_ids`. Do not read
+        # `subscription_id` for null.
+        is_multi_subscription:,
         # Whether this payment was created solely to update a subscription's payment
         # method (a zero-/setup-amount charge). `false` for normal charges.
         is_update_payment_method:,
@@ -287,6 +307,10 @@ module Dodopayments
         # balance. This may differ from the customer's payment currency in adaptive
         # pricing scenarios.
         settlement_currency:,
+        # Every subscription that this payment starts or charges, in a stable order. It is
+        # empty for a one-time payment. It holds the value of `subscription_id` when the
+        # payment names one subscription.
+        subscription_ids:,
         # Total amount charged to the customer including tax, in the currency's smallest
         # unit (e.g. cents for USD, yen for JPY, fils for KWD — see the currency's decimal
         # places)
@@ -339,7 +363,9 @@ module Dodopayments
         settlement_tax: nil,
         # Current status of the payment intent
         status: nil,
-        # Identifier of the subscription if payment is part of a subscription
+        # Identifier of the subscription if payment is part of a subscription. A
+        # multi-subscription payment leaves this null, because no single subscription owns
+        # the payment. Read `subscription_ids` for those.
         subscription_id: nil,
         # Amount of tax collected in the currency's smallest unit (e.g. cents for USD, yen
         # for JPY, fils for KWD)
@@ -360,6 +386,7 @@ module Dodopayments
             customer: Dodopayments::CustomerLimitedDetails,
             digital_products_delivered: T::Boolean,
             disputes: T::Array[Dodopayments::Dispute],
+            is_multi_subscription: T::Boolean,
             is_update_payment_method: T::Boolean,
             metadata: T::Hash[Symbol, Dodopayments::MetadataItem::Variants],
             payment_id: String,
@@ -369,6 +396,7 @@ module Dodopayments
             retry_attempt: Integer,
             settlement_amount: Integer,
             settlement_currency: Dodopayments::Currency::TaggedSymbol,
+            subscription_ids: T::Array[String],
             total_amount: Integer,
             card_holder_name: T.nilable(String),
             card_issuing_country:

data/rbi/dodopayments/models/payment_list_response.rbi

@@ -34,6 +34,12 @@ module Dodopayments
       sig { returns(T::Boolean) }
       attr_accessor :has_license_key
 
+      # True when one payment starts more than one subscription. Read this field to find
+      # the payment type. Do not read the length of `subscription_ids`. Do not read
+      # `subscription_id` for null.
+      sig { returns(T::Boolean) }
+      attr_accessor :is_multi_subscription
+
       # Arbitrary key-value metadata. Values can be string, integer, number, or boolean.
       sig { returns(T::Hash[Symbol, Dodopayments::MetadataItem::Variants]) }
       attr_accessor :metadata
@@ -50,6 +56,12 @@ module Dodopayments
       end
       attr_accessor :payment_provider
 
+      # Every subscription that this payment starts or charges, in a stable order. It is
+      # empty for a one-time payment. It holds the value of `subscription_id` when the
+      # payment names one subscription.
+      sig { returns(T::Array[String]) }
+      attr_accessor :subscription_ids
+
       sig { returns(Integer) }
       attr_accessor :total_amount
 
@@ -100,10 +112,12 @@ module Dodopayments
           customer: Dodopayments::CustomerLimitedDetails::OrHash,
           digital_products_delivered: T::Boolean,
           has_license_key: T::Boolean,
+          is_multi_subscription: T::Boolean,
           metadata: T::Hash[Symbol, Dodopayments::MetadataItem::Variants],
           payment_id: String,
           payment_provider:
             Dodopayments::Models::PaymentListResponse::PaymentProvider::OrSymbol,
+          subscription_ids: T::Array[String],
           total_amount: Integer,
           card_last_four: T.nilable(String),
           card_network: T.nilable(String),
@@ -124,12 +138,20 @@ module Dodopayments
         customer:,
         digital_products_delivered:,
         has_license_key:,
+        # True when one payment starts more than one subscription. Read this field to find
+        # the payment type. Do not read the length of `subscription_ids`. Do not read
+        # `subscription_id` for null.
+        is_multi_subscription:,
         # Arbitrary key-value metadata. Values can be string, integer, number, or boolean.
         metadata:,
         payment_id:,
         # Which processor handled this payment. `stripe` / `adyen` for BYOP routes (the
         # merchant's own payment connector); `dodo` for everything Dodo processed itself.
         payment_provider:,
+        # Every subscription that this payment starts or charges, in a stable order. It is
+        # empty for a one-time payment. It holds the value of `subscription_id` when the
+        # payment names one subscription.
+        subscription_ids:,
         total_amount:,
         # The last four digits of the card
         card_last_four: nil,
@@ -160,10 +182,12 @@ module Dodopayments
             customer: Dodopayments::CustomerLimitedDetails,
             digital_products_delivered: T::Boolean,
             has_license_key: T::Boolean,
+            is_multi_subscription: T::Boolean,
             metadata: T::Hash[Symbol, Dodopayments::MetadataItem::Variants],
             payment_id: String,
             payment_provider:
               Dodopayments::Models::PaymentListResponse::PaymentProvider::TaggedSymbol,
+            subscription_ids: T::Array[String],
             total_amount: Integer,
             card_last_four: T.nilable(String),
             card_network: T.nilable(String),

data/rbi/dodopayments/models/payouts/breakup/detail_list_response.rbi

@@ -36,8 +36,9 @@ module Dodopayments
           attr_accessor :original_currency
 
           # Amount in the payout's currency, in that currency's smallest unit (cents for
-          # USD, yen for JPY, fils for KWD). Uses cumulative rounding to ensure sum matches
-          # payout total exactly.
+          # USD, yen for JPY, fils for KWD). The entry is converted at the rate the payout
+          # settled at. These amounts sum to the value of the entries, which can be less
+          # than the payout: the grouped breakup reports the difference as `unattributed`.
           sig { returns(Integer) }
           attr_accessor :payout_currency_amount
 
@@ -53,8 +54,8 @@ module Dodopayments
           sig { returns(T.nilable(String)) }
           attr_accessor :reference_object_id
 
-          # Individual balance ledger entry for a payout, with amounts pro-rated into the
-          # payout's currency.
+          # Individual balance ledger entry for a payout, converted into the payout's
+          # currency.
           sig do
             params(
               id: String,
@@ -82,8 +83,9 @@ module Dodopayments
             # Original currency as ISO 4217 code (e.g., "USD", "EUR").
             original_currency:,
             # Amount in the payout's currency, in that currency's smallest unit (cents for
-            # USD, yen for JPY, fils for KWD). Uses cumulative rounding to ensure sum matches
-            # payout total exactly.
+            # USD, yen for JPY, fils for KWD). The entry is converted at the rate the payout
+            # settled at. These amounts sum to the value of the entries, which can be less
+            # than the payout: the grouped breakup reports the difference as `unattributed`.
             payout_currency_amount:,
             # USD equivalent of the original amount (in cents).
             usd_equivalent_amount:,

data/rbi/dodopayments/models/payouts/breakup_retrieve_response.rbi

@@ -13,7 +13,8 @@ module Dodopayments
           end
 
         # The type of balance ledger event (e.g., "payment", "refund", "dispute",
-        # "payment_fees").
+        # "payment_fees"), or `unattributed` for the payout amount the entries do not
+        # account for.
         sig { returns(String) }
         attr_accessor :event_type
 
@@ -23,12 +24,28 @@ module Dodopayments
         attr_accessor :total
 
         # Payout breakup aggregated by event type, with amounts in the payout's currency.
+        #
+        # The rows sum to the payout amount. The last row can be `unattributed`, which is
+        # not a ledger event type. It holds the payout amount less the entries that fund
+        # it, and it takes either sign:
+        #
+        # - Positive: the entries come to less than the payout, so the payout drew on the
+        #   balance an earlier cycle left over. A cycle of refunds and disputes produces a
+        #   large positive value.
+        # - Negative: the entries come to more than the payout, and the remainder funds a
+        #   later payout. This is the common case, for two reasons. The walk that claims
+        #   the entries stops at the first one that reaches its target, so it passes the
+        #   target by part of an entry. The target is also the gross debit, which holds
+        #   the payout fee, and the fee is not a line here.
+        #
+        # The row is absent when the two are equal.
         sig do
           params(event_type: String, total: Integer).returns(T.attached_class)
         end
         def self.new(
           # The type of balance ledger event (e.g., "payment", "refund", "dispute",
-          # "payment_fees").
+          # "payment_fees"), or `unattributed` for the payout amount the entries do not
+          # account for.
           event_type:,
           # Total amount for this event type in the payout's currency, in that currency's
           # smallest unit (cents for USD, yen for JPY, fils for KWD).

data/rbi/dodopayments/models/refund.rbi

@@ -57,6 +57,20 @@ module Dodopayments
       sig { returns(T.nilable(Dodopayments::Currency::TaggedSymbol)) }
       attr_accessor :currency
 
+      # The reference number that the card network or the bank gives to the refund. The
+      # customer can give this number to their bank to trace the refund. It is null
+      # until the payment processor sends it.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :network_reference
+
+      # The kind of `network_reference`: ARN, STAN or RRN.
+      sig do
+        returns(
+          T.nilable(Dodopayments::RefundNetworkReferenceType::TaggedSymbol)
+        )
+      end
+      attr_accessor :network_reference_type
+
       # The reason provided for the refund, if any. Optional.
       sig { returns(T.nilable(String)) }
       attr_accessor :reason
@@ -74,6 +88,9 @@ module Dodopayments
           status: Dodopayments::RefundStatus::OrSymbol,
           amount: T.nilable(Integer),
           currency: T.nilable(Dodopayments::Currency::OrSymbol),
+          network_reference: T.nilable(String),
+          network_reference_type:
+            T.nilable(Dodopayments::RefundNetworkReferenceType::OrSymbol),
           reason: T.nilable(String)
         ).returns(T.attached_class)
       end
@@ -100,6 +117,12 @@ module Dodopayments
         amount: nil,
         # The currency of the refund, represented as an ISO 4217 currency code.
         currency: nil,
+        # The reference number that the card network or the bank gives to the refund. The
+        # customer can give this number to their bank to trace the refund. It is null
+        # until the payment processor sends it.
+        network_reference: nil,
+        # The kind of `network_reference`: ARN, STAN or RRN.
+        network_reference_type: nil,
         # The reason provided for the refund, if any. Optional.
         reason: nil
       )
@@ -119,6 +142,9 @@ module Dodopayments
             status: Dodopayments::RefundStatus::TaggedSymbol,
             amount: T.nilable(Integer),
             currency: T.nilable(Dodopayments::Currency::TaggedSymbol),
+            network_reference: T.nilable(String),
+            network_reference_type:
+              T.nilable(Dodopayments::RefundNetworkReferenceType::TaggedSymbol),
             reason: T.nilable(String)
           }
         )

data/rbi/dodopayments/models/refund_list_item.rbi

@@ -40,6 +40,20 @@ module Dodopayments
       sig { returns(T.nilable(Dodopayments::Currency::TaggedSymbol)) }
       attr_accessor :currency
 
+      # The reference number that the card network or the bank gives to the refund. The
+      # customer can give this number to their bank to trace the refund. It is null
+      # until the payment processor sends it.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :network_reference
+
+      # The kind of `network_reference`: ARN, STAN or RRN.
+      sig do
+        returns(
+          T.nilable(Dodopayments::RefundNetworkReferenceType::TaggedSymbol)
+        )
+      end
+      attr_accessor :network_reference_type
+
       # The reason provided for the refund, if any. Optional.
       sig { returns(T.nilable(String)) }
       attr_accessor :reason
@@ -54,6 +68,9 @@ module Dodopayments
           status: Dodopayments::RefundStatus::OrSymbol,
           amount: T.nilable(Integer),
           currency: T.nilable(Dodopayments::Currency::OrSymbol),
+          network_reference: T.nilable(String),
+          network_reference_type:
+            T.nilable(Dodopayments::RefundNetworkReferenceType::OrSymbol),
           reason: T.nilable(String)
         ).returns(T.attached_class)
       end
@@ -74,6 +91,12 @@ module Dodopayments
         amount: nil,
         # The currency of the refund, represented as an ISO 4217 currency code.
         currency: nil,
+        # The reference number that the card network or the bank gives to the refund. The
+        # customer can give this number to their bank to trace the refund. It is null
+        # until the payment processor sends it.
+        network_reference: nil,
+        # The kind of `network_reference`: ARN, STAN or RRN.
+        network_reference_type: nil,
         # The reason provided for the refund, if any. Optional.
         reason: nil
       )
@@ -90,6 +113,9 @@ module Dodopayments
             status: Dodopayments::RefundStatus::TaggedSymbol,
             amount: T.nilable(Integer),
             currency: T.nilable(Dodopayments::Currency::TaggedSymbol),
+            network_reference: T.nilable(String),
+            network_reference_type:
+              T.nilable(Dodopayments::RefundNetworkReferenceType::TaggedSymbol),
             reason: T.nilable(String)
           }
         )

data/rbi/dodopayments/models/refund_network_reference_type.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    # The kind of reference number that the card network or the bank gives to a
+    # refund.
+    module RefundNetworkReferenceType
+      extend Dodopayments::Internal::Type::Enum
+
+      TaggedSymbol =
+        T.type_alias { T.all(Symbol, Dodopayments::RefundNetworkReferenceType) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      ACQUIRER_REFERENCE_NUMBER =
+        T.let(
+          :acquirer_reference_number,
+          Dodopayments::RefundNetworkReferenceType::TaggedSymbol
+        )
+      SYSTEM_TRACE_AUDIT_NUMBER =
+        T.let(
+          :system_trace_audit_number,
+          Dodopayments::RefundNetworkReferenceType::TaggedSymbol
+        )
+      RETRIEVAL_REFERENCE_NUMBER =
+        T.let(
+          :retrieval_reference_number,
+          Dodopayments::RefundNetworkReferenceType::TaggedSymbol
+        )
+      OTHER =
+        T.let(:other, Dodopayments::RefundNetworkReferenceType::TaggedSymbol)
+
+      sig do
+        override.returns(
+          T::Array[Dodopayments::RefundNetworkReferenceType::TaggedSymbol]
+        )
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/subscription.rbi

@@ -139,6 +139,18 @@ module Dodopayments
       sig { returns(T.nilable(Time)) }
       attr_accessor :cancelled_at
 
+      # The caller that cancelled the subscription or scheduled its cancel. `null` when
+      # no caller is known, for example when the system cancelled the subscription.
+      sig { returns(T.nilable(Dodopayments::SubscriptionCancelledBy)) }
+      attr_reader :cancelled_by
+
+      sig do
+        params(
+          cancelled_by: T.nilable(Dodopayments::SubscriptionCancelledBy::OrHash)
+        ).void
+      end
+      attr_writer :cancelled_by
+
       # Customer's responses to custom fields collected during checkout
       sig { returns(T.nilable(T::Array[Dodopayments::CustomFieldResponse])) }
       attr_accessor :custom_field_responses
@@ -229,6 +241,8 @@ module Dodopayments
           cancellation_feedback:
             T.nilable(Dodopayments::CancellationFeedback::OrSymbol),
           cancelled_at: T.nilable(Time),
+          cancelled_by:
+            T.nilable(Dodopayments::SubscriptionCancelledBy::OrHash),
           custom_field_responses:
             T.nilable(T::Array[Dodopayments::CustomFieldResponse::OrHash]),
           customer_business_name: T.nilable(String),
@@ -306,6 +320,9 @@ module Dodopayments
         cancellation_feedback: nil,
         # Cancelled timestamp if the subscription is cancelled
         cancelled_at: nil,
+        # The caller that cancelled the subscription or scheduled its cancel. `null` when
+        # no caller is known, for example when the system cancelled the subscription.
+        cancelled_by: nil,
         # Customer's responses to custom fields collected during checkout
         custom_field_responses: nil,
         # Business / legal name associated with the tax id (B2B). When set this is used on
@@ -372,6 +389,7 @@ module Dodopayments
             cancellation_feedback:
               T.nilable(Dodopayments::CancellationFeedback::TaggedSymbol),
             cancelled_at: T.nilable(Time),
+            cancelled_by: T.nilable(Dodopayments::SubscriptionCancelledBy),
             custom_field_responses:
               T.nilable(T::Array[Dodopayments::CustomFieldResponse]),
             customer_business_name: T.nilable(String),

data/rbi/dodopayments/models/subscription_cancelled_by.rbi

@@ -0,0 +1,107 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class SubscriptionCancelledBy < Dodopayments::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::SubscriptionCancelledBy,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      # The kind of caller.
+      sig do
+        returns(Dodopayments::SubscriptionCancelledBy::ActorType::TaggedSymbol)
+      end
+      attr_accessor :actor_type
+
+      # Email of the customer or of the dashboard user. `null` for an API key or the
+      # Dodo Payments team.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :email
+
+      # Name of the customer or of the dashboard user. `null` for an API key or the Dodo
+      # Payments team.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :name
+
+      # The caller that cancelled a subscription or scheduled its cancel.
+      sig do
+        params(
+          actor_type:
+            Dodopayments::SubscriptionCancelledBy::ActorType::OrSymbol,
+          email: T.nilable(String),
+          name: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The kind of caller.
+        actor_type:,
+        # Email of the customer or of the dashboard user. `null` for an API key or the
+        # Dodo Payments team.
+        email: nil,
+        # Name of the customer or of the dashboard user. `null` for an API key or the Dodo
+        # Payments team.
+        name: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            actor_type:
+              Dodopayments::SubscriptionCancelledBy::ActorType::TaggedSymbol,
+            email: T.nilable(String),
+            name: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The kind of caller.
+      module ActorType
+        extend Dodopayments::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Dodopayments::SubscriptionCancelledBy::ActorType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        CUSTOMER =
+          T.let(
+            :customer,
+            Dodopayments::SubscriptionCancelledBy::ActorType::TaggedSymbol
+          )
+        MERCHANT_USER =
+          T.let(
+            :merchant_user,
+            Dodopayments::SubscriptionCancelledBy::ActorType::TaggedSymbol
+          )
+        API_KEY =
+          T.let(
+            :api_key,
+            Dodopayments::SubscriptionCancelledBy::ActorType::TaggedSymbol
+          )
+        DODO_TEAM =
+          T.let(
+            :dodo_team,
+            Dodopayments::SubscriptionCancelledBy::ActorType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Dodopayments::SubscriptionCancelledBy::ActorType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end