dodopayments 1.20.0 → 1.47.0

data/rbi/dodopayments/models/subscription_list_params.rbi

@@ -6,43 +6,86 @@ module Dodopayments
       extend Dodopayments::Internal::Type::RequestParameters::Converter
       include Dodopayments::Internal::Type::RequestParameters
 
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::SubscriptionListParams,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      # filter by Brand id
+      sig { returns(T.nilable(String)) }
+      attr_reader :brand_id
+
+      sig { params(brand_id: String).void }
+      attr_writer :brand_id
+
       # Get events after this created time
       sig { returns(T.nilable(Time)) }
-      attr_accessor :created_at_gte
+      attr_reader :created_at_gte
+
+      sig { params(created_at_gte: Time).void }
+      attr_writer :created_at_gte
 
       # Get events created before this time
       sig { returns(T.nilable(Time)) }
-      attr_accessor :created_at_lte
+      attr_reader :created_at_lte
+
+      sig { params(created_at_lte: Time).void }
+      attr_writer :created_at_lte
 
       # Filter by customer id
       sig { returns(T.nilable(String)) }
-      attr_accessor :customer_id
+      attr_reader :customer_id
+
+      sig { params(customer_id: String).void }
+      attr_writer :customer_id
 
       # Page number default is 0
       sig { returns(T.nilable(Integer)) }
-      attr_accessor :page_number
+      attr_reader :page_number
+
+      sig { params(page_number: Integer).void }
+      attr_writer :page_number
 
       # Page size default is 10 max is 100
       sig { returns(T.nilable(Integer)) }
-      attr_accessor :page_size
+      attr_reader :page_size
+
+      sig { params(page_size: Integer).void }
+      attr_writer :page_size
 
       # Filter by status
-      sig { returns(T.nilable(Dodopayments::Models::SubscriptionStatus::OrSymbol)) }
-      attr_accessor :status
+      sig do
+        returns(
+          T.nilable(Dodopayments::SubscriptionListParams::Status::OrSymbol)
+        )
+      end
+      attr_reader :status
 
       sig do
         params(
-          created_at_gte: T.nilable(Time),
-          created_at_lte: T.nilable(Time),
-          customer_id: T.nilable(String),
-          page_number: T.nilable(Integer),
-          page_size: T.nilable(Integer),
-          status: T.nilable(Dodopayments::Models::SubscriptionStatus::OrSymbol),
-          request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          status: Dodopayments::SubscriptionListParams::Status::OrSymbol
+        ).void
+      end
+      attr_writer :status
+
+      sig do
+        params(
+          brand_id: String,
+          created_at_gte: Time,
+          created_at_lte: Time,
+          customer_id: String,
+          page_number: Integer,
+          page_size: Integer,
+          status: Dodopayments::SubscriptionListParams::Status::OrSymbol,
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
+        # filter by Brand id
+        brand_id: nil,
         # Get events after this created time
         created_at_gte: nil,
         # Get events created before this time
@@ -56,22 +99,75 @@ module Dodopayments
         # Filter by status
         status: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              created_at_gte: T.nilable(Time),
-              created_at_lte: T.nilable(Time),
-              customer_id: T.nilable(String),
-              page_number: T.nilable(Integer),
-              page_size: T.nilable(Integer),
-              status: T.nilable(Dodopayments::Models::SubscriptionStatus::OrSymbol),
-              request_options: Dodopayments::RequestOptions
-            }
+        override.returns(
+          {
+            brand_id: String,
+            created_at_gte: Time,
+            created_at_lte: Time,
+            customer_id: String,
+            page_number: Integer,
+            page_size: Integer,
+            status: Dodopayments::SubscriptionListParams::Status::OrSymbol,
+            request_options: Dodopayments::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Filter by status
+      module Status
+        extend Dodopayments::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Dodopayments::SubscriptionListParams::Status)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PENDING =
+          T.let(
+            :pending,
+            Dodopayments::SubscriptionListParams::Status::TaggedSymbol
+          )
+        ACTIVE =
+          T.let(
+            :active,
+            Dodopayments::SubscriptionListParams::Status::TaggedSymbol
+          )
+        ON_HOLD =
+          T.let(
+            :on_hold,
+            Dodopayments::SubscriptionListParams::Status::TaggedSymbol
+          )
+        CANCELLED =
+          T.let(
+            :cancelled,
+            Dodopayments::SubscriptionListParams::Status::TaggedSymbol
+          )
+        FAILED =
+          T.let(
+            :failed,
+            Dodopayments::SubscriptionListParams::Status::TaggedSymbol
+          )
+        EXPIRED =
+          T.let(
+            :expired,
+            Dodopayments::SubscriptionListParams::Status::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Dodopayments::SubscriptionListParams::Status::TaggedSymbol]
           )
