dodopayments 0.0.1.pre.alpha.0 → 1.14.0

data/rbi/lib/dodopayments/models/discount_list_params.rbi

@@ -2,38 +2,27 @@
 
 module Dodopayments
   module Models
-    class DiscountListParams < Dodopayments::BaseModel
-      extend Dodopayments::RequestParameters::Converter
-      include Dodopayments::RequestParameters
+    class DiscountListParams < Dodopayments::Internal::Type::BaseModel
+      extend Dodopayments::Internal::Type::RequestParameters::Converter
+      include Dodopayments::Internal::Type::RequestParameters
 
       # Page number (default = 0).
       sig { returns(T.nilable(Integer)) }
-      def page_number
-      end
-
-      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-      def page_number=(_)
-      end
+      attr_accessor :page_number
 
       # Page size (default = 10, max = 100).
       sig { returns(T.nilable(Integer)) }
-      def page_size
-      end
-
-      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-      def page_size=(_)
-      end
+      attr_accessor :page_size
 
       sig do
         params(
           page_number: T.nilable(Integer),
           page_size: T.nilable(Integer),
-          request_options: T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything])
+          request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash)
         )
           .returns(T.attached_class)
       end
-      def self.new(page_number: nil, page_size: nil, request_options: {})
-      end
+      def self.new(page_number: nil, page_size: nil, request_options: {}); end
 
       sig do
         override
@@ -45,8 +34,7 @@ module Dodopayments
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

data/rbi/lib/dodopayments/models/discount_retrieve_params.rbi

@@ -2,20 +2,18 @@
 
 module Dodopayments
   module Models
-    class DiscountRetrieveParams < Dodopayments::BaseModel
-      extend Dodopayments::RequestParameters::Converter
-      include Dodopayments::RequestParameters
+    class DiscountRetrieveParams < Dodopayments::Internal::Type::BaseModel
+      extend Dodopayments::Internal::Type::RequestParameters::Converter
+      include Dodopayments::Internal::Type::RequestParameters
 
       sig do
-        params(request_options: T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        params(request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash))
           .returns(T.attached_class)
       end
-      def self.new(request_options: {})
-      end
+      def self.new(request_options: {}); end
 
       sig { override.returns({request_options: Dodopayments::RequestOptions}) }
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

data/rbi/lib/dodopayments/models/discount_type.rbi

@@ -2,16 +2,16 @@
 
 module Dodopayments
   module Models
-    class DiscountType < Dodopayments::Enum
-      abstract!
+    module DiscountType
+      extend Dodopayments::Internal::Type::Enum
 
-      PERCENTAGE = :percentage
+      TaggedSymbol = T.type_alias { T.all(Symbol, Dodopayments::Models::DiscountType) }
+      OrSymbol = T.type_alias { T.any(Symbol, String, Dodopayments::Models::DiscountType::TaggedSymbol) }
 
-      class << self
-        sig { override.returns(T::Array[Symbol]) }
-        def values
-        end
-      end
+      PERCENTAGE = T.let(:percentage, Dodopayments::Models::DiscountType::TaggedSymbol)
+
+      sig { override.returns(T::Array[Dodopayments::Models::DiscountType::TaggedSymbol]) }
+      def self.values; end
     end
   end
 end

data/rbi/lib/dodopayments/models/discount_update_params.rbi

@@ -2,75 +2,40 @@
 
 module Dodopayments
   module Models
-    class DiscountUpdateParams < Dodopayments::BaseModel
-      extend Dodopayments::RequestParameters::Converter
-      include Dodopayments::RequestParameters
+    class DiscountUpdateParams < Dodopayments::Internal::Type::BaseModel
+      extend Dodopayments::Internal::Type::RequestParameters::Converter
+      include Dodopayments::Internal::Type::RequestParameters
 
       # If present, update the discount amount:
       #
-      #   - If `discount_type` is `percentage`, this represents **basis points** (e.g.,
-      #     `540` = `5.4%`).
-      #   - Otherwise, this represents **USD cents** (e.g., `100` = `$1.00`).
+      # - If `discount_type` is `percentage`, this represents **basis points** (e.g.,
+      #   `540` = `5.4%`).
+      # - Otherwise, this represents **USD cents** (e.g., `100` = `$1.00`).
       #
-      #   Must be at least 1 if provided.
+      # Must be at least 1 if provided.
       sig { returns(T.nilable(Integer)) }
