orb-billing 0.3.0 → 0.3.2

data/rbi/{lib/orb → orb}/models/subscription.rbi

@@ -3,6 +3,8 @@
 module Orb
   module Models
     class Subscription < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       sig { returns(String) }
       attr_accessor :id
 
@@ -13,7 +15,7 @@ module Orb
 
       # The adjustment intervals for this subscription sorted by the start_date of the
       # adjustment interval.
-      sig { returns(T::Array[Orb::Models::Subscription::AdjustmentInterval]) }
+      sig { returns(T::Array[Orb::Subscription::AdjustmentInterval]) }
       attr_accessor :adjustment_intervals
 
       # Determines whether issued invoices for this subscription will automatically be
@@ -22,14 +24,14 @@ module Orb
       sig { returns(T.nilable(T::Boolean)) }
       attr_accessor :auto_collection
 
-      sig { returns(Orb::Models::Subscription::BillingCycleAnchorConfiguration) }
+      sig { returns(Orb::Subscription::BillingCycleAnchorConfiguration) }
       attr_reader :billing_cycle_anchor_configuration
 
       sig do
         params(
-          billing_cycle_anchor_configuration: T.any(Orb::Models::Subscription::BillingCycleAnchorConfiguration, Orb::Internal::AnyHash)
-        )
-          .void
+          billing_cycle_anchor_configuration:
+            Orb::Subscription::BillingCycleAnchorConfiguration::OrHash
+        ).void
       end
       attr_writer :billing_cycle_anchor_configuration
 
@@ -73,10 +75,10 @@ module Orb
       # [IANA timezone database](https://www.iana.org/time-zones)), which defaults to
       # your account's timezone. See [Timezone localization](/essentials/timezones) for
       # information on what this timezone parameter influences within Orb.
-      sig { returns(Orb::Models::Customer) }
+      sig { returns(Orb::Customer) }
       attr_reader :customer
 
-      sig { params(customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash)).void }
+      sig { params(customer: Orb::Customer::OrHash).void }
       attr_writer :customer
 
       # Determines the default memo on this subscriptions' invoices. Note that if this
@@ -89,9 +91,9 @@ module Orb
         returns(
           T::Array[
             T.any(
-              Orb::Models::Subscription::DiscountInterval::AmountDiscountInterval,
-              Orb::Models::Subscription::DiscountInterval::PercentageDiscountInterval,
-              Orb::Models::Subscription::DiscountInterval::UsageDiscountInterval
+              Orb::Subscription::DiscountInterval::Amount,
+              Orb::Subscription::DiscountInterval::Percentage,
+              Orb::Subscription::DiscountInterval::Usage
             )
           ]
         )
@@ -102,14 +104,14 @@ module Orb
       sig { returns(T.nilable(Time)) }
       attr_accessor :end_date
 
-      sig { returns(T::Array[Orb::Models::Subscription::FixedFeeQuantitySchedule]) }
+      sig { returns(T::Array[Orb::Subscription::FixedFeeQuantitySchedule]) }
       attr_accessor :fixed_fee_quantity_schedule
 
       sig { returns(T.nilable(String)) }
       attr_accessor :invoicing_threshold
 
       # The maximum intervals for this subscription sorted by the start_date.
-      sig { returns(T::Array[Orb::Models::Subscription::MaximumInterval]) }
+      sig { returns(T::Array[Orb::Subscription::MaximumInterval]) }
       attr_accessor :maximum_intervals
 
       # User specified key-value pairs for the resource. If not present, this defaults
@@ -120,7 +122,7 @@ module Orb
       attr_accessor :metadata
 
       # The minimum intervals for this subscription sorted by the start_date.
-      sig { returns(T::Array[Orb::Models::Subscription::MinimumInterval]) }
+      sig { returns(T::Array[Orb::Subscription::MinimumInterval]) }
       attr_accessor :minimum_intervals
 
       # Determines the difference between the invoice issue date for subscription
@@ -131,14 +133,14 @@ module Orb
       attr_accessor :net_terms
 
       # A pending subscription change if one exists on this subscription.
-      sig { returns(T.nilable(Orb::Models::Subscription::PendingSubscriptionChange)) }
+      sig { returns(T.nilable(Orb::Subscription::PendingSubscriptionChange)) }
       attr_reader :pending_subscription_change
 
       sig do
         params(
-          pending_subscription_change: T.nilable(T.any(Orb::Models::Subscription::PendingSubscriptionChange, Orb::Internal::AnyHash))
-        )
-          .void
+          pending_subscription_change:
+            T.nilable(Orb::Subscription::PendingSubscriptionChange::OrHash)
+        ).void
       end
       attr_writer :pending_subscription_change
 
@@ -146,24 +148,23 @@ module Orb
       # subscribed to by a customer. Plans define the billing behavior of the
       # subscription. You can see more about how to configure prices in the
       # [Price resource](/reference/price).
-      sig { returns(Orb::Models::Plan) }
+      sig { returns(Orb::Plan) }
       attr_reader :plan
 
-      sig { params(plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash)).void }
+      sig { params(plan: Orb::Plan::OrHash).void }
       attr_writer :plan
 
       # The price intervals for this subscription.
-      sig { returns(T::Array[Orb::Models::Subscription::PriceInterval]) }
+      sig { returns(T::Array[Orb::Subscription::PriceInterval]) }
       attr_accessor :price_intervals
 
-      sig { returns(T.nilable(Orb::Models::Subscription::RedeemedCoupon)) }
+      sig { returns(T.nilable(Orb::Subscription::RedeemedCoupon)) }
       attr_reader :redeemed_coupon
 
       sig do
         params(
-          redeemed_coupon: T.nilable(T.any(Orb::Models::Subscription::RedeemedCoupon, Orb::Internal::AnyHash))
-        )
-          .void
+          redeemed_coupon: T.nilable(Orb::Subscription::RedeemedCoupon::OrHash)
+        ).void
       end
       attr_writer :redeemed_coupon
 
@@ -171,13 +172,13 @@ module Orb
       sig { returns(Time) }
       attr_accessor :start_date
 
-      sig { returns(Orb::Models::Subscription::Status::TaggedSymbol) }
+      sig { returns(Orb::Subscription::Status::TaggedSymbol) }
       attr_accessor :status
 
