orb-billing 0.3.1 → 0.3.2

data/rbi/orb/models/subscription_price_intervals_response.rbi

@@ -3,6 +3,8 @@
 module Orb
   module Models
     class SubscriptionPriceIntervalsResponse < 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,13 @@ module Orb
 
       # The adjustment intervals for this subscription sorted by the start_date of the
       # adjustment interval.
-      sig { returns(T::Array[Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval]) }
+      sig do
+        returns(
+          T::Array[
+            Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval
+          ]
+        )
+      end
       attr_accessor :adjustment_intervals
 
       # Determines whether issued invoices for this subscription will automatically be
@@ -22,17 +30,18 @@ module Orb
       sig { returns(T.nilable(T::Boolean)) }
       attr_accessor :auto_collection
 
-      sig { returns(Orb::Models::SubscriptionPriceIntervalsResponse::BillingCycleAnchorConfiguration) }
+      sig do
+        returns(
+          Orb::Models::SubscriptionPriceIntervalsResponse::BillingCycleAnchorConfiguration
+        )
+      end
       attr_reader :billing_cycle_anchor_configuration
 
       sig do
         params(
-          billing_cycle_anchor_configuration: T.any(
-            Orb::Models::SubscriptionPriceIntervalsResponse::BillingCycleAnchorConfiguration,
-            Orb::Internal::AnyHash
-          )
-        )
-          .void
+          billing_cycle_anchor_configuration:
+            Orb::Models::SubscriptionPriceIntervalsResponse::BillingCycleAnchorConfiguration::OrHash
+        ).void
       end
       attr_writer :billing_cycle_anchor_configuration
 
@@ -76,10 +85,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
@@ -105,14 +114,26 @@ module Orb
       sig { returns(T.nilable(Time)) }
       attr_accessor :end_date
 
-      sig { returns(T::Array[Orb::Models::SubscriptionPriceIntervalsResponse::FixedFeeQuantitySchedule]) }
+      sig do
+        returns(
+          T::Array[
+            Orb::Models::SubscriptionPriceIntervalsResponse::FixedFeeQuantitySchedule
+          ]
+        )
+      end
       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::SubscriptionPriceIntervalsResponse::MaximumInterval]) }
+      sig do
+        returns(
+          T::Array[
+            Orb::Models::SubscriptionPriceIntervalsResponse::MaximumInterval
+          ]
+        )
+      end
       attr_accessor :maximum_intervals
 
       # User specified key-value pairs for the resource. If not present, this defaults
@@ -123,7 +144,13 @@ module Orb
       attr_accessor :metadata
 
       # The minimum intervals for this subscription sorted by the start_date.
-      sig { returns(T::Array[Orb::Models::SubscriptionPriceIntervalsResponse::MinimumInterval]) }
+      sig do
+        returns(
+          T::Array[
+            Orb::Models::SubscriptionPriceIntervalsResponse::MinimumInterval
+          ]
+        )
+      end
       attr_accessor :minimum_intervals
 
       # Determines the difference between the invoice issue date for subscription
@@ -134,16 +161,22 @@ module Orb
       attr_accessor :net_terms
 
       # A pending subscription change if one exists on this subscription.
-      sig { returns(T.nilable(Orb::Models::SubscriptionPriceIntervalsResponse::PendingSubscriptionChange)) }
+      sig do
+        returns(
+          T.nilable(
+            Orb::Models::SubscriptionPriceIntervalsResponse::PendingSubscriptionChange
+          )
+        )
+      end
       attr_reader :pending_subscription_change
 
       sig do
         params(
-          pending_subscription_change: T.nilable(
-            T.any(Orb::Models::SubscriptionPriceIntervalsResponse::PendingSubscriptionChange, Orb::Internal::AnyHash)
-          )
-        )
-          .void
+          pending_subscription_change:
+            T.nilable(
+              Orb::Models::SubscriptionPriceIntervalsResponse::PendingSubscriptionChange::OrHash
+            )
+        ).void
       end
       attr_writer :pending_subscription_change
 