+        end
+        def self.values
+        end
       end
-      def to_hash; end
     end
   end
 end

data/rbi/dodopayments/models/subscription_list_response.rbi

@@ -3,27 +3,43 @@
 module Dodopayments
   module Models
     class SubscriptionListResponse < Dodopayments::Internal::Type::BaseModel
-      sig { returns(Dodopayments::Models::BillingAddress) }
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::Models::SubscriptionListResponse,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      # Billing address details for payments
+      sig { returns(Dodopayments::BillingAddress) }
       attr_reader :billing
 
-      sig { params(billing: T.any(Dodopayments::Models::BillingAddress, Dodopayments::Internal::AnyHash)).void }
+      sig { params(billing: Dodopayments::BillingAddress::OrHash).void }
       attr_writer :billing
 
+      # Indicates if the subscription will cancel at the next billing date
+      sig { returns(T::Boolean) }
+      attr_accessor :cancel_at_next_billing_date
+
       # Timestamp when the subscription was created
       sig { returns(Time) }
       attr_accessor :created_at
 
-      sig { returns(Dodopayments::Models::Currency::TaggedSymbol) }
+      # Currency used for the subscription payments
+      sig { returns(Dodopayments::Currency::TaggedSymbol) }
       attr_accessor :currency
 
-      sig { returns(Dodopayments::Models::CustomerLimitedDetails) }
+      # Customer details associated with the subscription
+      sig { returns(Dodopayments::CustomerLimitedDetails) }
       attr_reader :customer
 
       sig do
-        params(customer: T.any(Dodopayments::Models::CustomerLimitedDetails, Dodopayments::Internal::AnyHash)).void
+        params(customer: Dodopayments::CustomerLimitedDetails::OrHash).void
       end
       attr_writer :customer
 
+      # Additional custom data associated with the subscription
       sig { returns(T::Hash[Symbol, String]) }
       attr_accessor :metadata
 
@@ -40,7 +56,8 @@ module Dodopayments
       sig { returns(Integer) }
       attr_accessor :payment_frequency_count
 
-      sig { returns(Dodopayments::Models::TimeInterval::TaggedSymbol) }
+      # Time interval for payment frequency (e.g. month, year)
+      sig { returns(Dodopayments::TimeInterval::TaggedSymbol) }
       attr_accessor :payment_frequency_interval
 
       # Timestamp of the last payment. Indicates the start of current billing period
@@ -60,7 +77,8 @@ module Dodopayments
       sig { returns(Integer) }
       attr_accessor :recurring_pre_tax_amount
 
-      sig { returns(Dodopayments::Models::SubscriptionStatus::TaggedSymbol) }
+      # Current status of the subscription
+      sig { returns(Dodopayments::SubscriptionStatus::TaggedSymbol) }
       attr_accessor :status
 
       # Unique identifier for the subscription
@@ -71,7 +89,8 @@ module Dodopayments
       sig { returns(Integer) }
       attr_accessor :subscription_period_count
 