-      def amount
-      end
-
-      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-      def amount=(_)
-      end
+      attr_accessor :amount
 
       # If present, update the discount code (uppercase).
       sig { returns(T.nilable(String)) }
-      def code
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def code=(_)
-      end
+      attr_accessor :code
 
       sig { returns(T.nilable(Time)) }
-      def expires_at
-      end
-
-      sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-      def expires_at=(_)
-      end
+      attr_accessor :expires_at
 
       sig { returns(T.nilable(String)) }
-      def name
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def name=(_)
-      end
+      attr_accessor :name
 
       # If present, replaces all restricted product IDs with this new set. To remove all
-      #   restrictions, send empty array
+      # restrictions, send empty array
       sig { returns(T.nilable(T::Array[String])) }
-      def restricted_to
-      end
-
-      sig { params(_: T.nilable(T::Array[String])).returns(T.nilable(T::Array[String])) }
-      def restricted_to=(_)
-      end
+      attr_accessor :restricted_to
 
-      sig { returns(T.nilable(Symbol)) }
-      def type
-      end
-
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def type=(_)
-      end
+      sig { returns(T.nilable(Dodopayments::Models::DiscountType::OrSymbol)) }
+      attr_accessor :type
 
       sig { returns(T.nilable(Integer)) }
-      def usage_limit
-      end
-
-      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-      def usage_limit=(_)
-      end
+      attr_accessor :usage_limit
 
       sig do
         params(
@@ -79,9 +44,9 @@ module Dodopayments
           expires_at: T.nilable(Time),
           name: T.nilable(String),
           restricted_to: T.nilable(T::Array[String]),
-          type: T.nilable(Symbol),
+          type: T.nilable(Dodopayments::Models::DiscountType::OrSymbol),
           usage_limit: T.nilable(Integer),
-          request_options: T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything])
+          request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash)
         )
           .returns(T.attached_class)
       end
@@ -94,9 +59,7 @@ module Dodopayments
         type: nil,
         usage_limit: nil,
         request_options: {}
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -106,14 +69,13 @@ module Dodopayments
               expires_at: T.nilable(Time),
               name: T.nilable(String),
               restricted_to: T.nilable(T::Array[String]),
-              type: T.nilable(Symbol),
+              type: T.nilable(Dodopayments::Models::DiscountType::OrSymbol),
               usage_limit: T.nilable(Integer),
               request_options: Dodopayments::RequestOptions
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

data/rbi/lib/dodopayments/models/dispute.rbi

@@ -2,77 +2,37 @@
 
 module Dodopayments
   module Models
-    class Dispute < Dodopayments::BaseModel
+    class Dispute < Dodopayments::Internal::Type::BaseModel
       # The amount involved in the dispute, represented as a string to accommodate
-      #   precision.
+      # precision.
       sig { returns(String) }
-      def amount
-      end
-
-      sig { params(_: String).returns(String) }
-      def amount=(_)
-      end
+      attr_accessor :amount
 
       # The unique identifier of the business involved in the dispute.
       sig { returns(String) }
-      def business_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def business_id=(_)
-      end
+      attr_accessor :business_id
 
       # The timestamp of when the dispute was created, in UTC.
       sig { returns(Time) }
-      def created_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def created_at=(_)
-      end
+      attr_accessor :created_at
 
       # The currency of the disputed amount, represented as an ISO 4217 currency code.
       sig { returns(String) }
-      def currency
-      end
-
-      sig { params(_: String).returns(String) }
-      def currency=(_)
-      end
+      attr_accessor :currency
 
       # The unique identifier of the dispute.
       sig { returns(String) }
-      def dispute_id
-      end
+      attr_accessor :dispute_id
 
-      sig { params(_: String).returns(String) }
-      def dispute_id=(_)
-      end
-
-      sig { returns(Symbol) }
-      def dispute_stage
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def dispute_stage=(_)
-      end
-
-      sig { returns(Symbol) }
-      def dispute_status
-      end
+      sig { returns(Dodopayments::Models::DisputeStage::TaggedSymbol) }
+      attr_accessor :dispute_stage
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def dispute_status=(_)
-      end
+      sig { returns(Dodopayments::Models::DisputeStatus::TaggedSymbol) }
+      attr_accessor :dispute_status
 
       # The unique identifier of the payment associated with the dispute.
       sig { returns(String) }