@@ -151,24 +184,38 @@ 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::SubscriptionPriceIntervalsResponse::PriceInterval]) }
+      sig do
+        returns(
+          T::Array[
+            Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval
+          ]
+        )
+      end
       attr_accessor :price_intervals
 
-      sig { returns(T.nilable(Orb::Models::SubscriptionPriceIntervalsResponse::RedeemedCoupon)) }
+      sig do
+        returns(
+          T.nilable(
+            Orb::Models::SubscriptionPriceIntervalsResponse::RedeemedCoupon
+          )
+        )
+      end
       attr_reader :redeemed_coupon
 
       sig do
         params(
-          redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionPriceIntervalsResponse::RedeemedCoupon, Orb::Internal::AnyHash))
-        )
-          .void
+          redeemed_coupon:
+            T.nilable(
+              Orb::Models::SubscriptionPriceIntervalsResponse::RedeemedCoupon::OrHash
+            )
+        ).void
       end
       attr_writer :redeemed_coupon
 
@@ -176,33 +223,45 @@ module Orb
       sig { returns(Time) }
       attr_accessor :start_date
 
-      sig { returns(Orb::Models::SubscriptionPriceIntervalsResponse::Status::TaggedSymbol) }
+      sig do
+        returns(
+          Orb::Models::SubscriptionPriceIntervalsResponse::Status::TaggedSymbol
+        )
+      end
       attr_accessor :status
 
-      sig { returns(Orb::Models::SubscriptionPriceIntervalsResponse::TrialInfo) }
+      sig do
+        returns(Orb::Models::SubscriptionPriceIntervalsResponse::TrialInfo)
+      end
       attr_reader :trial_info
 
       sig do
         params(
-          trial_info: T.any(Orb::Models::SubscriptionPriceIntervalsResponse::TrialInfo, Orb::Internal::AnyHash)
-        )
-          .void
+          trial_info:
+            Orb::Models::SubscriptionPriceIntervalsResponse::TrialInfo::OrHash
+        ).void
       end
       attr_writer :trial_info
 
       # The resources that were changed as part of this operation. Only present when
       # fetched through the subscription changes API or if the
       # `include_changed_resources` parameter was passed in the request.
-      sig { returns(T.nilable(Orb::Models::SubscriptionPriceIntervalsResponse::ChangedResources)) }
+      sig do
+        returns(
+          T.nilable(
+            Orb::Models::SubscriptionPriceIntervalsResponse::ChangedResources
+          )
+        )
+      end
       attr_reader :changed_resources
 
       sig do
         params(
-          changed_resources: T.nilable(
-            T.any(Orb::Models::SubscriptionPriceIntervalsResponse::ChangedResources, Orb::Internal::AnyHash)
-          )
-        )
-          .void
+          changed_resources:
+            T.nilable(
+              Orb::Models::SubscriptionPriceIntervalsResponse::ChangedResources::OrHash
+            )
+        ).void
       end
       attr_writer :changed_resources
 
@@ -210,47 +269,66 @@ module Orb
         params(
           id: String,
           active_plan_phase_order: T.nilable(Integer),
-          adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval, Orb::Internal::AnyHash)],
+          adjustment_intervals:
+            T::Array[
+              Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::OrHash
+            ],
           auto_collection: T.nilable(T::Boolean),
-          billing_cycle_anchor_configuration: T.any(
-            Orb::Models::SubscriptionPriceIntervalsResponse::BillingCycleAnchorConfiguration,
-            Orb::Internal::AnyHash
-          ),
+          billing_cycle_anchor_configuration:
+            Orb::Models::SubscriptionPriceIntervalsResponse::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::SubscriptionPriceIntervalsResponse::DiscountInterval::Amount,
-              Orb::Internal::AnyHash,
-              Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::Percentage,
-              Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::Usage
-            )
-          ],
+          discount_intervals:
+            T::Array[
+              T.any(
+                Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::Amount::OrHash,
+                Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::Percentage::OrHash,
+                Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::Usage::OrHash
+              )
+            ],
           end_date: T.nilable(Time),