-      sig { returns(Dodopayments::Models::TimeInterval::TaggedSymbol) }
+      # Time interval for the subscription period (e.g. month, year)
+      sig { returns(Dodopayments::TimeInterval::TaggedSymbol) }
       attr_accessor :subscription_period_interval
 
       # Indicates if the recurring_pre_tax_amount is tax inclusive
@@ -86,6 +105,10 @@ module Dodopayments
       sig { returns(T.nilable(Time)) }
       attr_accessor :cancelled_at
 
+      # Number of remaining discount cycles if discount is applied
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :discount_cycles_remaining
+
       # The discount id if discount is applied
       sig { returns(T.nilable(String)) }
       attr_accessor :discount_id
@@ -93,36 +116,43 @@ module Dodopayments
       # Response struct representing subscription details
       sig do
         params(
-          billing: T.any(Dodopayments::Models::BillingAddress, Dodopayments::Internal::AnyHash),
+          billing: Dodopayments::BillingAddress::OrHash,
+          cancel_at_next_billing_date: T::Boolean,
           created_at: Time,
-          currency: Dodopayments::Models::Currency::OrSymbol,
-          customer: T.any(Dodopayments::Models::CustomerLimitedDetails, Dodopayments::Internal::AnyHash),
+          currency: Dodopayments::Currency::OrSymbol,
+          customer: Dodopayments::CustomerLimitedDetails::OrHash,
           metadata: T::Hash[Symbol, String],
           next_billing_date: Time,
           on_demand: T::Boolean,
           payment_frequency_count: Integer,
-          payment_frequency_interval: Dodopayments::Models::TimeInterval::OrSymbol,
+          payment_frequency_interval: Dodopayments::TimeInterval::OrSymbol,
           previous_billing_date: Time,
           product_id: String,
           quantity: Integer,
           recurring_pre_tax_amount: Integer,
-          status: Dodopayments::Models::SubscriptionStatus::OrSymbol,
+          status: Dodopayments::SubscriptionStatus::OrSymbol,
           subscription_id: String,
           subscription_period_count: Integer,
-          subscription_period_interval: Dodopayments::Models::TimeInterval::OrSymbol,
+          subscription_period_interval: Dodopayments::TimeInterval::OrSymbol,
           tax_inclusive: T::Boolean,
           trial_period_days: Integer,
           cancelled_at: T.nilable(Time),
+          discount_cycles_remaining: T.nilable(Integer),
           discount_id: T.nilable(String)
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
+        # Billing address details for payments
         billing:,
+        # Indicates if the subscription will cancel at the next billing date
+        cancel_at_next_billing_date:,
         # Timestamp when the subscription was created
         created_at:,
+        # Currency used for the subscription payments
         currency:,
+        # Customer details associated with the subscription
         customer:,
+        # Additional custom data associated with the subscription
         metadata:,
         # Timestamp of the next scheduled billing. Indicates the end of current billing
         # period
@@ -131,6 +161,7 @@ module Dodopayments
         on_demand:,
         # Number of payment frequency intervals
         payment_frequency_count:,
+        # Time interval for payment frequency (e.g. month, year)
         payment_frequency_interval:,
         # Timestamp of the last payment. Indicates the start of current billing period
         previous_billing_date:,
@@ -141,11 +172,13 @@ module Dodopayments
         # Amount charged before tax for each recurring payment in smallest currency unit
         # (e.g. cents)
         recurring_pre_tax_amount:,
+        # Current status of the subscription
         status:,
         # Unique identifier for the subscription
         subscription_id:,
         # Number of subscription period intervals
         subscription_period_count:,
+        # Time interval for the subscription period (e.g. month, year)
         subscription_period_interval:,
         # Indicates if the recurring_pre_tax_amount is tax inclusive
         tax_inclusive:,
@@ -153,38 +186,46 @@ module Dodopayments
         trial_period_days:,
         # Cancelled timestamp if the subscription is cancelled
         cancelled_at: nil,
+        # Number of remaining discount cycles if discount is applied
+        discount_cycles_remaining: nil,
         # The discount id if discount is applied
         discount_id: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              billing: Dodopayments::Models::BillingAddress,
-              created_at: Time,
-              currency: Dodopayments::Models::Currency::TaggedSymbol,
-              customer: Dodopayments::Models::CustomerLimitedDetails,
-              metadata: T::Hash[Symbol, String],
-              next_billing_date: Time,
-              on_demand: T::Boolean,
-              payment_frequency_count: Integer,
-              payment_frequency_interval: Dodopayments::Models::TimeInterval::TaggedSymbol,
-              previous_billing_date: Time,
-              product_id: String,
-              quantity: Integer,
-              recurring_pre_tax_amount: Integer,
-              status: Dodopayments::Models::SubscriptionStatus::TaggedSymbol,
-              subscription_id: String,
-              subscription_period_count: Integer,
-              subscription_period_interval: Dodopayments::Models::TimeInterval::TaggedSymbol,
-              tax_inclusive: T::Boolean,
-              trial_period_days: Integer,
-              cancelled_at: T.nilable(Time),
-              discount_id: T.nilable(String)
-            }
-          )
+        override.returns(
+          {
+            billing: Dodopayments::BillingAddress,
+            cancel_at_next_billing_date: T::Boolean,
+            created_at: Time,
+            currency: Dodopayments::Currency::TaggedSymbol,
+            customer: Dodopayments::CustomerLimitedDetails,
+            metadata: T::Hash[Symbol, String],
+            next_billing_date: Time,
+            on_demand: T::Boolean,
+            payment_frequency_count: Integer,
+            payment_frequency_interval:
+              Dodopayments::TimeInterval::TaggedSymbol,
+            previous_billing_date: Time,
+            product_id: String,
+            quantity: Integer,
+            recurring_pre_tax_amount: Integer,
+            status: Dodopayments::SubscriptionStatus::TaggedSymbol,
+            subscription_id: String,
+            subscription_period_count: Integer,
+            subscription_period_interval:
+              Dodopayments::TimeInterval::TaggedSymbol,
+            tax_inclusive: T::Boolean,
+            trial_period_days: Integer,
+            cancelled_at: T.nilable(Time),
+            discount_cycles_remaining: T.nilable(Integer),
+            discount_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
     end
   end
 end

data/rbi/dodopayments/models/subscription_retrieve_params.rbi

@@ -6,14 +6,27 @@ module Dodopayments
       extend Dodopayments::Internal::Type::RequestParameters::Converter
       include Dodopayments::Internal::Type::RequestParameters
 
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::SubscriptionRetrieveParams,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
       sig do
-        params(request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash))
-          .returns(T.attached_class)
+        params(request_options: Dodopayments::RequestOptions::OrHash).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
+      sig do
+        override.returns({ request_options: Dodopayments::RequestOptions })
+      end
+      def to_hash
+      end
     end
   end
 end

data/rbi/dodopayments/models/subscription_status.rbi

@@ -5,19 +5,25 @@ module Dodopayments
     module SubscriptionStatus
       extend Dodopayments::Internal::Type::Enum
 
-      TaggedSymbol = T.type_alias { T.all(Symbol, Dodopayments::Models::SubscriptionStatus) }
+      TaggedSymbol =
+        T.type_alias { T.all(Symbol, Dodopayments::SubscriptionStatus) }
       OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-      PENDING = T.let(:pending, Dodopayments::Models::SubscriptionStatus::TaggedSymbol)
-      ACTIVE = T.let(:active, Dodopayments::Models::SubscriptionStatus::TaggedSymbol)
-      ON_HOLD = T.let(:on_hold, Dodopayments::Models::SubscriptionStatus::TaggedSymbol)
-      PAUSED = T.let(:paused, Dodopayments::Models::SubscriptionStatus::TaggedSymbol)
-      CANCELLED = T.let(:cancelled, Dodopayments::Models::SubscriptionStatus::TaggedSymbol)
-      FAILED = T.let(:failed, Dodopayments::Models::SubscriptionStatus::TaggedSymbol)
-      EXPIRED = T.let(:expired, Dodopayments::Models::SubscriptionStatus::TaggedSymbol)
+      PENDING = T.let(:pending, Dodopayments::SubscriptionStatus::TaggedSymbol)
+      ACTIVE = T.let(:active, Dodopayments::SubscriptionStatus::TaggedSymbol)
+      ON_HOLD = T.let(:on_hold, Dodopayments::SubscriptionStatus::TaggedSymbol)
+      CANCELLED =
+        T.let(:cancelled, Dodopayments::SubscriptionStatus::TaggedSymbol)
+      FAILED = T.let(:failed, Dodopayments::SubscriptionStatus::TaggedSymbol)
+      EXPIRED = T.let(:expired, Dodopayments::SubscriptionStatus::TaggedSymbol)
 
-      sig { override.returns(T::Array[Dodopayments::Models::SubscriptionStatus::TaggedSymbol]) }
-      def self.values; end
+      sig do
+        override.returns(
+          T::Array[Dodopayments::SubscriptionStatus::TaggedSymbol]
+        )
+      end
+      def self.values
+      end
     end
   end
 end

data/rbi/dodopayments/models/subscription_update_params.rbi

@@ -6,32 +6,46 @@ module Dodopayments
       extend Dodopayments::Internal::Type::RequestParameters::Converter
       include Dodopayments::Internal::Type::RequestParameters
 
-      sig { returns(T.nilable(Dodopayments::Models::BillingAddress)) }
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::SubscriptionUpdateParams,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(Dodopayments::BillingAddress)) }
       attr_reader :billing
 
       sig do