-      sig { returns(Orb::Models::Subscription::TrialInfo) }
+      sig { returns(Orb::Subscription::TrialInfo) }
       attr_reader :trial_info
 
-      sig { params(trial_info: T.any(Orb::Models::Subscription::TrialInfo, Orb::Internal::AnyHash)).void }
+      sig { params(trial_info: Orb::Subscription::TrialInfo::OrHash).void }
       attr_writer :trial_info
 
       # A [subscription](/core-concepts#subscription) represents the purchase of a plan
@@ -203,39 +204,44 @@ module Orb
         params(
           id: String,
           active_plan_phase_order: T.nilable(Integer),
-          adjustment_intervals: T::Array[T.any(Orb::Models::Subscription::AdjustmentInterval, Orb::Internal::AnyHash)],
+          adjustment_intervals:
+            T::Array[Orb::Subscription::AdjustmentInterval::OrHash],
           auto_collection: T.nilable(T::Boolean),
-          billing_cycle_anchor_configuration: T.any(Orb::Models::Subscription::BillingCycleAnchorConfiguration, Orb::Internal::AnyHash),
+          billing_cycle_anchor_configuration:
+            Orb::Subscription::BillingCycleAnchorConfiguration::OrHash,
           billing_cycle_day: Integer,
           created_at: Time,
           current_billing_period_end_date: T.nilable(Time),
           current_billing_period_start_date: T.nilable(Time),
-          customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash),
+          customer: Orb::Customer::OrHash,
           default_invoice_memo: T.nilable(String),
-          discount_intervals: T::Array[
-            T.any(
-              Orb::Models::Subscription::DiscountInterval::AmountDiscountInterval,
-              Orb::Internal::AnyHash,
-              Orb::Models::Subscription::DiscountInterval::PercentageDiscountInterval,
-              Orb::Models::Subscription::DiscountInterval::UsageDiscountInterval
-            )
-          ],
+          discount_intervals:
+            T::Array[
+              T.any(
+                Orb::Subscription::DiscountInterval::Amount::OrHash,
+                Orb::Subscription::DiscountInterval::Percentage::OrHash,
+                Orb::Subscription::DiscountInterval::Usage::OrHash
+              )
+            ],
           end_date: T.nilable(Time),
-          fixed_fee_quantity_schedule: T::Array[T.any(Orb::Models::Subscription::FixedFeeQuantitySchedule, Orb::Internal::AnyHash)],
+          fixed_fee_quantity_schedule:
+            T::Array[Orb::Subscription::FixedFeeQuantitySchedule::OrHash],
           invoicing_threshold: T.nilable(String),
-          maximum_intervals: T::Array[T.any(Orb::Models::Subscription::MaximumInterval, Orb::Internal::AnyHash)],
+          maximum_intervals:
+            T::Array[Orb::Subscription::MaximumInterval::OrHash],
           metadata: T::Hash[Symbol, String],
-          minimum_intervals: T::Array[T.any(Orb::Models::Subscription::MinimumInterval, Orb::Internal::AnyHash)],
+          minimum_intervals:
+            T::Array[Orb::Subscription::MinimumInterval::OrHash],
           net_terms: Integer,
-          pending_subscription_change: T.nilable(T.any(Orb::Models::Subscription::PendingSubscriptionChange, Orb::Internal::AnyHash)),
-          plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash),
-          price_intervals: T::Array[T.any(Orb::Models::Subscription::PriceInterval, Orb::Internal::AnyHash)],
-          redeemed_coupon: T.nilable(T.any(Orb::Models::Subscription::RedeemedCoupon, Orb::Internal::AnyHash)),
+          pending_subscription_change:
+            T.nilable(Orb::Subscription::PendingSubscriptionChange::OrHash),
+          plan: Orb::Plan::OrHash,
+          price_intervals: T::Array[Orb::Subscription::PriceInterval::OrHash],
+          redeemed_coupon: T.nilable(Orb::Subscription::RedeemedCoupon::OrHash),
           start_date: Time,