-          fixed_fee_quantity_schedule: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsResponse::FixedFeeQuantitySchedule, Orb::Internal::AnyHash)],
+          fixed_fee_quantity_schedule:
+            T::Array[
+              Orb::Models::SubscriptionPriceIntervalsResponse::FixedFeeQuantitySchedule::OrHash
+            ],
           invoicing_threshold: T.nilable(String),
-          maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsResponse::MaximumInterval, Orb::Internal::AnyHash)],
+          maximum_intervals:
+            T::Array[
+              Orb::Models::SubscriptionPriceIntervalsResponse::MaximumInterval::OrHash
+            ],
           metadata: T::Hash[Symbol, String],
-          minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsResponse::MinimumInterval, Orb::Internal::AnyHash)],
+          minimum_intervals:
+            T::Array[
+              Orb::Models::SubscriptionPriceIntervalsResponse::MinimumInterval::OrHash
+            ],
           net_terms: Integer,
-          pending_subscription_change: T.nilable(
-            T.any(Orb::Models::SubscriptionPriceIntervalsResponse::PendingSubscriptionChange, Orb::Internal::AnyHash)
-          ),
-          plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash),
-          price_intervals: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval, Orb::Internal::AnyHash)],
-          redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionPriceIntervalsResponse::RedeemedCoupon, Orb::Internal::AnyHash)),
+          pending_subscription_change:
+            T.nilable(
+              Orb::Models::SubscriptionPriceIntervalsResponse::PendingSubscriptionChange::OrHash
+            ),
+          plan: Orb::Plan::OrHash,
+          price_intervals:
+            T::Array[
+              Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval::OrHash
+            ],
+          redeemed_coupon:
+            T.nilable(
+              Orb::Models::SubscriptionPriceIntervalsResponse::RedeemedCoupon::OrHash
+            ),
           start_date: Time,
-          status: Orb::Models::SubscriptionPriceIntervalsResponse::Status::OrSymbol,
-          trial_info: T.any(Orb::Models::SubscriptionPriceIntervalsResponse::TrialInfo, Orb::Internal::AnyHash),
-          changed_resources: T.nilable(
-            T.any(Orb::Models::SubscriptionPriceIntervalsResponse::ChangedResources, Orb::Internal::AnyHash)
-          )
-        )
-          .returns(T.attached_class)
+          status:
+            Orb::Models::SubscriptionPriceIntervalsResponse::Status::OrSymbol,
+          trial_info:
+            Orb::Models::SubscriptionPriceIntervalsResponse::TrialInfo::OrHash,
+          changed_resources:
+            T.nilable(
+              Orb::Models::SubscriptionPriceIntervalsResponse::ChangedResources::OrHash
+            )
+        ).returns(T.attached_class)
       end
       def self.new(
         id:,
@@ -339,50 +417,82 @@ module Orb
         # fetched through the subscription changes API or if the
         # `include_changed_resources` parameter was passed in the request.
         changed_resources: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              id: String,
-              active_plan_phase_order: T.nilable(Integer),
-              adjustment_intervals: T::Array[Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval],
-              auto_collection: T.nilable(T::Boolean),
-              billing_cycle_anchor_configuration: Orb::Models::SubscriptionPriceIntervalsResponse::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::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval
+              ],
+            auto_collection: T.nilable(T::Boolean),
+            billing_cycle_anchor_configuration:
+              Orb::Models::SubscriptionPriceIntervalsResponse::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::SubscriptionPriceIntervalsResponse::DiscountInterval::Amount,
                   Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::Percentage,
                   Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::Usage
                 )
               ],