-        params(billing: T.nilable(T.any(Dodopayments::Models::BillingAddress, Dodopayments::Internal::AnyHash)))
-          .void
+        params(billing: T.nilable(Dodopayments::BillingAddress::OrHash)).void
       end
       attr_writer :billing
 
-      sig { returns(T.nilable(Dodopayments::Models::SubscriptionUpdateParams::DisableOnDemand)) }
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :cancel_at_next_billing_date
+
+      sig do
+        returns(
+          T.nilable(Dodopayments::SubscriptionUpdateParams::DisableOnDemand)
+        )
+      end
       attr_reader :disable_on_demand
 
       sig do
         params(
-          disable_on_demand: T.nilable(
-            T.any(Dodopayments::Models::SubscriptionUpdateParams::DisableOnDemand, Dodopayments::Internal::AnyHash)
-          )
-        )
-          .void
+          disable_on_demand:
+            T.nilable(
+              Dodopayments::SubscriptionUpdateParams::DisableOnDemand::OrHash
+            )
+        ).void
       end
       attr_writer :disable_on_demand
 
       sig { returns(T.nilable(T::Hash[Symbol, String])) }
       attr_accessor :metadata
 
-      sig { returns(T.nilable(Dodopayments::Models::SubscriptionStatus::OrSymbol)) }
+      sig { returns(T.nilable(Dodopayments::SubscriptionStatus::OrSymbol)) }
       attr_accessor :status
 
       sig { returns(T.nilable(String)) }