-          status: Orb::Models::Subscription::Status::OrSymbol,
-          trial_info: T.any(Orb::Models::Subscription::TrialInfo, Orb::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          status: Orb::Subscription::Status::OrSymbol,
+          trial_info: Orb::Subscription::TrialInfo::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         id:,
@@ -320,60 +326,69 @@ module Orb
         start_date:,
         status:,
         trial_info:
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              id: String,
-              active_plan_phase_order: T.nilable(Integer),
-              adjustment_intervals: T::Array[Orb::Models::Subscription::AdjustmentInterval],
-              auto_collection: T.nilable(T::Boolean),
-              billing_cycle_anchor_configuration: Orb::Models::Subscription::BillingCycleAnchorConfiguration,
-              billing_cycle_day: Integer,
-              created_at: Time,
-              current_billing_period_end_date: T.nilable(Time),
-              current_billing_period_start_date: T.nilable(Time),
-              customer: Orb::Models::Customer,
-              default_invoice_memo: T.nilable(String),
-              discount_intervals: T::Array[
+        override.returns(
+          {
+            id: String,
+            active_plan_phase_order: T.nilable(Integer),
+            adjustment_intervals:
+              T::Array[Orb::Subscription::AdjustmentInterval],
+            auto_collection: T.nilable(T::Boolean),
+            billing_cycle_anchor_configuration:
+              Orb::Subscription::BillingCycleAnchorConfiguration,
+            billing_cycle_day: Integer,
+            created_at: Time,
+            current_billing_period_end_date: T.nilable(Time),
+            current_billing_period_start_date: T.nilable(Time),
+            customer: Orb::Customer,
+            default_invoice_memo: T.nilable(String),
+            discount_intervals:
+              T::Array[
                 T.any(
-                  Orb::Models::Subscription::DiscountInterval::AmountDiscountInterval,
-                  Orb::Models::Subscription::DiscountInterval::PercentageDiscountInterval,
-                  Orb::Models::Subscription::DiscountInterval::UsageDiscountInterval
+                  Orb::Subscription::DiscountInterval::Amount,
+                  Orb::Subscription::DiscountInterval::Percentage,
+                  Orb::Subscription::DiscountInterval::Usage
                 )
               ],
-              end_date: T.nilable(Time),
-              fixed_fee_quantity_schedule: T::Array[Orb::Models::Subscription::FixedFeeQuantitySchedule],
-              invoicing_threshold: T.nilable(String),
-              maximum_intervals: T::Array[Orb::Models::Subscription::MaximumInterval],
-              metadata: T::Hash[Symbol, String],
-              minimum_intervals: T::Array[Orb::Models::Subscription::MinimumInterval],
-              net_terms: Integer,
-              pending_subscription_change: T.nilable(Orb::Models::Subscription::PendingSubscriptionChange),
-              plan: Orb::Models::Plan,
-              price_intervals: T::Array[Orb::Models::Subscription::PriceInterval],
-              redeemed_coupon: T.nilable(Orb::Models::Subscription::RedeemedCoupon),
-              start_date: Time,
-              status: Orb::Models::Subscription::Status::TaggedSymbol,
-              trial_info: Orb::Models::Subscription::TrialInfo
-            }
-          )
+            end_date: T.nilable(Time),
+            fixed_fee_quantity_schedule:
+              T::Array[Orb::Subscription::FixedFeeQuantitySchedule],
+            invoicing_threshold: T.nilable(String),
+            maximum_intervals: T::Array[Orb::Subscription::MaximumInterval],
+            metadata: T::Hash[Symbol, String],
+            minimum_intervals: T::Array[Orb::Subscription::MinimumInterval],
+            net_terms: Integer,
+            pending_subscription_change:
+              T.nilable(Orb::Subscription::PendingSubscriptionChange),
+            plan: Orb::Plan,
+            price_intervals: T::Array[Orb::Subscription::PriceInterval],
+            redeemed_coupon: T.nilable(Orb::Subscription::RedeemedCoupon),
+            start_date: Time,
+            status: Orb::Subscription::Status::TaggedSymbol,
+            trial_info: Orb::Subscription::TrialInfo
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       class AdjustmentInterval < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         sig { returns(String) }
         attr_accessor :id
 
         sig do
           returns(
             T.any(
-              Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseUsageDiscountAdjustment,
-              Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseAmountDiscountAdjustment,
-              Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhasePercentageDiscountAdjustment,
-              Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseMinimumAdjustment,
-              Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment
+              Orb::Subscription::AdjustmentInterval::Adjustment::UsageDiscount,
+              Orb::Subscription::AdjustmentInterval::Adjustment::AmountDiscount,
+              Orb::Subscription::AdjustmentInterval::Adjustment::PercentageDiscount,
+              Orb::Subscription::AdjustmentInterval::Adjustment::Minimum,
+              Orb::Subscription::AdjustmentInterval::Adjustment::Maximum
             )
           )
         end
@@ -394,19 +409,18 @@ module Orb
         sig do
           params(
             id: String,
-            adjustment: T.any(
-              Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseUsageDiscountAdjustment,
-              Orb::Internal::AnyHash,
-              Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseAmountDiscountAdjustment,
-              Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhasePercentageDiscountAdjustment,
-              Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseMinimumAdjustment,
-              Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment
-            ),
+            adjustment:
+              T.any(
+                Orb::Subscription::AdjustmentInterval::Adjustment::UsageDiscount::OrHash,
+                Orb::Subscription::AdjustmentInterval::Adjustment::AmountDiscount::OrHash,
+                Orb::Subscription::AdjustmentInterval::Adjustment::PercentageDiscount::OrHash,
+                Orb::Subscription::AdjustmentInterval::Adjustment::Minimum::OrHash,
+                Orb::Subscription::AdjustmentInterval::Adjustment::Maximum::OrHash
+              ),
             applies_to_price_interval_ids: T::Array[String],
             end_date: T.nilable(Time),
             start_date: Time
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           id:,
@@ -417,31 +431,47 @@ module Orb
           end_date:,
           # The start date of the adjustment interval.
           start_date:
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                id: String,
-                adjustment: T.any(
-                  Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseUsageDiscountAdjustment,
-                  Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseAmountDiscountAdjustment,
-                  Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhasePercentageDiscountAdjustment,
-                  Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseMinimumAdjustment,
-                  Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment
+          override.returns(
+            {
+              id: String,
+              adjustment:
+                T.any(
+                  Orb::Subscription::AdjustmentInterval::Adjustment::UsageDiscount,
+                  Orb::Subscription::AdjustmentInterval::Adjustment::AmountDiscount,
+                  Orb::Subscription::AdjustmentInterval::Adjustment::PercentageDiscount,
+                  Orb::Subscription::AdjustmentInterval::Adjustment::Minimum,
+                  Orb::Subscription::AdjustmentInterval::Adjustment::Maximum
                 ),
-                applies_to_price_interval_ids: T::Array[String],
-                end_date: T.nilable(Time),
-                start_date: Time
-              }
-            )
+              applies_to_price_interval_ids: T::Array[String],
+              end_date: T.nilable(Time),
+              start_date: Time
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         module Adjustment
           extend Orb::Internal::Type::Union
 
-          class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel
+          Variants =
+            T.type_alias do
+              T.any(
+                Orb::Subscription::AdjustmentInterval::Adjustment::UsageDiscount,
+                Orb::Subscription::AdjustmentInterval::Adjustment::AmountDiscount,
+                Orb::Subscription::AdjustmentInterval::Adjustment::PercentageDiscount,
+                Orb::Subscription::AdjustmentInterval::Adjustment::Minimum,
+                Orb::Subscription::AdjustmentInterval::Adjustment::Maximum
+              )
+            end
+
+          class UsageDiscount < Orb::Internal::Type::BaseModel
+            OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
             sig { returns(String) }
             attr_accessor :id
 
@@ -479,8 +509,7 @@ module Orb
                 reason: T.nilable(String),
                 usage_discount: Float,
                 adjustment_type: Symbol
-              )
-                .returns(T.attached_class)
+              ).returns(T.attached_class)
             end
             def self.new(
               id:,
@@ -497,25 +526,29 @@ module Orb
               # to in a given billing period.
               usage_discount:,
               adjustment_type: :usage_discount
-            ); end
+            )
+            end
+
             sig do
-              override
-                .returns(
-                  {
-                    id: String,
-                    adjustment_type: Symbol,
-                    applies_to_price_ids: T::Array[String],
-                    is_invoice_level: T::Boolean,
-                    plan_phase_order: T.nilable(Integer),
-                    reason: T.nilable(String),
-                    usage_discount: Float
-                  }
-                )
+              override.returns(
+                {
+                  id: String,
+                  adjustment_type: Symbol,
+                  applies_to_price_ids: T::Array[String],
+                  is_invoice_level: T::Boolean,
+                  plan_phase_order: T.nilable(Integer),
+                  reason: T.nilable(String),
+                  usage_discount: Float
+                }
+              )
+            end
+            def to_hash
             end
-            def to_hash; end
           end
 
-          class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel
+          class AmountDiscount < Orb::Internal::Type::BaseModel
+            OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
             sig { returns(String) }
             attr_accessor :id
 
@@ -553,8 +586,7 @@ module Orb
                 plan_phase_order: T.nilable(Integer),
                 reason: T.nilable(String),
                 adjustment_type: Symbol
-              )
-                .returns(T.attached_class)
+              ).returns(T.attached_class)
             end
             def self.new(
               id:,
@@ -571,25 +603,29 @@ module Orb
               # The reason for the adjustment.
               reason:,
               adjustment_type: :amount_discount
-            ); end
+            )
+            end
+
             sig do