-              end_date: T.nilable(Time),
-              fixed_fee_quantity_schedule: T::Array[Orb::Models::SubscriptionPriceIntervalsResponse::FixedFeeQuantitySchedule],
-              invoicing_threshold: T.nilable(String),
-              maximum_intervals: T::Array[Orb::Models::SubscriptionPriceIntervalsResponse::MaximumInterval],
-              metadata: T::Hash[Symbol, String],
-              minimum_intervals: T::Array[Orb::Models::SubscriptionPriceIntervalsResponse::MinimumInterval],
-              net_terms: Integer,
-              pending_subscription_change: T.nilable(Orb::Models::SubscriptionPriceIntervalsResponse::PendingSubscriptionChange),
-              plan: Orb::Models::Plan,
-              price_intervals: T::Array[Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval],
-              redeemed_coupon: T.nilable(Orb::Models::SubscriptionPriceIntervalsResponse::RedeemedCoupon),
-              start_date: Time,
-              status: Orb::Models::SubscriptionPriceIntervalsResponse::Status::TaggedSymbol,
-              trial_info: Orb::Models::SubscriptionPriceIntervalsResponse::TrialInfo,
-              changed_resources: T.nilable(Orb::Models::SubscriptionPriceIntervalsResponse::ChangedResources)
-            }
-          )
+            end_date: T.nilable(Time),
+            fixed_fee_quantity_schedule:
+              T::Array[
+                Orb::Models::SubscriptionPriceIntervalsResponse::FixedFeeQuantitySchedule
+              ],
+            invoicing_threshold: T.nilable(String),
+            maximum_intervals:
+              T::Array[
+                Orb::Models::SubscriptionPriceIntervalsResponse::MaximumInterval
+              ],
+            metadata: T::Hash[Symbol, String],
+            minimum_intervals:
+              T::Array[
+                Orb::Models::SubscriptionPriceIntervalsResponse::MinimumInterval
+              ],
+            net_terms: Integer,
+            pending_subscription_change:
+              T.nilable(
+                Orb::Models::SubscriptionPriceIntervalsResponse::PendingSubscriptionChange
+              ),
+            plan: Orb::Plan,
+            price_intervals:
+              T::Array[
+                Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval
+              ],
+            redeemed_coupon:
+              T.nilable(
+                Orb::Models::SubscriptionPriceIntervalsResponse::RedeemedCoupon
+              ),
+            start_date: Time,
+            status:
+              Orb::Models::SubscriptionPriceIntervalsResponse::Status::TaggedSymbol,
+            trial_info:
+              Orb::Models::SubscriptionPriceIntervalsResponse::TrialInfo,
+            changed_resources:
+              T.nilable(
+                Orb::Models::SubscriptionPriceIntervalsResponse::ChangedResources
+              )
+          }
+        )
+      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
 