@@ -39,19 +53,21 @@ module Dodopayments
 
       sig do
         params(
-          billing: T.nilable(T.any(Dodopayments::Models::BillingAddress, Dodopayments::Internal::AnyHash)),
-          disable_on_demand: T.nilable(
-            T.any(Dodopayments::Models::SubscriptionUpdateParams::DisableOnDemand, Dodopayments::Internal::AnyHash)
-          ),
+          billing: T.nilable(Dodopayments::BillingAddress::OrHash),
+          cancel_at_next_billing_date: T.nilable(T::Boolean),
+          disable_on_demand:
+            T.nilable(
+              Dodopayments::SubscriptionUpdateParams::DisableOnDemand::OrHash
+            ),
           metadata: T.nilable(T::Hash[Symbol, String]),
-          status: T.nilable(Dodopayments::Models::SubscriptionStatus::OrSymbol),
+          status: T.nilable(Dodopayments::SubscriptionStatus::OrSymbol),
           tax_id: T.nilable(String),
-          request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         billing: nil,
+        cancel_at_next_billing_date: nil,
         disable_on_demand: nil,
         metadata: nil,
         status: nil,
@@ -61,29 +77,43 @@ module Dodopayments
       end
 
       sig do
-        override
-          .returns(
-            {
-              billing: T.nilable(Dodopayments::Models::BillingAddress),
-              disable_on_demand: T.nilable(Dodopayments::Models::SubscriptionUpdateParams::DisableOnDemand),
-              metadata: T.nilable(T::Hash[Symbol, String]),
-              status: T.nilable(Dodopayments::Models::SubscriptionStatus::OrSymbol),
-              tax_id: T.nilable(String),
-              request_options: Dodopayments::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            billing: T.nilable(Dodopayments::BillingAddress),
+            cancel_at_next_billing_date: T.nilable(T::Boolean),
+            disable_on_demand:
+              T.nilable(
+                Dodopayments::SubscriptionUpdateParams::DisableOnDemand
+              ),
+            metadata: T.nilable(T::Hash[Symbol, String]),
+            status: T.nilable(Dodopayments::SubscriptionStatus::OrSymbol),
+            tax_id: T.nilable(String),
+            request_options: Dodopayments::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       class DisableOnDemand < Dodopayments::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Dodopayments::SubscriptionUpdateParams::DisableOnDemand,
+              Dodopayments::Internal::AnyHash
+            )
+          end
+
         sig { returns(Time) }
         attr_accessor :next_billing_date
 
         sig { params(next_billing_date: Time).returns(T.attached_class) }
-        def self.new(next_billing_date:); end
+        def self.new(next_billing_date:)
+        end
 
-        sig { override.returns({next_billing_date: Time}) }
-        def to_hash; end
+        sig { override.returns({ next_billing_date: Time }) }
+        def to_hash
+        end
       end
     end
   end

data/rbi/dodopayments/models/tax_category.rbi

@@ -7,16 +7,20 @@ module Dodopayments
     module TaxCategory
       extend Dodopayments::Internal::Type::Enum
 
-      TaggedSymbol = T.type_alias { T.all(Symbol, Dodopayments::Models::TaxCategory) }
+      TaggedSymbol = T.type_alias { T.all(Symbol, Dodopayments::TaxCategory) }
       OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-      DIGITAL_PRODUCTS = T.let(:digital_products, Dodopayments::Models::TaxCategory::TaggedSymbol)
-      SAAS = T.let(:saas, Dodopayments::Models::TaxCategory::TaggedSymbol)
-      E_BOOK = T.let(:e_book, Dodopayments::Models::TaxCategory::TaggedSymbol)
-      EDTECH = T.let(:edtech, Dodopayments::Models::TaxCategory::TaggedSymbol)
+      DIGITAL_PRODUCTS =
+        T.let(:digital_products, Dodopayments::TaxCategory::TaggedSymbol)
+      SAAS = T.let(:saas, Dodopayments::TaxCategory::TaggedSymbol)
+      E_BOOK = T.let(:e_book, Dodopayments::TaxCategory::TaggedSymbol)
+      EDTECH = T.let(:edtech, Dodopayments::TaxCategory::TaggedSymbol)
 
-      sig { override.returns(T::Array[Dodopayments::Models::TaxCategory::TaggedSymbol]) }
-      def self.values; end
+      sig do
+        override.returns(T::Array[Dodopayments::TaxCategory::TaggedSymbol])
+      end
+      def self.values
+      end
     end
   end
 end