-              override
-                .returns(
-                  {
-                    id: String,
-                    adjustment_type: Symbol,
-                    amount_discount: String,
-                    applies_to_price_ids: T::Array[String],
-                    is_invoice_level: T::Boolean,
-                    plan_phase_order: T.nilable(Integer),
-                    reason: T.nilable(String)
-                  }
-                )
+              override.returns(
+                {
+                  id: String,
+                  adjustment_type: Symbol,
+                  amount_discount: String,
+                  applies_to_price_ids: T::Array[String],
+                  is_invoice_level: T::Boolean,
+                  plan_phase_order: T.nilable(Integer),
+                  reason: T.nilable(String)
+                }
+              )
+            end
+            def to_hash
             end
-            def to_hash; end
           end
 
-          class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel
+          class PercentageDiscount < Orb::Internal::Type::BaseModel
+            OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
             sig { returns(String) }
             attr_accessor :id
 
@@ -627,8 +663,7 @@ module Orb
                 plan_phase_order: T.nilable(Integer),
                 reason: T.nilable(String),
                 adjustment_type: Symbol
-              )
-                .returns(T.attached_class)
+              ).returns(T.attached_class)
             end
             def self.new(
               id:,
@@ -645,25 +680,29 @@ module Orb
               # The reason for the adjustment.
               reason:,
               adjustment_type: :percentage_discount
-            ); end
+            )
+            end
+
             sig do
-              override
-                .returns(
-                  {
-                    id: String,
-                    adjustment_type: Symbol,
-                    applies_to_price_ids: T::Array[String],
-                    is_invoice_level: T::Boolean,
-                    percentage_discount: Float,
-                    plan_phase_order: T.nilable(Integer),
-                    reason: T.nilable(String)
-                  }
-                )
+              override.returns(
+                {
+                  id: String,
+                  adjustment_type: Symbol,
+                  applies_to_price_ids: T::Array[String],
+                  is_invoice_level: T::Boolean,
+                  percentage_discount: Float,
+                  plan_phase_order: T.nilable(Integer),
+                  reason: T.nilable(String)
+                }
+              )
+            end
+            def to_hash
             end
-            def to_hash; end
           end
 
-          class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel
+          class Minimum < Orb::Internal::Type::BaseModel
+            OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
             sig { returns(String) }
             attr_accessor :id
 
@@ -706,8 +745,7 @@ module Orb
                 plan_phase_order: T.nilable(Integer),
                 reason: T.nilable(String),
                 adjustment_type: Symbol
-              )
-                .returns(T.attached_class)
+              ).returns(T.attached_class)
             end
             def self.new(
               id:,
@@ -726,26 +764,30 @@ module Orb
               # The reason for the adjustment.
               reason:,
               adjustment_type: :minimum
-            ); end
+            )
+            end
+
             sig do
-              override
-                .returns(
-                  {
-                    id: String,
-                    adjustment_type: Symbol,
-                    applies_to_price_ids: T::Array[String],
-                    is_invoice_level: T::Boolean,
-                    item_id: String,
-                    minimum_amount: String,
-                    plan_phase_order: T.nilable(Integer),
-                    reason: T.nilable(String)
-                  }
-                )
+              override.returns(
+                {
+                  id: String,
+                  adjustment_type: Symbol,
+                  applies_to_price_ids: T::Array[String],
+                  is_invoice_level: T::Boolean,
+                  item_id: String,
+                  minimum_amount: String,
+                  plan_phase_order: T.nilable(Integer),
+                  reason: T.nilable(String)
+                }
+              )
+            end
+            def to_hash
             end
-            def to_hash; end
           end
 
-          class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel
+          class Maximum < Orb::Internal::Type::BaseModel
+            OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
             sig { returns(String) }
             attr_accessor :id
 
@@ -783,8 +825,7 @@ module Orb
                 plan_phase_order: T.nilable(Integer),
                 reason: T.nilable(String),
                 adjustment_type: Symbol
-              )
-                .returns(T.attached_class)
+              ).returns(T.attached_class)
             end
             def self.new(
               id:,
@@ -801,35 +842,41 @@ module Orb
               # The reason for the adjustment.
               reason:,
               adjustment_type: :maximum
-            ); end
+            )
+            end
+
             sig do
-              override
-                .returns(
-                  {
-                    id: String,
-                    adjustment_type: Symbol,
-                    applies_to_price_ids: T::Array[String],
-                    is_invoice_level: T::Boolean,
-                    maximum_amount: String,
-                    plan_phase_order: T.nilable(Integer),
-                    reason: T.nilable(String)
-                  }
-                )
+              override.returns(
+                {
+                  id: String,
+                  adjustment_type: Symbol,
+                  applies_to_price_ids: T::Array[String],
+                  is_invoice_level: T::Boolean,
+                  maximum_amount: String,
+                  plan_phase_order: T.nilable(Integer),
+                  reason: T.nilable(String)
+                }
+              )
+            end
+            def to_hash
             end
-            def to_hash; end
           end
 
           sig do
-            override
-              .returns(
-                [Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseUsageDiscountAdjustment, Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseAmountDiscountAdjustment, Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhasePercentageDiscountAdjustment, Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseMinimumAdjustment, Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment]
-              )
+            override.returns(
+              T::Array[
+                Orb::Subscription::AdjustmentInterval::Adjustment::Variants
+              ]
+            )
+          end
+          def self.variants
           end
