dodopayments 2.28.0 → 2.30.0

data/rbi/dodopayments/models/moderation_retrieve_usage_response.rbi

@@ -0,0 +1,104 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class ModerationRetrieveUsageResponse < Dodopayments::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::Models::ModerationRetrieveUsageResponse,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      # Your billable screens per UTC day for the last 30 days, charged or not. A day
+      # with no screens is not in the list.
+      sig do
+        returns(
+          T::Array[Dodopayments::Models::ModerationRetrieveUsageResponse::Daily]
+        )
+      end
+      attr_accessor :daily
+
+      # Billable screens still needed to fill the next block of 1000. A full block is
+      # charged within one hour, so this value is 1000 when your unbilled screens fill
+      # whole blocks.
+      sig { returns(Integer) }
+      attr_accessor :screens_to_next_block
+
+      # Billable screens that Dodo Payments has not charged for yet.
+      sig { returns(Integer) }
+      attr_accessor :unbilled_screens
+
+      # Your moderation usage.
+      sig do
+        params(
+          daily:
+            T::Array[
+              Dodopayments::Models::ModerationRetrieveUsageResponse::Daily::OrHash
+            ],
+          screens_to_next_block: Integer,
+          unbilled_screens: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Your billable screens per UTC day for the last 30 days, charged or not. A day
+        # with no screens is not in the list.
+        daily:,
+        # Billable screens still needed to fill the next block of 1000. A full block is
+        # charged within one hour, so this value is 1000 when your unbilled screens fill
+        # whole blocks.
+        screens_to_next_block:,
+        # Billable screens that Dodo Payments has not charged for yet.
+        unbilled_screens:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            daily:
+              T::Array[
+                Dodopayments::Models::ModerationRetrieveUsageResponse::Daily
+              ],
+            screens_to_next_block: Integer,
+            unbilled_screens: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Daily < Dodopayments::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Dodopayments::Models::ModerationRetrieveUsageResponse::Daily,
+              Dodopayments::Internal::AnyHash
+            )
+          end
+
+        # The UTC day.
+        sig { returns(Date) }
+        attr_accessor :date
+
+        # Billable screens on that day.
+        sig { returns(Integer) }
+        attr_accessor :screens
+
+        sig { params(date: Date, screens: Integer).returns(T.attached_class) }
+        def self.new(
+          # The UTC day.
+          date:,
+          # Billable screens on that day.
+          screens:
+        )
+        end
+
+        sig { override.returns({ date: Date, screens: Integer }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/moderation_screen_params.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class ModerationScreenParams < Dodopayments::Internal::Type::BaseModel
+      extend Dodopayments::Internal::Type::RequestParameters::Converter
+      include Dodopayments::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::ModerationScreenParams,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      # The image to screen, as base64, with or without a `data:image/...;base64,`
+      # prefix. The formats are JPEG, PNG, WebP, GIF and BMP. The limit is 6991530
+      # base64 characters, and the decoded image must be at most 5 MiB.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :image
+
+      # Your identifier for this screen, up to 128 characters, with no control
+      # characters. The response returns it in `request_id`.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :request_id
+
+      # The text to screen, up to 8000 characters.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :text
+
+      sig do
+        params(
+          image: T.nilable(String),
+          request_id: T.nilable(String),
+          text: T.nilable(String),
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The image to screen, as base64, with or without a `data:image/...;base64,`
+        # prefix. The formats are JPEG, PNG, WebP, GIF and BMP. The limit is 6991530
+        # base64 characters, and the decoded image must be at most 5 MiB.
+        image: nil,
+        # Your identifier for this screen, up to 128 characters, with no control
+        # characters. The response returns it in `request_id`.
+        request_id: nil,
+        # The text to screen, up to 8000 characters.
+        text: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            image: T.nilable(String),
+            request_id: T.nilable(String),
+            text: T.nilable(String),
+            request_options: Dodopayments::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

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.rbi

@@ -357,6 +357,22 @@ module Dodopayments
   MiscListSupportedCountriesParams =
     Dodopayments::Models::MiscListSupportedCountriesParams
 
+  ModerationCategory = Dodopayments::Models::ModerationCategory
+
+  ModerationCategoryProvenance =
+    Dodopayments::Models::ModerationCategoryProvenance
+
+  ModerationCategoryScores = Dodopayments::Models::ModerationCategoryScores
+
+  ModerationDecision = Dodopayments::Models::ModerationDecision
+
+  ModerationProvenance = Dodopayments::Models::ModerationProvenance
+
+  ModerationRetrieveUsageParams =
+    Dodopayments::Models::ModerationRetrieveUsageParams
+
+  ModerationScreenParams = Dodopayments::Models::ModerationScreenParams
+
   NewCustomer = Dodopayments::Models::NewCustomer
 
   OnDemandSubscription = Dodopayments::Models::OnDemandSubscription

data/rbi/dodopayments/resources/checkout_sessions.rbi

@@ -42,6 +42,9 @@ module Dodopayments
         ).returns(Dodopayments::CheckoutSessionResponse)
       end
       def create(
+        # The products of the checkout. A cart holds at most 20 of them, one-time and
+        # subscription products together. An empty cart is valid for the
+        # product-collection flow, where the customer chooses the product later.
         product_cart:,
         # Customers will never see payment methods that are not in this list. However,
         # adding a method here does not guarantee customers will see it. Availability
@@ -163,6 +166,9 @@ module Dodopayments
         ).returns(Dodopayments::Models::CheckoutSessionPreviewResponse)
       end
       def preview(
+        # The products of the checkout. A cart holds at most 20 of them, one-time and
+        # subscription products together. An empty cart is valid for the
+        # product-collection flow, where the customer chooses the product later.
         product_cart:,
         # Customers will never see payment methods that are not in this list. However,
         # adding a method here does not guarantee customers will see it. Availability

data/rbi/dodopayments/resources/discounts.rbi

@@ -46,9 +46,11 @@ module Dodopayments
         # - If omitted, a random 16-character code is generated.
         code: nil,
         # Per-currency options (flat deduction / percentage cap + minimum subtotal).
-        # Required for `flat` codes (must include a resolvable default); optional
-        # per-currency caps for `percentage` codes. Per-row invariants are checked in
-        # `normalize_currency_options`, not via `#[validate(nested)]`.
+        # Checkout uses the row for the currency the buyer pays in. For any other currency
+        # it converts the default row. Required for `flat` codes (must include a
+        # resolvable default); optional per-currency caps for `percentage` codes. Per-row
+        # invariants are checked in `normalize_currency_options`, not via
+        # `#[validate(nested)]`.
         currency_options: nil,
         # Who may redeem this discount code. Defaults to `any` (unrestricted). `specific`
         # starts with zero attached customers (fails closed) until customers are attached

data/rbi/dodopayments/resources/moderation.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Dodopayments
+  module Resources
+    class Moderation
+      # Shows how many billable screens you made and how close you are to your next
+      # charge.
+      #
+      # **Billing.** A billable screen is a live-mode screen that returns a verdict.
+      # Dodo Payments charges $0.30 for each full block of 1000 billable screens and
+      # debits the fee from your balance. Each full block is charged within one hour.
+      # Screens that do not fill a block stay unbilled until they do. Errors and
+      # test-mode screens are free and are not counted.
+      sig do
+        params(request_options: Dodopayments::RequestOptions::OrHash).returns(
+          Dodopayments::Models::ModerationRetrieveUsageResponse
+        )
+      end
+      def retrieve_usage(request_options: {})
+      end
+
+      # Screens text, an image, or both, and returns a verdict: `allow`, `flag` or
+      # `deny`. The API is fail-closed: do not generate when you get no verdict.
+      #
+      # **Pricing.** Dodo Payments charges $0.30 per 1000 billable screens and debits
+      # the fee from your balance. A billable screen is a live-mode screen that returns
+      # a verdict. Errors and test-mode screens are free.
+      #
+      # **429.** Honour `Retry-After` and retry. A 429 is a throughput limit, not a
+      # verdict.
+      #
+      # **Test mode** returns mock verdicts and never calls the model. The default
+      # verdict is `allow`. Put one of these strings in `text` to select another
+      # outcome: `dodo_mock_flag` (`flag`), `dodo_mock_deny` (`deny`),
+      # `dodo_mock_overloaded` (429) or `dodo_mock_not_ready` (503).
+      sig do
+        params(
+          image: T.nilable(String),
+          request_id: T.nilable(String),
+          text: T.nilable(String),
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(Dodopayments::Models::ModerationScreenResponse)
+      end
+      def screen(
+        # The image to screen, as base64, with or without a `data:image/...;base64,`
+        # prefix. The formats are JPEG, PNG, WebP, GIF and BMP. The limit is 6991530
+        # base64 characters, and the decoded image must be at most 5 MiB.
+        image: nil,
+        # Your identifier for this screen, up to 128 characters, with no control
+        # characters. The response returns it in `request_id`.
+        request_id: nil,
+        # The text to screen, up to 8000 characters.
+        text: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Dodopayments::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end