-      def payment_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def payment_id=(_)
-      end
+      attr_accessor :payment_id
 
       sig do
         params(
@@ -81,13 +41,22 @@ module Dodopayments
           created_at: Time,
           currency: String,
           dispute_id: String,
-          dispute_stage: Symbol,
-          dispute_status: Symbol,
+          dispute_stage: Dodopayments::Models::DisputeStage::OrSymbol,
+          dispute_status: Dodopayments::Models::DisputeStatus::OrSymbol,
           payment_id: String
         )
           .returns(T.attached_class)
       end
-      def self.new(amount:, business_id:, created_at:, currency:, dispute_id:, dispute_stage:, dispute_status:, payment_id:)
+      def self.new(
+        amount:,
+        business_id:,
+        created_at:,
+        currency:,
+        dispute_id:,
+        dispute_stage:,
+        dispute_status:,
+        payment_id:
+      )
       end
 
       sig do
@@ -99,14 +68,13 @@ module Dodopayments
               created_at: Time,
               currency: String,
               dispute_id: String,
-              dispute_stage: Symbol,
-              dispute_status: Symbol,
+              dispute_stage: Dodopayments::Models::DisputeStage::TaggedSymbol,
+              dispute_status: Dodopayments::Models::DisputeStatus::TaggedSymbol,
               payment_id: String
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

data/rbi/lib/dodopayments/models/dispute_list_params.rbi

@@ -2,83 +2,48 @@
 
 module Dodopayments
   module Models
-    class DisputeListParams < Dodopayments::BaseModel
-      extend Dodopayments::RequestParameters::Converter
-      include Dodopayments::RequestParameters
+    class DisputeListParams < Dodopayments::Internal::Type::BaseModel
+      extend Dodopayments::Internal::Type::RequestParameters::Converter
+      include Dodopayments::Internal::Type::RequestParameters
 
       # Get events after this created time
       sig { returns(T.nilable(Time)) }
-      def created_at_gte
-      end
-
-      sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-      def created_at_gte=(_)
-      end
+      attr_accessor :created_at_gte
 
       # Get events created before this time
       sig { returns(T.nilable(Time)) }
-      def created_at_lte
-      end
-
-      sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-      def created_at_lte=(_)
-      end
+      attr_accessor :created_at_lte
 
       # Filter by customer_id
       sig { returns(T.nilable(String)) }
-      def customer_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def customer_id=(_)
-      end
+      attr_accessor :customer_id
 
       # Filter by dispute stage
-      sig { returns(T.nilable(Symbol)) }
-      def dispute_stage
-      end
-
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def dispute_stage=(_)
-      end
+      sig { returns(T.nilable(Dodopayments::Models::DisputeStage::OrSymbol)) }
+      attr_accessor :dispute_stage
 
       # Filter by dispute status
-      sig { returns(T.nilable(Symbol)) }
-      def dispute_status
-      end
-
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def dispute_status=(_)
-      end
+      sig { returns(T.nilable(Dodopayments::Models::DisputeStatus::OrSymbol)) }
+      attr_accessor :dispute_status
 
       # Page number default is 0
       sig { returns(T.nilable(Integer)) }
-      def page_number
-      end
-
-      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-      def page_number=(_)
-      end
+      attr_accessor :page_number
 
       # Page size default is 10 max is 100
       sig { returns(T.nilable(Integer)) }
-      def page_size
-      end
-
-      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-      def page_size=(_)
-      end
+      attr_accessor :page_size
 
       sig do
         params(
           created_at_gte: T.nilable(Time),
           created_at_lte: T.nilable(Time),
           customer_id: T.nilable(String),
-          dispute_stage: T.nilable(Symbol),
-          dispute_status: T.nilable(Symbol),
+          dispute_stage: T.nilable(Dodopayments::Models::DisputeStage::OrSymbol),
+          dispute_status: T.nilable(Dodopayments::Models::DisputeStatus::OrSymbol),
           page_number: T.nilable(Integer),
           page_size: T.nilable(Integer),
-          request_options: T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything])
+          request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash)
         )
           .returns(T.attached_class)
       end
@@ -91,9 +56,7 @@ module Dodopayments
         page_number: nil,
         page_size: nil,
         request_options: {}
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -101,16 +64,15 @@ module Dodopayments
               created_at_gte: T.nilable(Time),
               created_at_lte: T.nilable(Time),
               customer_id: T.nilable(String),