-          def self.variants; end
         end
       end
 
       class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         # The day of the month on which the billing cycle is anchored. If the maximum
         # number of days in a month is greater than this value, the last day of the month
         # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing
@@ -849,7 +896,11 @@ module Orb
         attr_accessor :year
 
         sig do
-          params(day: Integer, month: T.nilable(Integer), year: T.nilable(Integer)).returns(T.attached_class)
+          params(
+            day: Integer,
+            month: T.nilable(Integer),
+            year: T.nilable(Integer)
+          ).returns(T.attached_class)
         end
         def self.new(
           # The day of the month on which the billing cycle is anchored. If the maximum
@@ -864,15 +915,37 @@ module Orb
           # The year on which the billing cycle is anchored (e.g. a 2 year billing cycle
           # anchored on 2021 would have cycles starting on 2021, 2023, 2025, etc.).
           year: nil
-        ); end
-        sig { override.returns({day: Integer, month: T.nilable(Integer), year: T.nilable(Integer)}) }
-        def to_hash; end
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              day: Integer,
+              month: T.nilable(Integer),
+              year: T.nilable(Integer)
+            }
+          )
+        end
+        def to_hash
+        end
       end
 
       module DiscountInterval
         extend Orb::Internal::Type::Union
 
-        class AmountDiscountInterval < Orb::Internal::Type::BaseModel
+        Variants =
+          T.type_alias do
+            T.any(
+              Orb::Subscription::DiscountInterval::Amount,
+              Orb::Subscription::DiscountInterval::Percentage,
+              Orb::Subscription::DiscountInterval::Usage
+            )
+          end
+
+        class Amount < Orb::Internal::Type::BaseModel
+          OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
           # Only available if discount_type is `amount`.
           sig { returns(String) }
           attr_accessor :amount_discount
@@ -904,8 +977,7 @@ module Orb
               end_date: T.nilable(Time),
               start_date: Time,
               discount_type: Symbol
-            )
-              .returns(T.attached_class)
+            ).returns(T.attached_class)
           end
           def self.new(
             # Only available if discount_type is `amount`.
@@ -919,24 +991,28 @@ module Orb
             # The start date of the discount interval.
             start_date:,
             discount_type: :amount
-          ); end
+          )
+          end
+
           sig do
-            override
-              .returns(
-                {
-                  amount_discount: String,
-                  applies_to_price_ids: T::Array[String],
-                  applies_to_price_interval_ids: T::Array[String],
-                  discount_type: Symbol,
-                  end_date: T.nilable(Time),
-                  start_date: Time
-                }
-              )
+            override.returns(
+              {
+                amount_discount: String,
+                applies_to_price_ids: T::Array[String],
+                applies_to_price_interval_ids: T::Array[String],
+                discount_type: Symbol,
+                end_date: T.nilable(Time),
+                start_date: Time
+              }
+            )
+          end
+          def to_hash
           end
-          def to_hash; end
         end
 
-        class PercentageDiscountInterval < Orb::Internal::Type::BaseModel
+        class Percentage < Orb::Internal::Type::BaseModel
+          OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
           # The price ids that this discount interval applies to.
           sig { returns(T::Array[String]) }
           attr_accessor :applies_to_price_ids
@@ -969,8 +1045,7 @@ module Orb
               percentage_discount: Float,
               start_date: Time,
               discount_type: Symbol
-            )
-              .returns(T.attached_class)
+            ).returns(T.attached_class)
           end
           def self.new(
             # The price ids that this discount interval applies to.
@@ -985,24 +1060,28 @@ module Orb
             # The start date of the discount interval.
             start_date:,
             discount_type: :percentage
-          ); end
+          )
+          end
+
           sig do
-            override
-              .returns(
-                {
-                  applies_to_price_ids: T::Array[String],
-                  applies_to_price_interval_ids: T::Array[String],
-                  discount_type: Symbol,
-                  end_date: T.nilable(Time),
-                  percentage_discount: Float,
-                  start_date: Time
-                }
-              )
+            override.returns(
+              {
+                applies_to_price_ids: T::Array[String],
+                applies_to_price_interval_ids: T::Array[String],
+                discount_type: Symbol,
+                end_date: T.nilable(Time),
+                percentage_discount: Float,
+                start_date: Time
+              }
+            )
+          end
+          def to_hash
           end
-          def to_hash; end
         end
 
-        class UsageDiscountInterval < Orb::Internal::Type::BaseModel
+        class Usage < Orb::Internal::Type::BaseModel
+          OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
           # The price ids that this discount interval applies to.
           sig { returns(T::Array[String]) }
           attr_accessor :applies_to_price_ids
@@ -1035,8 +1114,7 @@ module Orb
               start_date: Time,
               usage_discount: Float,
               discount_type: Symbol
-            )
-              .returns(T.attached_class)
+            ).returns(T.attached_class)
           end
           def self.new(
             # The price ids that this discount interval applies to.
@@ -1051,33 +1129,37 @@ module Orb
             # discount is for
             usage_discount:,
             discount_type: :usage
-          ); end
+          )
+          end
+
           sig do
-            override
-              .returns(
-                {
-                  applies_to_price_ids: T::Array[String],
-                  applies_to_price_interval_ids: T::Array[String],
-                  discount_type: Symbol,
-                  end_date: T.nilable(Time),
-                  start_date: Time,
-                  usage_discount: Float
-                }
-              )
+            override.returns(
+              {
+                applies_to_price_ids: T::Array[String],
+                applies_to_price_interval_ids: T::Array[String],
+                discount_type: Symbol,
+                end_date: T.nilable(Time),
+                start_date: Time,
+                usage_discount: Float
+              }
+            )
+          end
+          def to_hash
           end
-          def to_hash; end
         end
 
         sig do
-          override
-            .returns(
-              [Orb::Models::Subscription::DiscountInterval::AmountDiscountInterval, Orb::Models::Subscription::DiscountInterval::PercentageDiscountInterval, Orb::Models::Subscription::DiscountInterval::UsageDiscountInterval]
-            )
+          override.returns(
+            T::Array[Orb::Subscription::DiscountInterval::Variants]
+          )
+        end
+        def self.variants
         end
-        def self.variants; end
       end
 
       class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         sig { returns(T.nilable(Time)) }
         attr_accessor :end_date
 
@@ -1091,18 +1173,33 @@ module Orb
         attr_accessor :start_date
 
         sig do
