dodopayments 1.18.3 → 1.20.0

data/rbi/dodopayments/models/payment.rbi

@@ -0,0 +1,227 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class Payment < Dodopayments::Internal::Type::BaseModel
+      sig { returns(Dodopayments::Models::BillingAddress) }
+      attr_reader :billing
+
+      sig { params(billing: T.any(Dodopayments::Models::BillingAddress, Dodopayments::Internal::AnyHash)).void }
+      attr_writer :billing
+
+      # Identifier of the business associated with the payment
+      sig { returns(String) }
+      attr_accessor :business_id
+
+      # Timestamp when the payment was created
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      sig { returns(Dodopayments::Models::Currency::TaggedSymbol) }
+      attr_accessor :currency
+
+      sig { returns(Dodopayments::Models::CustomerLimitedDetails) }
+      attr_reader :customer
+
+      sig do
+        params(customer: T.any(Dodopayments::Models::CustomerLimitedDetails, Dodopayments::Internal::AnyHash)).void
+      end
+      attr_writer :customer
+
+      # List of disputes associated with this payment
+      sig { returns(T::Array[Dodopayments::Models::Dispute]) }
+      attr_accessor :disputes
+
+      sig { returns(T::Hash[Symbol, String]) }
+      attr_accessor :metadata
+
+      # Unique identifier for the payment
+      sig { returns(String) }
+      attr_accessor :payment_id
+
+      # List of refunds issued for this payment
+      sig { returns(T::Array[Dodopayments::Models::Refund]) }
+      attr_accessor :refunds
+
+      # The amount that will be credited to your Dodo balance after currency conversion
+      # and processing. Especially relevant for adaptive pricing where the customer's
+      # payment currency differs from your settlement currency.
+      sig { returns(Integer) }
+      attr_accessor :settlement_amount
+
+      sig { returns(Dodopayments::Models::Currency::TaggedSymbol) }
+      attr_accessor :settlement_currency
+
+      # Total amount charged to the customer including tax, in smallest currency unit
+      # (e.g. cents)
+      sig { returns(Integer) }
+      attr_accessor :total_amount
+
+      # The discount id if discount is applied
+      sig { returns(T.nilable(String)) }
+      attr_accessor :discount_id
+
+      # An error message if the payment failed
+      sig { returns(T.nilable(String)) }
+      attr_accessor :error_message
+
+      # Checkout URL
+      sig { returns(T.nilable(String)) }
+      attr_accessor :payment_link
+
+      # Payment method used by customer (e.g. "card", "bank_transfer")
+      sig { returns(T.nilable(String)) }
+      attr_accessor :payment_method
+
+      # Specific type of payment method (e.g. "visa", "mastercard")
+      sig { returns(T.nilable(String)) }
+      attr_accessor :payment_method_type
+
+      # List of products purchased in a one-time payment
+      sig { returns(T.nilable(T::Array[Dodopayments::Models::Payment::ProductCart])) }
+      attr_accessor :product_cart
+
+      # This represents the portion of settlement_amount that corresponds to taxes
+      # collected. Especially relevant for adaptive pricing where the tax component must
+      # be tracked separately in your Dodo balance.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :settlement_tax
+
+      sig { returns(T.nilable(Dodopayments::Models::IntentStatus::TaggedSymbol)) }
+      attr_accessor :status
+
+      # Identifier of the subscription if payment is part of a subscription
+      sig { returns(T.nilable(String)) }
+      attr_accessor :subscription_id
+
+      # Amount of tax collected in smallest currency unit (e.g. cents)
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :tax
+
+      # Timestamp when the payment was last updated
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :updated_at
+
+      sig do
+        params(
+          billing: T.any(Dodopayments::Models::BillingAddress, Dodopayments::Internal::AnyHash),
+          business_id: String,
+          created_at: Time,
+          currency: Dodopayments::Models::Currency::OrSymbol,
+          customer: T.any(Dodopayments::Models::CustomerLimitedDetails, Dodopayments::Internal::AnyHash),
+          disputes: T::Array[T.any(Dodopayments::Models::Dispute, Dodopayments::Internal::AnyHash)],
+          metadata: T::Hash[Symbol, String],
+          payment_id: String,
+          refunds: T::Array[T.any(Dodopayments::Models::Refund, Dodopayments::Internal::AnyHash)],
+          settlement_amount: Integer,
+          settlement_currency: Dodopayments::Models::Currency::OrSymbol,
+          total_amount: Integer,
+          discount_id: T.nilable(String),
+          error_message: T.nilable(String),
+          payment_link: T.nilable(String),
+          payment_method: T.nilable(String),
+          payment_method_type: T.nilable(String),
+          product_cart: T.nilable(T::Array[T.any(Dodopayments::Models::Payment::ProductCart, Dodopayments::Internal::AnyHash)]),
+          settlement_tax: T.nilable(Integer),
+          status: T.nilable(Dodopayments::Models::IntentStatus::OrSymbol),
+          subscription_id: T.nilable(String),
+          tax: T.nilable(Integer),
+          updated_at: T.nilable(Time)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        billing:,
+        # Identifier of the business associated with the payment
+        business_id:,
+        # Timestamp when the payment was created
+        created_at:,
+        currency:,
+        customer:,
+        # List of disputes associated with this payment
+        disputes:,
+        metadata:,
+        # Unique identifier for the payment
+        payment_id:,
+        # List of refunds issued for this payment
+        refunds:,
+        # The amount that will be credited to your Dodo balance after currency conversion
+        # and processing. Especially relevant for adaptive pricing where the customer's
+        # payment currency differs from your settlement currency.
+        settlement_amount:,
+        settlement_currency:,
+        # Total amount charged to the customer including tax, in smallest currency unit
+        # (e.g. cents)
+        total_amount:,
+        # The discount id if discount is applied
+        discount_id: nil,
+        # An error message if the payment failed
+        error_message: nil,
+        # Checkout URL
+        payment_link: nil,
+        # Payment method used by customer (e.g. "card", "bank_transfer")
+        payment_method: nil,
+        # Specific type of payment method (e.g. "visa", "mastercard")
+        payment_method_type: nil,
+        # List of products purchased in a one-time payment
+        product_cart: nil,
+        # This represents the portion of settlement_amount that corresponds to taxes
+        # collected. Especially relevant for adaptive pricing where the tax component must
+        # be tracked separately in your Dodo balance.
+        settlement_tax: nil,
+        status: nil,
+        # Identifier of the subscription if payment is part of a subscription
+        subscription_id: nil,
+        # Amount of tax collected in smallest currency unit (e.g. cents)
+        tax: nil,
+        # Timestamp when the payment was last updated
+        updated_at: nil
+      ); end
+      sig do
+        override
+          .returns(
+            {
+              billing: Dodopayments::Models::BillingAddress,
+              business_id: String,
+              created_at: Time,
+              currency: Dodopayments::Models::Currency::TaggedSymbol,
+              customer: Dodopayments::Models::CustomerLimitedDetails,
+              disputes: T::Array[Dodopayments::Models::Dispute],
+              metadata: T::Hash[Symbol, String],
+              payment_id: String,
+              refunds: T::Array[Dodopayments::Models::Refund],
+              settlement_amount: Integer,
+              settlement_currency: Dodopayments::Models::Currency::TaggedSymbol,
+              total_amount: Integer,
+              discount_id: T.nilable(String),
+              error_message: T.nilable(String),
+              payment_link: T.nilable(String),
+              payment_method: T.nilable(String),
+              payment_method_type: T.nilable(String),
+              product_cart: T.nilable(T::Array[Dodopayments::Models::Payment::ProductCart]),
+              settlement_tax: T.nilable(Integer),
+              status: T.nilable(Dodopayments::Models::IntentStatus::TaggedSymbol),
+              subscription_id: T.nilable(String),
+              tax: T.nilable(Integer),
+              updated_at: T.nilable(Time)
+            }
+          )
+      end
+      def to_hash; end
+
+      class ProductCart < Dodopayments::Internal::Type::BaseModel
+        sig { returns(String) }
+        attr_accessor :product_id
+
+        sig { returns(Integer) }
+        attr_accessor :quantity
+
+        sig { params(product_id: String, quantity: Integer).returns(T.attached_class) }
+        def self.new(product_id:, quantity:); end
+
+        sig { override.returns({product_id: String, quantity: Integer}) }
+        def to_hash; end
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/payment_create_params.rbi