-              dispute_stage: T.nilable(Symbol),
-              dispute_status: T.nilable(Symbol),
+              dispute_stage: T.nilable(Dodopayments::Models::DisputeStage::OrSymbol),
+              dispute_status: T.nilable(Dodopayments::Models::DisputeStatus::OrSymbol),
               page_number: T.nilable(Integer),
               page_size: T.nilable(Integer),
               request_options: Dodopayments::RequestOptions
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

data/rbi/lib/dodopayments/models/dispute_retrieve_params.rbi

@@ -2,20 +2,18 @@
 
 module Dodopayments
   module Models
-    class DisputeRetrieveParams < Dodopayments::BaseModel
-      extend Dodopayments::RequestParameters::Converter
-      include Dodopayments::RequestParameters
+    class DisputeRetrieveParams < Dodopayments::Internal::Type::BaseModel
+      extend Dodopayments::Internal::Type::RequestParameters::Converter
+      include Dodopayments::Internal::Type::RequestParameters
 
       sig do
-        params(request_options: T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        params(request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash))
           .returns(T.attached_class)
       end
-      def self.new(request_options: {})
-      end
+      def self.new(request_options: {}); end
 
       sig { override.returns({request_options: Dodopayments::RequestOptions}) }
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

data/rbi/lib/dodopayments/models/dispute_stage.rbi

@@ -2,18 +2,18 @@
 
 module Dodopayments
   module Models
-    class DisputeStage < Dodopayments::Enum
-      abstract!
+    module DisputeStage
+      extend Dodopayments::Internal::Type::Enum
 
-      PRE_DISPUTE = :pre_dispute
-      DISPUTE = :dispute
-      PRE_ARBITRATION = :pre_arbitration
+      TaggedSymbol = T.type_alias { T.all(Symbol, Dodopayments::Models::DisputeStage) }
+      OrSymbol = T.type_alias { T.any(Symbol, String, Dodopayments::Models::DisputeStage::TaggedSymbol) }
 
-      class << self
-        sig { override.returns(T::Array[Symbol]) }
-        def values
-        end
-      end
+      PRE_DISPUTE = T.let(:pre_dispute, Dodopayments::Models::DisputeStage::TaggedSymbol)
+      DISPUTE = T.let(:dispute, Dodopayments::Models::DisputeStage::TaggedSymbol)
+      PRE_ARBITRATION = T.let(:pre_arbitration, Dodopayments::Models::DisputeStage::TaggedSymbol)
+
+      sig { override.returns(T::Array[Dodopayments::Models::DisputeStage::TaggedSymbol]) }
+      def self.values; end
     end
   end
 end

data/rbi/lib/dodopayments/models/dispute_status.rbi

@@ -2,22 +2,22 @@
 
 module Dodopayments
   module Models
-    class DisputeStatus < Dodopayments::Enum
-      abstract!
+    module DisputeStatus
+      extend Dodopayments::Internal::Type::Enum
 
-      DISPUTE_OPENED = :dispute_opened
-      DISPUTE_EXPIRED = :dispute_expired
-      DISPUTE_ACCEPTED = :dispute_accepted
-      DISPUTE_CANCELLED = :dispute_cancelled
-      DISPUTE_CHALLENGED = :dispute_challenged
-      DISPUTE_WON = :dispute_won
-      DISPUTE_LOST = :dispute_lost
+      TaggedSymbol = T.type_alias { T.all(Symbol, Dodopayments::Models::DisputeStatus) }
+      OrSymbol = T.type_alias { T.any(Symbol, String, Dodopayments::Models::DisputeStatus::TaggedSymbol) }
 
-      class << self
-        sig { override.returns(T::Array[Symbol]) }
-        def values
-        end
-      end
+      DISPUTE_OPENED = T.let(:dispute_opened, Dodopayments::Models::DisputeStatus::TaggedSymbol)
+      DISPUTE_EXPIRED = T.let(:dispute_expired, Dodopayments::Models::DisputeStatus::TaggedSymbol)
+      DISPUTE_ACCEPTED = T.let(:dispute_accepted, Dodopayments::Models::DisputeStatus::TaggedSymbol)
+      DISPUTE_CANCELLED = T.let(:dispute_cancelled, Dodopayments::Models::DisputeStatus::TaggedSymbol)
+      DISPUTE_CHALLENGED = T.let(:dispute_challenged, Dodopayments::Models::DisputeStatus::TaggedSymbol)
+      DISPUTE_WON = T.let(:dispute_won, Dodopayments::Models::DisputeStatus::TaggedSymbol)
+      DISPUTE_LOST = T.let(:dispute_lost, Dodopayments::Models::DisputeStatus::TaggedSymbol)
+
+      sig { override.returns(T::Array[Dodopayments::Models::DisputeStatus::TaggedSymbol]) }
+      def self.values; end
     end
   end
 end