@@ -414,19 +524,18 @@ module Orb
         sig do
           params(
             id: String,
-            adjustment: T.any(
-              Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::UsageDiscount,
-              Orb::Internal::AnyHash,
-              Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::AmountDiscount,
-              Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::PercentageDiscount,
-              Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::Minimum,
-              Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::Maximum
-            ),
+            adjustment:
+              T.any(
+                Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::UsageDiscount::OrHash,
+                Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::AmountDiscount::OrHash,
+                Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::PercentageDiscount::OrHash,
+                Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::Minimum::OrHash,
+                Orb::Models::SubscriptionPriceIntervalsResponse::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:,
@@ -437,31 +546,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(
+          override.returns(
+            {
+              id: String,
+              adjustment:
+                T.any(
                   Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::UsageDiscount,
                   Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::AmountDiscount,
                   Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::PercentageDiscount,
                   Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::Minimum,
                   Orb::Models::SubscriptionPriceIntervalsResponse::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
 
+          Variants =
+            T.type_alias do
+              T.any(
+                Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::UsageDiscount,
+                Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::AmountDiscount,
+                Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::PercentageDiscount,
+                Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::Minimum,
+                Orb::Models::SubscriptionPriceIntervalsResponse::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
 
@@ -499,8 +624,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:,
@@ -517,25 +641,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 AmountDiscount < Orb::Internal::Type::BaseModel
+            OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
             sig { returns(String) }
             attr_accessor :id
 
@@ -573,8 +701,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:,
@@ -591,25 +718,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 PercentageDiscount < Orb::Internal::Type::BaseModel
+            OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
             sig { returns(String) }
             attr_accessor :id
 
@@ -647,8 +778,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:,
@@ -665,25 +795,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 Minimum < Orb::Internal::Type::BaseModel
+            OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
             sig { returns(String) }
             attr_accessor :id
 
@@ -726,8 +860,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:,
@@ -746,26 +879,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 Maximum < Orb::Internal::Type::BaseModel
+            OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
             sig { returns(String) }
             attr_accessor :id
 
@@ -803,8 +940,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:,
@@ -821,35 +957,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::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::UsageDiscount, Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::AmountDiscount, Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::PercentageDiscount, Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::Minimum, Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::Maximum]
-              )
+            override.returns(
+              T::Array[
+                Orb::Models::SubscriptionPriceIntervalsResponse::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
@@ -869,7 +1011,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
@@ -884,15 +1030,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
 
+        Variants =
+          T.type_alias do
+            T.any(
+              Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::Amount,
+              Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::Percentage,
+              Orb::Models::SubscriptionPriceIntervalsResponse::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
@@ -924,8 +1092,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`.
@@ -939,24 +1106,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 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
@@ -989,8 +1160,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.
@@ -1005,24 +1175,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 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
@@ -1055,8 +1229,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.
@@ -1071,33 +1244,39 @@ 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::SubscriptionPriceIntervalsResponse::DiscountInterval::Amount, Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::Percentage, Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::Usage]
-            )
+          override.returns(
+            T::Array[
+              Orb::Models::SubscriptionPriceIntervalsResponse::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
 
@@ -1111,18 +1290,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
@@ -1151,8 +1345,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.
@@ -1166,23 +1359,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
@@ -1211,8 +1408,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.
@@ -1226,35 +1422,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
 
@@ -1288,7 +1492,9 @@ module Orb
         sig do
           returns(
             T.nilable(
-              T::Array[Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval::FixedFeeQuantityTransition]
+              T::Array[
+                Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval::FixedFeeQuantityTransition
+              ]
             )
           )
         end
@@ -1307,34 +1513,34 @@ module Orb
         sig do
           returns(
             T.any(
-              Orb::Models::Price::Unit,
-              Orb::Models::Price::Package,
-              Orb::Models::Price::Matrix,
-              Orb::Models::Price::Tiered,
-              Orb::Models::Price::TieredBps,
-              Orb::Models::Price::Bps,
-              Orb::Models::Price::BulkBps,
-              Orb::Models::Price::Bulk,
-              Orb::Models::Price::ThresholdTotalAmount,
-              Orb::Models::Price::TieredPackage,
-              Orb::Models::Price::GroupedTiered,
-              Orb::Models::Price::TieredWithMinimum,
-              Orb::Models::Price::TieredPackageWithMinimum,
-              Orb::Models::Price::PackageWithAllocation,
-              Orb::Models::Price::UnitWithPercent,
-              Orb::Models::Price::MatrixWithAllocation,
-              Orb::Models::Price::TieredWithProration,
-              Orb::Models::Price::UnitWithProration,
-              Orb::Models::Price::GroupedAllocation,
-              Orb::Models::Price::GroupedWithProratedMinimum,
-              Orb::Models::Price::GroupedWithMeteredMinimum,
-              Orb::Models::Price::MatrixWithDisplayName,
-              Orb::Models::Price::BulkWithProration,
-              Orb::Models::Price::GroupedTieredPackage,
-              Orb::Models::Price::MaxGroupTieredPackage,
-              Orb::Models::Price::ScalableMatrixWithUnitPricing,
-              Orb::Models::Price::ScalableMatrixWithTieredPricing,
-              Orb::Models::Price::CumulativeGroupedBulk
+              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
@@ -1361,49 +1567,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::SubscriptionPriceIntervalsResponse::PriceInterval::FixedFeeQuantityTransition,
-                  Orb::Internal::AnyHash
-                )
-              ]
-            ),
-            price: T.any(
-              Orb::Models::Price::Unit,
-              Orb::Internal::AnyHash,
-              Orb::Models::Price::Package,
-              Orb::Models::Price::Matrix,
-              Orb::Models::Price::Tiered,
-              Orb::Models::Price::TieredBps,
-              Orb::Models::Price::Bps,
-              Orb::Models::Price::BulkBps,
-              Orb::Models::Price::Bulk,
-              Orb::Models::Price::ThresholdTotalAmount,
-              Orb::Models::Price::TieredPackage,
-              Orb::Models::Price::GroupedTiered,
-              Orb::Models::Price::TieredWithMinimum,
-              Orb::Models::Price::TieredPackageWithMinimum,
-              Orb::Models::Price::PackageWithAllocation,
-              Orb::Models::Price::UnitWithPercent,
-              Orb::Models::Price::MatrixWithAllocation,
-              Orb::Models::Price::TieredWithProration,
-              Orb::Models::Price::UnitWithProration,
-              Orb::Models::Price::GroupedAllocation,
-              Orb::Models::Price::GroupedWithProratedMinimum,
-              Orb::Models::Price::GroupedWithMeteredMinimum,
-              Orb::Models::Price::MatrixWithDisplayName,
-              Orb::Models::Price::BulkWithProration,
-              Orb::Models::Price::GroupedTieredPackage,
-              Orb::Models::Price::MaxGroupTieredPackage,
-              Orb::Models::Price::ScalableMatrixWithUnitPricing,
-              Orb::Models::Price::ScalableMatrixWithTieredPricing,
-              Orb::Models::Price::CumulativeGroupedBulk
-            ),
+            fixed_fee_quantity_transitions:
+              T.nilable(
+                T::Array[
+                  Orb::Models::SubscriptionPriceIntervalsResponse::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:,
@@ -1442,58 +1645,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::SubscriptionPriceIntervalsResponse::PriceInterval::FixedFeeQuantityTransition]
+          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::SubscriptionPriceIntervalsResponse::PriceInterval::FixedFeeQuantityTransition
+                  ]
                 ),
-                price: T.any(
-                  Orb::Models::Price::Unit,
-                  Orb::Models::Price::Package,
-                  Orb::Models::Price::Matrix,
-                  Orb::Models::Price::Tiered,
-                  Orb::Models::Price::TieredBps,
-                  Orb::Models::Price::Bps,
-                  Orb::Models::Price::BulkBps,
-                  Orb::Models::Price::Bulk,
-                  Orb::Models::Price::ThresholdTotalAmount,
-                  Orb::Models::Price::TieredPackage,
-                  Orb::Models::Price::GroupedTiered,
-                  Orb::Models::Price::TieredWithMinimum,
-                  Orb::Models::Price::TieredPackageWithMinimum,
-                  Orb::Models::Price::PackageWithAllocation,
-                  Orb::Models::Price::UnitWithPercent,
-                  Orb::Models::Price::MatrixWithAllocation,
-                  Orb::Models::Price::TieredWithProration,
-                  Orb::Models::Price::UnitWithProration,
-                  Orb::Models::Price::GroupedAllocation,
-                  Orb::Models::Price::GroupedWithProratedMinimum,
-                  Orb::Models::Price::GroupedWithMeteredMinimum,
-                  Orb::Models::Price::MatrixWithDisplayName,
-                  Orb::Models::Price::BulkWithProration,
-                  Orb::Models::Price::GroupedTieredPackage,
-                  Orb::Models::Price::MaxGroupTieredPackage,
-                  Orb::Models::Price::ScalableMatrixWithUnitPricing,
-                  Orb::Models::Price::ScalableMatrixWithTieredPricing,
-                  Orb::Models::Price::CumulativeGroupedBulk
+              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])
-              }
-            )
+              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
 
@@ -1503,15 +1714,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
 
@@ -1522,54 +1747,95 @@ 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::SubscriptionPriceIntervalsResponse::Status) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              Orb::Models::SubscriptionPriceIntervalsResponse::Status
+            )
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        ACTIVE = T.let(:active, Orb::Models::SubscriptionPriceIntervalsResponse::Status::TaggedSymbol)
-        ENDED = T.let(:ended, Orb::Models::SubscriptionPriceIntervalsResponse::Status::TaggedSymbol)
-        UPCOMING = T.let(:upcoming, Orb::Models::SubscriptionPriceIntervalsResponse::Status::TaggedSymbol)
+        ACTIVE =
+          T.let(
+            :active,
+            Orb::Models::SubscriptionPriceIntervalsResponse::Status::TaggedSymbol
+          )
+        ENDED =
+          T.let(
+            :ended,
+            Orb::Models::SubscriptionPriceIntervalsResponse::Status::TaggedSymbol
+          )
+        UPCOMING =
+          T.let(
+            :upcoming,
+            Orb::Models::SubscriptionPriceIntervalsResponse::Status::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Orb::Models::SubscriptionPriceIntervalsResponse::Status::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Orb::Models::SubscriptionPriceIntervalsResponse::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
 
       class ChangedResources < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         # The credit notes that were created as part of this operation.
-        sig { returns(T::Array[Orb::Models::CreditNote]) }
+        sig { returns(T::Array[Orb::CreditNote]) }
         attr_accessor :created_credit_notes
 
         # The invoices that were created as part of this operation.
-        sig { returns(T::Array[Orb::Models::Invoice]) }
+        sig { returns(T::Array[Orb::Invoice]) }
         attr_accessor :created_invoices
 
         # The credit notes that were voided as part of this operation.
-        sig { returns(T::Array[Orb::Models::CreditNote]) }
+        sig { returns(T::Array[Orb::CreditNote]) }
         attr_accessor :voided_credit_notes
 
         # The invoices that were voided as part of this operation.
-        sig { returns(T::Array[Orb::Models::Invoice]) }
+        sig { returns(T::Array[Orb::Invoice]) }
         attr_accessor :voided_invoices
 
         # The resources that were changed as part of this operation. Only present when
@@ -1577,12 +1843,11 @@ module Orb
         # `include_changed_resources` parameter was passed in the request.
         sig do
           params(
-            created_credit_notes: T::Array[T.any(Orb::Models::CreditNote, Orb::Internal::AnyHash)],
-            created_invoices: T::Array[T.any(Orb::Models::Invoice, Orb::Internal::AnyHash)],
-            voided_credit_notes: T::Array[T.any(Orb::Models::CreditNote, Orb::Internal::AnyHash)],
-            voided_invoices: T::Array[T.any(Orb::Models::Invoice, Orb::Internal::AnyHash)]
-          )
-            .returns(T.attached_class)
+            created_credit_notes: T::Array[Orb::CreditNote::OrHash],
+            created_invoices: T::Array[Orb::Invoice::OrHash],
+            voided_credit_notes: T::Array[Orb::CreditNote::OrHash],
+            voided_invoices: T::Array[Orb::Invoice::OrHash]
+          ).returns(T.attached_class)
         end
         def self.new(
           # The credit notes that were created as part of this operation.
@@ -1593,19 +1858,21 @@ module Orb
           voided_credit_notes:,
           # The invoices that were voided as part of this operation.
           voided_invoices:
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                created_credit_notes: T::Array[Orb::Models::CreditNote],
-                created_invoices: T::Array[Orb::Models::Invoice],
-                voided_credit_notes: T::Array[Orb::Models::CreditNote],
-                voided_invoices: T::Array[Orb::Models::Invoice]
-              }
-            )
+          override.returns(
+            {
+              created_credit_notes: T::Array[Orb::CreditNote],
+              created_invoices: T::Array[Orb::Invoice],
+              voided_credit_notes: T::Array[Orb::CreditNote],
+              voided_invoices: T::Array[Orb::Invoice]
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
     end
   end