-          params(end_date: T.nilable(Time), price_id: String, quantity: Float, start_date: Time)
-            .returns(T.attached_class)
+          params(
+            end_date: T.nilable(Time),
+            price_id: String,
+            quantity: Float,
+            start_date: Time
+          ).returns(T.attached_class)
+        end
+        def self.new(end_date:, price_id:, quantity:, start_date:)
         end
-        def self.new(end_date:, price_id:, quantity:, start_date:); end
 
         sig do
-          override.returns({end_date: T.nilable(Time), price_id: String, quantity: Float, start_date: Time})
+          override.returns(
+            {
+              end_date: T.nilable(Time),
+              price_id: String,
+              quantity: Float,
+              start_date: Time
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
 
       class MaximumInterval < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         # The price ids that this maximum interval applies to.
         sig { returns(T::Array[String]) }
         attr_accessor :applies_to_price_ids
@@ -1131,8 +1228,7 @@ module Orb
             end_date: T.nilable(Time),
             maximum_amount: String,
             start_date: Time
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # The price ids that this maximum interval applies to.
@@ -1146,23 +1242,27 @@ module Orb
           maximum_amount:,
           # The start date of the maximum interval.
           start_date:
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                applies_to_price_ids: T::Array[String],
-                applies_to_price_interval_ids: T::Array[String],
-                end_date: T.nilable(Time),
-                maximum_amount: String,
-                start_date: Time
-              }
-            )
+          override.returns(
+            {
+              applies_to_price_ids: T::Array[String],
+              applies_to_price_interval_ids: T::Array[String],
+              end_date: T.nilable(Time),
+              maximum_amount: String,
+              start_date: Time
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
 
       class MinimumInterval < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         # The price ids that this minimum interval applies to.
         sig { returns(T::Array[String]) }
         attr_accessor :applies_to_price_ids
@@ -1191,8 +1291,7 @@ module Orb
             end_date: T.nilable(Time),
             minimum_amount: String,
             start_date: Time
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # The price ids that this minimum interval applies to.
@@ -1206,35 +1305,43 @@ module Orb
           minimum_amount:,
           # The start date of the minimum interval.
           start_date:
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                applies_to_price_ids: T::Array[String],
-                applies_to_price_interval_ids: T::Array[String],
-                end_date: T.nilable(Time),
-                minimum_amount: String,
-                start_date: Time
-              }
-            )
+          override.returns(
+            {
+              applies_to_price_ids: T::Array[String],
+              applies_to_price_interval_ids: T::Array[String],
+              end_date: T.nilable(Time),
+              minimum_amount: String,
+              start_date: Time
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
 
       class PendingSubscriptionChange < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         sig { returns(String) }
         attr_accessor :id
 
         # A pending subscription change if one exists on this subscription.
         sig { params(id: String).returns(T.attached_class) }
-        def self.new(id:); end
+        def self.new(id:)
+        end
 
-        sig { override.returns({id: String}) }
-        def to_hash; end
+        sig { override.returns({ id: String }) }
+        def to_hash
+        end
       end
 
       class PriceInterval < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         sig { returns(String) }
         attr_accessor :id
 
@@ -1265,7 +1372,15 @@ module Orb
 
         # The fixed fee quantity transitions for this price interval. This is only
         # relevant for fixed fees.
-        sig { returns(T.nilable(T::Array[Orb::Models::Subscription::PriceInterval::FixedFeeQuantityTransition])) }
+        sig do
+          returns(
+            T.nilable(
+              T::Array[
+                Orb::Subscription::PriceInterval::FixedFeeQuantityTransition
+              ]
+            )
+          )
+        end
         attr_accessor :fixed_fee_quantity_transitions
 
         # The Price resource represents a price that can be billed on a subscription,
@@ -1281,34 +1396,34 @@ module Orb
         sig do
           returns(
             T.any(
-              Orb::Models::Price::UnitPrice,
-              Orb::Models::Price::PackagePrice,
-              Orb::Models::Price::MatrixPrice,
-              Orb::Models::Price::TieredPrice,
-              Orb::Models::Price::TieredBpsPrice,
-              Orb::Models::Price::BpsPrice,
-              Orb::Models::Price::BulkBpsPrice,
-              Orb::Models::Price::BulkPrice,
-              Orb::Models::Price::ThresholdTotalAmountPrice,
-              Orb::Models::Price::TieredPackagePrice,
-              Orb::Models::Price::GroupedTieredPrice,
-              Orb::Models::Price::TieredWithMinimumPrice,
-              Orb::Models::Price::TieredPackageWithMinimumPrice,
-              Orb::Models::Price::PackageWithAllocationPrice,
-              Orb::Models::Price::UnitWithPercentPrice,
-              Orb::Models::Price::MatrixWithAllocationPrice,
-              Orb::Models::Price::TieredWithProrationPrice,
-              Orb::Models::Price::UnitWithProrationPrice,
-              Orb::Models::Price::GroupedAllocationPrice,
-              Orb::Models::Price::GroupedWithProratedMinimumPrice,
-              Orb::Models::Price::GroupedWithMeteredMinimumPrice,
-              Orb::Models::Price::MatrixWithDisplayNamePrice,
-              Orb::Models::Price::BulkWithProrationPrice,
-              Orb::Models::Price::GroupedTieredPackagePrice,
-              Orb::Models::Price::MaxGroupTieredPackagePrice,
-              Orb::Models::Price::ScalableMatrixWithUnitPricingPrice,
-              Orb::Models::Price::ScalableMatrixWithTieredPricingPrice,
-              Orb::Models::Price::CumulativeGroupedBulkPrice
+              Orb::Price::Unit,
+              Orb::Price::Package,
+              Orb::Price::Matrix,
+              Orb::Price::Tiered,
+              Orb::Price::TieredBps,
+              Orb::Price::Bps,
+              Orb::Price::BulkBps,
+              Orb::Price::Bulk,
+              Orb::Price::ThresholdTotalAmount,
+              Orb::Price::TieredPackage,
+              Orb::Price::GroupedTiered,
+              Orb::Price::TieredWithMinimum,
+              Orb::Price::TieredPackageWithMinimum,
+              Orb::Price::PackageWithAllocation,
+              Orb::Price::UnitWithPercent,
+              Orb::Price::MatrixWithAllocation,
+              Orb::Price::TieredWithProration,
+              Orb::Price::UnitWithProration,
+              Orb::Price::GroupedAllocation,
+              Orb::Price::GroupedWithProratedMinimum,
+              Orb::Price::GroupedWithMeteredMinimum,
+              Orb::Price::MatrixWithDisplayName,
+              Orb::Price::BulkWithProration,
+              Orb::Price::GroupedTieredPackage,
+              Orb::Price::MaxGroupTieredPackage,
+              Orb::Price::ScalableMatrixWithUnitPricing,
+              Orb::Price::ScalableMatrixWithTieredPricing,
+              Orb::Price::CumulativeGroupedBulk
             )
           )
         end
@@ -1335,44 +1450,46 @@ module Orb
             current_billing_period_start_date: T.nilable(Time),
             end_date: T.nilable(Time),
             filter: T.nilable(String),
-            fixed_fee_quantity_transitions: T.nilable(
-              T::Array[T.any(Orb::Models::Subscription::PriceInterval::FixedFeeQuantityTransition, Orb::Internal::AnyHash)]
-            ),
-            price: T.any(
-              Orb::Models::Price::UnitPrice,
-              Orb::Internal::AnyHash,
-              Orb::Models::Price::PackagePrice,
-              Orb::Models::Price::MatrixPrice,
-              Orb::Models::Price::TieredPrice,
-              Orb::Models::Price::TieredBpsPrice,
-              Orb::Models::Price::BpsPrice,
-              Orb::Models::Price::BulkBpsPrice,
-              Orb::Models::Price::BulkPrice,
-              Orb::Models::Price::ThresholdTotalAmountPrice,
-              Orb::Models::Price::TieredPackagePrice,
-              Orb::Models::Price::GroupedTieredPrice,
-              Orb::Models::Price::TieredWithMinimumPrice,
-              Orb::Models::Price::TieredPackageWithMinimumPrice,
-              Orb::Models::Price::PackageWithAllocationPrice,
-              Orb::Models::Price::UnitWithPercentPrice,
-              Orb::Models::Price::MatrixWithAllocationPrice,
-              Orb::Models::Price::TieredWithProrationPrice,
-              Orb::Models::Price::UnitWithProrationPrice,
-              Orb::Models::Price::GroupedAllocationPrice,
-              Orb::Models::Price::GroupedWithProratedMinimumPrice,
-              Orb::Models::Price::GroupedWithMeteredMinimumPrice,
-              Orb::Models::Price::MatrixWithDisplayNamePrice,
-              Orb::Models::Price::BulkWithProrationPrice,
-              Orb::Models::Price::GroupedTieredPackagePrice,
-              Orb::Models::Price::MaxGroupTieredPackagePrice,
-              Orb::Models::Price::ScalableMatrixWithUnitPricingPrice,
-              Orb::Models::Price::ScalableMatrixWithTieredPricingPrice,
-              Orb::Models::Price::CumulativeGroupedBulkPrice
-            ),
+            fixed_fee_quantity_transitions:
+              T.nilable(
+                T::Array[
+                  Orb::Subscription::PriceInterval::FixedFeeQuantityTransition::OrHash
+                ]
+              ),
+            price:
+              T.any(
+                Orb::Price::Unit::OrHash,
+                Orb::Price::Package::OrHash,
+                Orb::Price::Matrix::OrHash,
+                Orb::Price::Tiered::OrHash,
+                Orb::Price::TieredBps::OrHash,
+                Orb::Price::Bps::OrHash,
+                Orb::Price::BulkBps::OrHash,
+                Orb::Price::Bulk::OrHash,
+                Orb::Price::ThresholdTotalAmount::OrHash,
+                Orb::Price::TieredPackage::OrHash,
+                Orb::Price::GroupedTiered::OrHash,
+                Orb::Price::TieredWithMinimum::OrHash,
+                Orb::Price::TieredPackageWithMinimum::OrHash,
+                Orb::Price::PackageWithAllocation::OrHash,
+                Orb::Price::UnitWithPercent::OrHash,
+                Orb::Price::MatrixWithAllocation::OrHash,
+                Orb::Price::TieredWithProration::OrHash,
+                Orb::Price::UnitWithProration::OrHash,
+                Orb::Price::GroupedAllocation::OrHash,
+                Orb::Price::GroupedWithProratedMinimum::OrHash,
+                Orb::Price::GroupedWithMeteredMinimum::OrHash,
+                Orb::Price::MatrixWithDisplayName::OrHash,
+                Orb::Price::BulkWithProration::OrHash,
+                Orb::Price::GroupedTieredPackage::OrHash,
+                Orb::Price::MaxGroupTieredPackage::OrHash,
+                Orb::Price::ScalableMatrixWithUnitPricing::OrHash,
+                Orb::Price::ScalableMatrixWithTieredPricing::OrHash,
+                Orb::Price::CumulativeGroupedBulk::OrHash
+              ),
             start_date: Time,
             usage_customer_ids: T.nilable(T::Array[String])
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           id:,
@@ -1411,56 +1528,66 @@ module Orb
           # A list of customer IDs whose usage events will be aggregated and billed under
           # this price interval.
           usage_customer_ids:
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                id: String,
-                billing_cycle_day: Integer,
-                current_billing_period_end_date: T.nilable(Time),
-                current_billing_period_start_date: T.nilable(Time),
-                end_date: T.nilable(Time),
-                filter: T.nilable(String),
-                fixed_fee_quantity_transitions: T.nilable(T::Array[Orb::Models::Subscription::PriceInterval::FixedFeeQuantityTransition]),
-                price: T.any(
-                  Orb::Models::Price::UnitPrice,
-                  Orb::Models::Price::PackagePrice,
-                  Orb::Models::Price::MatrixPrice,
-                  Orb::Models::Price::TieredPrice,
-                  Orb::Models::Price::TieredBpsPrice,
-                  Orb::Models::Price::BpsPrice,
-                  Orb::Models::Price::BulkBpsPrice,
-                  Orb::Models::Price::BulkPrice,
-                  Orb::Models::Price::ThresholdTotalAmountPrice,
-                  Orb::Models::Price::TieredPackagePrice,
-                  Orb::Models::Price::GroupedTieredPrice,
-                  Orb::Models::Price::TieredWithMinimumPrice,
-                  Orb::Models::Price::TieredPackageWithMinimumPrice,
-                  Orb::Models::Price::PackageWithAllocationPrice,
-                  Orb::Models::Price::UnitWithPercentPrice,
-                  Orb::Models::Price::MatrixWithAllocationPrice,
-                  Orb::Models::Price::TieredWithProrationPrice,
-                  Orb::Models::Price::UnitWithProrationPrice,
-                  Orb::Models::Price::GroupedAllocationPrice,
-                  Orb::Models::Price::GroupedWithProratedMinimumPrice,
-                  Orb::Models::Price::GroupedWithMeteredMinimumPrice,
-                  Orb::Models::Price::MatrixWithDisplayNamePrice,
-                  Orb::Models::Price::BulkWithProrationPrice,
-                  Orb::Models::Price::GroupedTieredPackagePrice,
-                  Orb::Models::Price::MaxGroupTieredPackagePrice,
-                  Orb::Models::Price::ScalableMatrixWithUnitPricingPrice,
-                  Orb::Models::Price::ScalableMatrixWithTieredPricingPrice,
-                  Orb::Models::Price::CumulativeGroupedBulkPrice
+          override.returns(
+            {
+              id: String,
+              billing_cycle_day: Integer,
+              current_billing_period_end_date: T.nilable(Time),
+              current_billing_period_start_date: T.nilable(Time),
+              end_date: T.nilable(Time),
+              filter: T.nilable(String),
+              fixed_fee_quantity_transitions:
+                T.nilable(
+                  T::Array[
+                    Orb::Subscription::PriceInterval::FixedFeeQuantityTransition
+                  ]
                 ),
-                start_date: Time,
-                usage_customer_ids: T.nilable(T::Array[String])
-              }
-            )
+              price:
+                T.any(
+                  Orb::Price::Unit,
+                  Orb::Price::Package,
+                  Orb::Price::Matrix,
+                  Orb::Price::Tiered,
+                  Orb::Price::TieredBps,
+                  Orb::Price::Bps,
+                  Orb::Price::BulkBps,
+                  Orb::Price::Bulk,
+                  Orb::Price::ThresholdTotalAmount,
+                  Orb::Price::TieredPackage,
+                  Orb::Price::GroupedTiered,
+                  Orb::Price::TieredWithMinimum,
+                  Orb::Price::TieredPackageWithMinimum,
+                  Orb::Price::PackageWithAllocation,
+                  Orb::Price::UnitWithPercent,
+                  Orb::Price::MatrixWithAllocation,
+                  Orb::Price::TieredWithProration,
+                  Orb::Price::UnitWithProration,
+                  Orb::Price::GroupedAllocation,
+                  Orb::Price::GroupedWithProratedMinimum,
+                  Orb::Price::GroupedWithMeteredMinimum,
+                  Orb::Price::MatrixWithDisplayName,
+                  Orb::Price::BulkWithProration,
+                  Orb::Price::GroupedTieredPackage,
+                  Orb::Price::MaxGroupTieredPackage,
+                  Orb::Price::ScalableMatrixWithUnitPricing,
+                  Orb::Price::ScalableMatrixWithTieredPricing,
+                  Orb::Price::CumulativeGroupedBulk
+                ),
+              start_date: Time,
+              usage_customer_ids: T.nilable(T::Array[String])
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel
+          OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
           sig { returns(Time) }
           attr_accessor :effective_date
 
@@ -1470,15 +1597,29 @@ module Orb
           sig { returns(Integer) }
           attr_accessor :quantity
 
-          sig { params(effective_date: Time, price_id: String, quantity: Integer).returns(T.attached_class) }
-          def self.new(effective_date:, price_id:, quantity:); end
+          sig do
+            params(
+              effective_date: Time,
+              price_id: String,
+              quantity: Integer
+            ).returns(T.attached_class)
+          end
+          def self.new(effective_date:, price_id:, quantity:)
+          end
 
-          sig { override.returns({effective_date: Time, price_id: String, quantity: Integer}) }
-          def to_hash; end
+          sig do
+            override.returns(
+              { effective_date: Time, price_id: String, quantity: Integer }
+            )
+          end
+          def to_hash
+          end
         end
       end
 
       class RedeemedCoupon < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         sig { returns(String) }
         attr_accessor :coupon_id
 
@@ -1489,37 +1630,54 @@ module Orb
         attr_accessor :start_date
 
         sig do
-          params(coupon_id: String, end_date: T.nilable(Time), start_date: Time).returns(T.attached_class)
+          params(
+            coupon_id: String,
+            end_date: T.nilable(Time),
+            start_date: Time
+          ).returns(T.attached_class)
+        end
+        def self.new(coupon_id:, end_date:, start_date:)
         end
-        def self.new(coupon_id:, end_date:, start_date:); end
 
-        sig { override.returns({coupon_id: String, end_date: T.nilable(Time), start_date: Time}) }
-        def to_hash; end
+        sig do
+          override.returns(
+            { coupon_id: String, end_date: T.nilable(Time), start_date: Time }
+          )
+        end
+        def to_hash
+        end
       end
 
       module Status
         extend Orb::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Subscription::Status) }
+        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Subscription::Status) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        ACTIVE = T.let(:active, Orb::Models::Subscription::Status::TaggedSymbol)
-        ENDED = T.let(:ended, Orb::Models::Subscription::Status::TaggedSymbol)
-        UPCOMING = T.let(:upcoming, Orb::Models::Subscription::Status::TaggedSymbol)
+        ACTIVE = T.let(:active, Orb::Subscription::Status::TaggedSymbol)
+        ENDED = T.let(:ended, Orb::Subscription::Status::TaggedSymbol)
+        UPCOMING = T.let(:upcoming, Orb::Subscription::Status::TaggedSymbol)
 
-        sig { override.returns(T::Array[Orb::Models::Subscription::Status::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(T::Array[Orb::Subscription::Status::TaggedSymbol])
+        end
+        def self.values
+        end
       end
 
       class TrialInfo < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         sig { returns(T.nilable(Time)) }
         attr_accessor :end_date
 
         sig { params(end_date: T.nilable(Time)).returns(T.attached_class) }
-        def self.new(end_date:); end
+        def self.new(end_date:)
+        end
 
-        sig { override.returns({end_date: T.nilable(Time)}) }
-        def to_hash; end
+        sig { override.returns({ end_date: T.nilable(Time) }) }
+        def to_hash
+        end
       end
     end
   end