data/rbi/lib/dodopayments/models/intent_status.rbi

@@ -2,26 +2,30 @@
 
 module Dodopayments
   module Models
-    class IntentStatus < Dodopayments::Enum
-      abstract!
+    module IntentStatus
+      extend Dodopayments::Internal::Type::Enum
 
-      SUCCEEDED = :succeeded
-      FAILED = :failed
-      CANCELLED = :cancelled
-      PROCESSING = :processing
-      REQUIRES_CUSTOMER_ACTION = :requires_customer_action
-      REQUIRES_MERCHANT_ACTION = :requires_merchant_action
-      REQUIRES_PAYMENT_METHOD = :requires_payment_method
-      REQUIRES_CONFIRMATION = :requires_confirmation
-      REQUIRES_CAPTURE = :requires_capture
-      PARTIALLY_CAPTURED = :partially_captured
-      PARTIALLY_CAPTURED_AND_CAPTURABLE = :partially_captured_and_capturable
+      TaggedSymbol = T.type_alias { T.all(Symbol, Dodopayments::Models::IntentStatus) }
+      OrSymbol = T.type_alias { T.any(Symbol, String, Dodopayments::Models::IntentStatus::TaggedSymbol) }
 
-      class << self
-        sig { override.returns(T::Array[Symbol]) }
-        def values
-        end
-      end
+      SUCCEEDED = T.let(:succeeded, Dodopayments::Models::IntentStatus::TaggedSymbol)
+      FAILED = T.let(:failed, Dodopayments::Models::IntentStatus::TaggedSymbol)
+      CANCELLED = T.let(:cancelled, Dodopayments::Models::IntentStatus::TaggedSymbol)
+      PROCESSING = T.let(:processing, Dodopayments::Models::IntentStatus::TaggedSymbol)
+      REQUIRES_CUSTOMER_ACTION =
+        T.let(:requires_customer_action, Dodopayments::Models::IntentStatus::TaggedSymbol)
+      REQUIRES_MERCHANT_ACTION =
+        T.let(:requires_merchant_action, Dodopayments::Models::IntentStatus::TaggedSymbol)
+      REQUIRES_PAYMENT_METHOD =
+        T.let(:requires_payment_method, Dodopayments::Models::IntentStatus::TaggedSymbol)
+      REQUIRES_CONFIRMATION = T.let(:requires_confirmation, Dodopayments::Models::IntentStatus::TaggedSymbol)
+      REQUIRES_CAPTURE = T.let(:requires_capture, Dodopayments::Models::IntentStatus::TaggedSymbol)
+      PARTIALLY_CAPTURED = T.let(:partially_captured, Dodopayments::Models::IntentStatus::TaggedSymbol)
+      PARTIALLY_CAPTURED_AND_CAPTURABLE =
+        T.let(:partially_captured_and_capturable, Dodopayments::Models::IntentStatus::TaggedSymbol)
+
+      sig { override.returns(T::Array[Dodopayments::Models::IntentStatus::TaggedSymbol]) }
+      def self.values; end
     end
   end
 end

data/rbi/lib/dodopayments/models/invoices/payment_retrieve_params.rbi

@@ -3,20 +3,18 @@
 module Dodopayments
   module Models
     module Invoices
-      class PaymentRetrieveParams < Dodopayments::BaseModel
-        extend Dodopayments::RequestParameters::Converter
-        include Dodopayments::RequestParameters
+      class PaymentRetrieveParams < Dodopayments::Internal::Type::BaseModel
+        extend Dodopayments::Internal::Type::RequestParameters::Converter
+        include Dodopayments::Internal::Type::RequestParameters
 
         sig do
-          params(request_options: T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+          params(request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash))
             .returns(T.attached_class)
         end
-        def self.new(request_options: {})
-        end
+        def self.new(request_options: {}); end
 
         sig { override.returns({request_options: Dodopayments::RequestOptions}) }
-        def to_hash
-        end
+        def to_hash; end
       end
     end
   end