@@ -0,0 +1,189 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class PaymentCreateParams < Dodopayments::Internal::Type::BaseModel
+      extend Dodopayments::Internal::Type::RequestParameters::Converter
+      include Dodopayments::Internal::Type::RequestParameters
+
+      sig { returns(Dodopayments::Models::BillingAddress) }
+      attr_reader :billing
+
+      sig { params(billing: T.any(Dodopayments::Models::BillingAddress, Dodopayments::Internal::AnyHash)).void }
+      attr_writer :billing
+
+      sig { returns(T.any(Dodopayments::Models::AttachExistingCustomer, Dodopayments::Models::CreateNewCustomer)) }
+      attr_accessor :customer
+
+      # List of products in the cart. Must contain at least 1 and at most 100 items.
+      sig { returns(T::Array[Dodopayments::Models::OneTimeProductCartItem]) }
+      attr_accessor :product_cart
+
+      # List of payment methods allowed during checkout.
+      #
+      # 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 still depends on other factors (e.g., customer location, merchant
+      # settings).
+      sig do
+        returns(
+          T.nilable(T::Array[Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::OrSymbol])
+        )
+      end
+      attr_accessor :allowed_payment_method_types
+
+      sig { returns(T.nilable(Dodopayments::Models::Currency::OrSymbol)) }
+      attr_accessor :billing_currency
+
+      # Discount Code to apply to the transaction
+      sig { returns(T.nilable(String)) }
+      attr_accessor :discount_code
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :metadata
+
+      sig { params(metadata: T::Hash[Symbol, String]).void }
+      attr_writer :metadata
+
+      # Whether to generate a payment link. Defaults to false if not specified.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :payment_link
+
+      # Optional URL to redirect the customer after payment. Must be a valid URL if
+      # provided.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :return_url
+
+      # Display saved payment methods of a returning customer False by default
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :show_saved_payment_methods
+
+      sig { params(show_saved_payment_methods: T::Boolean).void }
+      attr_writer :show_saved_payment_methods
+
+      # Tax ID in case the payment is B2B. If tax id validation fails the payment
+      # creation will fail
+      sig { returns(T.nilable(String)) }
+      attr_accessor :tax_id
+
+      sig do
+        params(
+          billing: T.any(Dodopayments::Models::BillingAddress, Dodopayments::Internal::AnyHash),
+          customer: T.any(
+            Dodopayments::Models::AttachExistingCustomer,
+            Dodopayments::Internal::AnyHash,
+            Dodopayments::Models::CreateNewCustomer
+          ),
+          product_cart: T::Array[T.any(Dodopayments::Models::OneTimeProductCartItem, Dodopayments::Internal::AnyHash)],
+          allowed_payment_method_types: T.nilable(T::Array[Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::OrSymbol]),
+          billing_currency: T.nilable(Dodopayments::Models::Currency::OrSymbol),
+          discount_code: T.nilable(String),
+          metadata: T::Hash[Symbol, String],
+          payment_link: T.nilable(T::Boolean),
+          return_url: T.nilable(String),
+          show_saved_payment_methods: T::Boolean,
+          tax_id: T.nilable(String),
+          request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        billing:,
+        customer:,
+        # List of products in the cart. Must contain at least 1 and at most 100 items.
+        product_cart:,
+        # List of payment methods allowed during checkout.
+        #
+        # 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 still depends on other factors (e.g., customer location, merchant
+        # settings).
+        allowed_payment_method_types: nil,
+        billing_currency: nil,
+        # Discount Code to apply to the transaction
+        discount_code: nil,
+        metadata: nil,
+        # Whether to generate a payment link. Defaults to false if not specified.
+        payment_link: nil,
+        # Optional URL to redirect the customer after payment. Must be a valid URL if
+        # provided.
+        return_url: nil,
+        # Display saved payment methods of a returning customer False by default
+        show_saved_payment_methods: nil,
+        # Tax ID in case the payment is B2B. If tax id validation fails the payment
+        # creation will fail
+        tax_id: nil,
+        request_options: {}
+      ); end
+      sig do
+        override
+          .returns(
+            {
+              billing: Dodopayments::Models::BillingAddress,
+              customer: T.any(Dodopayments::Models::AttachExistingCustomer, Dodopayments::Models::CreateNewCustomer),
+              product_cart: T::Array[Dodopayments::Models::OneTimeProductCartItem],
+              allowed_payment_method_types: T.nilable(T::Array[Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::OrSymbol]),
+              billing_currency: T.nilable(Dodopayments::Models::Currency::OrSymbol),
+              discount_code: T.nilable(String),
+              metadata: T::Hash[Symbol, String],
+              payment_link: T.nilable(T::Boolean),
+              return_url: T.nilable(String),
+              show_saved_payment_methods: T::Boolean,
+              tax_id: T.nilable(String),
+              request_options: Dodopayments::RequestOptions
+            }
+          )
+      end
+      def to_hash; end
+
+      module AllowedPaymentMethodType
+        extend Dodopayments::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        CREDIT =
+          T.let(:credit, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        DEBIT = T.let(:debit, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        UPI_COLLECT =
+          T.let(:upi_collect, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        UPI_INTENT =
+          T.let(:upi_intent, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        APPLE_PAY =
+          T.let(:apple_pay, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        CASHAPP =
+          T.let(:cashapp, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        GOOGLE_PAY =
+          T.let(:google_pay, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        MULTIBANCO =
+          T.let(:multibanco, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        BANCONTACT_CARD =
+          T.let(:bancontact_card, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        EPS = T.let(:eps, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        IDEAL = T.let(:ideal, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        PRZELEWY24 =
+          T.let(:przelewy24, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        AFFIRM =
+          T.let(:affirm, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        KLARNA =
+          T.let(:klarna, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        SEPA = T.let(:sepa, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        ACH = T.let(:ach, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        AMAZON_PAY =
+          T.let(:amazon_pay, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
+        AFTERPAY_CLEARPAY =
+          T.let(
+            :afterpay_clearpay,
+            Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol
+          )
+
+        sig do
+          override
+            .returns(T::Array[Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol])
+        end
+        def self.values; end
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/payment_list_response.rbi

@@ -0,0 +1,88 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class PaymentListResponse < Dodopayments::Internal::Type::BaseModel
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      sig { returns(Dodopayments::Models::Currency::TaggedSymbol) }
+      attr_accessor :currency
+
+      sig { returns(Dodopayments::Models::CustomerLimitedDetails) }
+      attr_reader :customer
+
+      sig do
+        params(customer: T.any(Dodopayments::Models::CustomerLimitedDetails, Dodopayments::Internal::AnyHash)).void
+      end
+      attr_writer :customer
+
+      sig { returns(T::Hash[Symbol, String]) }
+      attr_accessor :metadata
+
+      sig { returns(String) }
+      attr_accessor :payment_id
+
+      sig { returns(Integer) }
+      attr_accessor :total_amount
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :payment_method
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :payment_method_type
+
+      sig { returns(T.nilable(Dodopayments::Models::IntentStatus::TaggedSymbol)) }
+      attr_accessor :status
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :subscription_id
+
+      sig do
+        params(
+          created_at: Time,
+          currency: Dodopayments::Models::Currency::OrSymbol,
+          customer: T.any(Dodopayments::Models::CustomerLimitedDetails, Dodopayments::Internal::AnyHash),
+          metadata: T::Hash[Symbol, String],
+          payment_id: String,
+          total_amount: Integer,
+          payment_method: T.nilable(String),
+          payment_method_type: T.nilable(String),
+          status: T.nilable(Dodopayments::Models::IntentStatus::OrSymbol),
+          subscription_id: T.nilable(String)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        created_at:,
+        currency:,
+        customer:,
+        metadata:,
+        payment_id:,
+        total_amount:,
+        payment_method: nil,
+        payment_method_type: nil,
+        status: nil,
+        subscription_id: nil
+      ); end
+      sig do
+        override
+          .returns(
+            {
+              created_at: Time,
+              currency: Dodopayments::Models::Currency::TaggedSymbol,
+              customer: Dodopayments::Models::CustomerLimitedDetails,
+              metadata: T::Hash[Symbol, String],
+              payment_id: String,
+              total_amount: Integer,
+              payment_method: T.nilable(String),
+              payment_method_type: T.nilable(String),
+              status: T.nilable(Dodopayments::Models::IntentStatus::TaggedSymbol),
+              subscription_id: T.nilable(String)
+            }
+          )
+      end
+      def to_hash; end
+    end
+  end
+end

data/rbi/dodopayments/models/payout_list_response.rbi

@@ -0,0 +1,155 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class PayoutListResponse < Dodopayments::Internal::Type::BaseModel
+      # The total amount of the payout.
+      sig { returns(Integer) }
+      attr_accessor :amount
+
+      # The unique identifier of the business associated with the payout.
+      sig { returns(String) }
+      attr_accessor :business_id
+
+      # The total value of chargebacks associated with the payout.
+      sig { returns(Integer) }
+      attr_accessor :chargebacks
+
+      # The timestamp when the payout was created, in UTC.
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      sig { returns(Dodopayments::Models::Currency::TaggedSymbol) }
+      attr_accessor :currency
+
+      # The fee charged for processing the payout.
+      sig { returns(Integer) }
+      attr_accessor :fee
+
+      # The payment method used for the payout (e.g., bank transfer, card, etc.).
+      sig { returns(String) }
+      attr_accessor :payment_method
+
+      # The unique identifier of the payout.
+      sig { returns(String) }
+      attr_accessor :payout_id
+
+      # The total value of refunds associated with the payout.
+      sig { returns(Integer) }
+      attr_accessor :refunds
+
+      sig { returns(Dodopayments::Models::PayoutListResponse::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      # The tax applied to the payout.
+      sig { returns(Integer) }
+      attr_accessor :tax
+
+      # The timestamp when the payout was last updated, in UTC.
+      sig { returns(Time) }
+      attr_accessor :updated_at
+
+      # The name of the payout recipient or purpose.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :name
+
+      # The URL of the document associated with the payout.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :payout_document_url
+
+      # Any additional remarks or notes associated with the payout.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :remarks
+
+      sig do
+        params(
+          amount: Integer,
+          business_id: String,
+          chargebacks: Integer,
+          created_at: Time,
+          currency: Dodopayments::Models::Currency::OrSymbol,
+          fee: Integer,
+          payment_method: String,
+          payout_id: String,
+          refunds: Integer,
+          status: Dodopayments::Models::PayoutListResponse::Status::OrSymbol,
+          tax: Integer,
+          updated_at: Time,
+          name: T.nilable(String),
+          payout_document_url: T.nilable(String),
+          remarks: T.nilable(String)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        # The total amount of the payout.
+        amount:,
+        # The unique identifier of the business associated with the payout.
+        business_id:,
+        # The total value of chargebacks associated with the payout.
+        chargebacks:,
+        # The timestamp when the payout was created, in UTC.
+        created_at:,
+        currency:,
+        # The fee charged for processing the payout.
+        fee:,
+        # The payment method used for the payout (e.g., bank transfer, card, etc.).
+        payment_method:,
+        # The unique identifier of the payout.
+        payout_id:,
+        # The total value of refunds associated with the payout.
+        refunds:,
+        status:,
+        # The tax applied to the payout.
+        tax:,
+        # The timestamp when the payout was last updated, in UTC.
+        updated_at:,
+        # The name of the payout recipient or purpose.
+        name: nil,
+        # The URL of the document associated with the payout.
+        payout_document_url: nil,
+        # Any additional remarks or notes associated with the payout.
+        remarks: nil
+      ); end
+      sig do
+        override
+          .returns(
+            {
+              amount: Integer,
+              business_id: String,
+              chargebacks: Integer,
+              created_at: Time,
+              currency: Dodopayments::Models::Currency::TaggedSymbol,
+              fee: Integer,
+              payment_method: String,
+              payout_id: String,
+              refunds: Integer,
+              status: Dodopayments::Models::PayoutListResponse::Status::TaggedSymbol,
+              tax: Integer,
+              updated_at: Time,
+              name: T.nilable(String),
+              payout_document_url: T.nilable(String),
+              remarks: T.nilable(String)
+            }
+          )
+      end
+      def to_hash; end
+
+      module Status
+        extend Dodopayments::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Dodopayments::Models::PayoutListResponse::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        NOT_INITIATED = T.let(:not_initiated, Dodopayments::Models::PayoutListResponse::Status::TaggedSymbol)
+        IN_PROGRESS = T.let(:in_progress, Dodopayments::Models::PayoutListResponse::Status::TaggedSymbol)
+        ON_HOLD = T.let(:on_hold, Dodopayments::Models::PayoutListResponse::Status::TaggedSymbol)
+        FAILED = T.let(:failed, Dodopayments::Models::PayoutListResponse::Status::TaggedSymbol)
+        SUCCESS = T.let(:success, Dodopayments::Models::PayoutListResponse::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[Dodopayments::Models::PayoutListResponse::Status::TaggedSymbol]) }
+        def self.values; end
+      end
+    end
+  end
+end