orb-billing 0.11.0 → 1.0.0

data/rbi/orb/models/plan.rbi

@@ -54,10 +54,10 @@ module Orb
       sig { returns(String) }
       attr_accessor :invoicing_currency
 
-      sig { returns(T.nilable(Orb::Plan::Maximum)) }
+      sig { returns(T.nilable(Orb::Maximum)) }
       attr_reader :maximum
 
-      sig { params(maximum: T.nilable(Orb::Plan::Maximum::OrHash)).void }
+      sig { params(maximum: T.nilable(Orb::Maximum::OrHash)).void }
       attr_writer :maximum
 
       sig { returns(T.nilable(String)) }
@@ -70,10 +70,10 @@ module Orb
       sig { returns(T::Hash[Symbol, String]) }
       attr_accessor :metadata
 
-      sig { returns(T.nilable(Orb::Plan::Minimum)) }
+      sig { returns(T.nilable(Orb::Minimum)) }
       attr_reader :minimum
 
-      sig { params(minimum: T.nilable(Orb::Plan::Minimum::OrHash)).void }
+      sig { params(minimum: T.nilable(Orb::Minimum::OrHash)).void }
       attr_writer :minimum
 
       sig { returns(T.nilable(String)) }
@@ -126,11 +126,11 @@ module Orb
           adjustments:
             T::Array[
               T.any(
-                Orb::Plan::Adjustment::UsageDiscount::OrHash,
-                Orb::Plan::Adjustment::AmountDiscount::OrHash,
-                Orb::Plan::Adjustment::PercentageDiscount::OrHash,
-                Orb::Plan::Adjustment::Minimum::OrHash,
-                Orb::Plan::Adjustment::Maximum::OrHash
+                Orb::PlanPhaseUsageDiscountAdjustment::OrHash,
+                Orb::PlanPhaseAmountDiscountAdjustment::OrHash,
+                Orb::PlanPhasePercentageDiscountAdjustment::OrHash,
+                Orb::PlanPhaseMinimumAdjustment::OrHash,
+                Orb::PlanPhaseMaximumAdjustment::OrHash
               )
             ],
           base_plan: T.nilable(Orb::Plan::BasePlan::OrHash),
@@ -150,10 +150,10 @@ module Orb
             ),
           external_plan_id: T.nilable(String),
           invoicing_currency: String,
-          maximum: T.nilable(Orb::Plan::Maximum::OrHash),
+          maximum: T.nilable(Orb::Maximum::OrHash),
           maximum_amount: T.nilable(String),
           metadata: T::Hash[Symbol, String],
-          minimum: T.nilable(Orb::Plan::Minimum::OrHash),
+          minimum: T.nilable(Orb::Minimum::OrHash),
           minimum_amount: T.nilable(String),
           name: String,
           net_terms: T.nilable(Integer),
@@ -165,9 +165,9 @@ module Orb
                 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::TieredBPS::OrHash,
+                Orb::Price::BPS::OrHash,
+                Orb::Price::BulkBPS::OrHash,
                 Orb::Price::Bulk::OrHash,
                 Orb::Price::ThresholdTotalAmount::OrHash,
                 Orb::Price::TieredPackage::OrHash,
@@ -263,10 +263,10 @@ module Orb
             discount: T.nilable(Orb::Discount::Variants),
             external_plan_id: T.nilable(String),
             invoicing_currency: String,
-            maximum: T.nilable(Orb::Plan::Maximum),
+            maximum: T.nilable(Orb::Maximum),
             maximum_amount: T.nilable(String),
             metadata: T::Hash[Symbol, String],
-            minimum: T.nilable(Orb::Plan::Minimum),
+            minimum: T.nilable(Orb::Minimum),
             minimum_amount: T.nilable(String),
             name: String,
             net_terms: T.nilable(Integer),
@@ -288,1216 +288,14 @@ module Orb
         Variants =
           T.type_alias do
             T.any(
-              Orb::Plan::Adjustment::UsageDiscount,
-              Orb::Plan::Adjustment::AmountDiscount,
-              Orb::Plan::Adjustment::PercentageDiscount,
-              Orb::Plan::Adjustment::Minimum,
-              Orb::Plan::Adjustment::Maximum
+              Orb::PlanPhaseUsageDiscountAdjustment,
+              Orb::PlanPhaseAmountDiscountAdjustment,
+              Orb::PlanPhasePercentageDiscountAdjustment,
+              Orb::PlanPhaseMinimumAdjustment,
+              Orb::PlanPhaseMaximumAdjustment
             )
           end
 
-        class UsageDiscount < Orb::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                Orb::Plan::Adjustment::UsageDiscount,
-                Orb::Internal::AnyHash
-              )
-            end
-
-          sig { returns(String) }
-          attr_accessor :id
-
-          sig { returns(Symbol) }
-          attr_accessor :adjustment_type
-
-          # The price IDs that this adjustment applies to.
-          sig { returns(T::Array[String]) }
-          attr_accessor :applies_to_price_ids
-
-          # The filters that determine which prices to apply this adjustment to.
-          sig do
-            returns(T::Array[Orb::Plan::Adjustment::UsageDiscount::Filter])
-          end
-          attr_accessor :filters
-
-          # True for adjustments that apply to an entire invocice, false for adjustments
-          # that apply to only one price.
-          sig { returns(T::Boolean) }
-          attr_accessor :is_invoice_level
-
-          # The plan phase in which this adjustment is active.
-          sig { returns(T.nilable(Integer)) }
-          attr_accessor :plan_phase_order
-
-          # The reason for the adjustment.
-          sig { returns(T.nilable(String)) }
-          attr_accessor :reason
-
-          # The number of usage units by which to discount the price this adjustment applies
-          # to in a given billing period.
-          sig { returns(Float) }
-          attr_accessor :usage_discount
-
-          sig do
-            params(
-              id: String,
-              applies_to_price_ids: T::Array[String],
-              filters:
-                T::Array[Orb::Plan::Adjustment::UsageDiscount::Filter::OrHash],
-              is_invoice_level: T::Boolean,
-              plan_phase_order: T.nilable(Integer),
-              reason: T.nilable(String),
-              usage_discount: Float,
-              adjustment_type: Symbol
-            ).returns(T.attached_class)
-          end
-          def self.new(
-            id:,
-            # The price IDs that this adjustment applies to.
-            applies_to_price_ids:,
-            # The filters that determine which prices to apply this adjustment to.
-            filters:,
-            # True for adjustments that apply to an entire invocice, false for adjustments
-            # that apply to only one price.
-            is_invoice_level:,
-            # The plan phase in which this adjustment is active.
-            plan_phase_order:,
-            # The reason for the adjustment.
-            reason:,
-            # The number of usage units by which to discount the price this adjustment applies
-            # to in a given billing period.
-            usage_discount:,
-            adjustment_type: :usage_discount
-          )
-          end
-
-          sig do
-            override.returns(
-              {
-                id: String,
-                adjustment_type: Symbol,
-                applies_to_price_ids: T::Array[String],
-                filters: T::Array[Orb::Plan::Adjustment::UsageDiscount::Filter],
-                is_invoice_level: T::Boolean,
-                plan_phase_order: T.nilable(Integer),
-                reason: T.nilable(String),
-                usage_discount: Float
-              }
-            )
-          end
-          def to_hash
-          end
-
-          class Filter < Orb::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  Orb::Plan::Adjustment::UsageDiscount::Filter,
-                  Orb::Internal::AnyHash
-                )
-              end
-
-            # The property of the price to filter on.
-            sig do
-              returns(
-                Orb::Plan::Adjustment::UsageDiscount::Filter::Field::TaggedSymbol
-              )
-            end
-            attr_accessor :field
-
-            # Should prices that match the filter be included or excluded.
-            sig do
-              returns(
-                Orb::Plan::Adjustment::UsageDiscount::Filter::Operator::TaggedSymbol
-              )
-            end
-            attr_accessor :operator
-
-            # The IDs or values that match this filter.
-            sig { returns(T::Array[String]) }
-            attr_accessor :values
-
-            sig do
-              params(
-                field:
-                  Orb::Plan::Adjustment::UsageDiscount::Filter::Field::OrSymbol,
-                operator:
-                  Orb::Plan::Adjustment::UsageDiscount::Filter::Operator::OrSymbol,
-                values: T::Array[String]
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              # The property of the price to filter on.
-              field:,
-              # Should prices that match the filter be included or excluded.
-              operator:,
-              # The IDs or values that match this filter.
-              values:
-            )
-            end
-
-            sig do
-              override.returns(
-                {
-                  field:
-                    Orb::Plan::Adjustment::UsageDiscount::Filter::Field::TaggedSymbol,
-                  operator:
-                    Orb::Plan::Adjustment::UsageDiscount::Filter::Operator::TaggedSymbol,
-                  values: T::Array[String]
-                }
-              )
-            end
-            def to_hash
-            end
-
-            # The property of the price to filter on.
-            module Field
-              extend Orb::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Orb::Plan::Adjustment::UsageDiscount::Filter::Field
-                  )
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              PRICE_ID =
-                T.let(
-                  :price_id,
-                  Orb::Plan::Adjustment::UsageDiscount::Filter::Field::TaggedSymbol
-                )
-              ITEM_ID =
-                T.let(
-                  :item_id,
-                  Orb::Plan::Adjustment::UsageDiscount::Filter::Field::TaggedSymbol
-                )
-              PRICE_TYPE =
-                T.let(
-                  :price_type,
-                  Orb::Plan::Adjustment::UsageDiscount::Filter::Field::TaggedSymbol
-                )
-              CURRENCY =
-                T.let(
-                  :currency,
-                  Orb::Plan::Adjustment::UsageDiscount::Filter::Field::TaggedSymbol
-                )
-              PRICING_UNIT_ID =
-                T.let(
-                  :pricing_unit_id,
-                  Orb::Plan::Adjustment::UsageDiscount::Filter::Field::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Orb::Plan::Adjustment::UsageDiscount::Filter::Field::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-
-            # Should prices that match the filter be included or excluded.
-            module Operator
-              extend Orb::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Orb::Plan::Adjustment::UsageDiscount::Filter::Operator
-                  )
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              INCLUDES =
-                T.let(
-                  :includes,
-                  Orb::Plan::Adjustment::UsageDiscount::Filter::Operator::TaggedSymbol
-                )
-              EXCLUDES =
-                T.let(
-                  :excludes,
-                  Orb::Plan::Adjustment::UsageDiscount::Filter::Operator::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Orb::Plan::Adjustment::UsageDiscount::Filter::Operator::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-          end
-        end
-
-        class AmountDiscount < Orb::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                Orb::Plan::Adjustment::AmountDiscount,
-                Orb::Internal::AnyHash
-              )
-            end
-
-          sig { returns(String) }
-          attr_accessor :id
-
-          sig { returns(Symbol) }
-          attr_accessor :adjustment_type
-
-          # The amount by which to discount the prices this adjustment applies to in a given
-          # billing period.
-          sig { returns(String) }
-          attr_accessor :amount_discount
-
-          # The price IDs that this adjustment applies to.
-          sig { returns(T::Array[String]) }
-          attr_accessor :applies_to_price_ids
-
-          # The filters that determine which prices to apply this adjustment to.
-          sig do
-            returns(T::Array[Orb::Plan::Adjustment::AmountDiscount::Filter])
-          end
-          attr_accessor :filters
-
-          # True for adjustments that apply to an entire invocice, false for adjustments
-          # that apply to only one price.
-          sig { returns(T::Boolean) }
-          attr_accessor :is_invoice_level
-
-          # The plan phase in which this adjustment is active.
-          sig { returns(T.nilable(Integer)) }
-          attr_accessor :plan_phase_order
-
-          # The reason for the adjustment.
-          sig { returns(T.nilable(String)) }
-          attr_accessor :reason
-
-          sig do
-            params(
-              id: String,
-              amount_discount: String,
-              applies_to_price_ids: T::Array[String],
-              filters:
-                T::Array[Orb::Plan::Adjustment::AmountDiscount::Filter::OrHash],
-              is_invoice_level: T::Boolean,
-              plan_phase_order: T.nilable(Integer),
-              reason: T.nilable(String),
-              adjustment_type: Symbol
-            ).returns(T.attached_class)
-          end
-          def self.new(
-            id:,
-            # The amount by which to discount the prices this adjustment applies to in a given
-            # billing period.
-            amount_discount:,
-            # The price IDs that this adjustment applies to.
-            applies_to_price_ids:,
-            # The filters that determine which prices to apply this adjustment to.
-            filters:,
-            # True for adjustments that apply to an entire invocice, false for adjustments
-            # that apply to only one price.
-            is_invoice_level:,
-            # The plan phase in which this adjustment is active.
-            plan_phase_order:,
-            # The reason for the adjustment.
-            reason:,
-            adjustment_type: :amount_discount
-          )
-          end
-
-          sig do
-            override.returns(
-              {
-                id: String,
-                adjustment_type: Symbol,
-                amount_discount: String,
-                applies_to_price_ids: T::Array[String],
-                filters:
-                  T::Array[Orb::Plan::Adjustment::AmountDiscount::Filter],
-                is_invoice_level: T::Boolean,
-                plan_phase_order: T.nilable(Integer),
-                reason: T.nilable(String)
-              }
-            )
-          end
-          def to_hash
-          end
-
-          class Filter < Orb::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  Orb::Plan::Adjustment::AmountDiscount::Filter,
-                  Orb::Internal::AnyHash
-                )
-              end
-
-            # The property of the price to filter on.
-            sig do
-              returns(
-                Orb::Plan::Adjustment::AmountDiscount::Filter::Field::TaggedSymbol
-              )
-            end
-            attr_accessor :field
-
-            # Should prices that match the filter be included or excluded.
-            sig do
-              returns(
-                Orb::Plan::Adjustment::AmountDiscount::Filter::Operator::TaggedSymbol
-              )
-            end
-            attr_accessor :operator
-
-            # The IDs or values that match this filter.
-            sig { returns(T::Array[String]) }
-            attr_accessor :values
-
-            sig do
-              params(
-                field:
-                  Orb::Plan::Adjustment::AmountDiscount::Filter::Field::OrSymbol,
-                operator:
-                  Orb::Plan::Adjustment::AmountDiscount::Filter::Operator::OrSymbol,
-                values: T::Array[String]
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              # The property of the price to filter on.
-              field:,
-              # Should prices that match the filter be included or excluded.
-              operator:,
-              # The IDs or values that match this filter.
-              values:
-            )
-            end
-
-            sig do
-              override.returns(
-                {
-                  field:
-                    Orb::Plan::Adjustment::AmountDiscount::Filter::Field::TaggedSymbol,
-                  operator:
-                    Orb::Plan::Adjustment::AmountDiscount::Filter::Operator::TaggedSymbol,
-                  values: T::Array[String]
-                }
-              )
-            end
-            def to_hash
-            end
-
-            # The property of the price to filter on.
-            module Field
-              extend Orb::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Orb::Plan::Adjustment::AmountDiscount::Filter::Field
-                  )
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              PRICE_ID =
-                T.let(
-                  :price_id,
-                  Orb::Plan::Adjustment::AmountDiscount::Filter::Field::TaggedSymbol
-                )
-              ITEM_ID =
-                T.let(
-                  :item_id,
-                  Orb::Plan::Adjustment::AmountDiscount::Filter::Field::TaggedSymbol
-                )
-              PRICE_TYPE =
-                T.let(
-                  :price_type,
-                  Orb::Plan::Adjustment::AmountDiscount::Filter::Field::TaggedSymbol
-                )
-              CURRENCY =
-                T.let(
-                  :currency,
-                  Orb::Plan::Adjustment::AmountDiscount::Filter::Field::TaggedSymbol
-                )
-              PRICING_UNIT_ID =
-                T.let(
-                  :pricing_unit_id,
-                  Orb::Plan::Adjustment::AmountDiscount::Filter::Field::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Orb::Plan::Adjustment::AmountDiscount::Filter::Field::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-
-            # Should prices that match the filter be included or excluded.
-            module Operator
-              extend Orb::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Orb::Plan::Adjustment::AmountDiscount::Filter::Operator
-                  )
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              INCLUDES =
-                T.let(
-                  :includes,
-                  Orb::Plan::Adjustment::AmountDiscount::Filter::Operator::TaggedSymbol
-                )
-              EXCLUDES =
-                T.let(
-                  :excludes,
-                  Orb::Plan::Adjustment::AmountDiscount::Filter::Operator::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Orb::Plan::Adjustment::AmountDiscount::Filter::Operator::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-          end
-        end
-
-        class PercentageDiscount < Orb::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                Orb::Plan::Adjustment::PercentageDiscount,
-                Orb::Internal::AnyHash
-              )
-            end
-
-          sig { returns(String) }
-          attr_accessor :id
-
-          sig { returns(Symbol) }
-          attr_accessor :adjustment_type
-
-          # The price IDs that this adjustment applies to.
-          sig { returns(T::Array[String]) }
-          attr_accessor :applies_to_price_ids
-
-          # The filters that determine which prices to apply this adjustment to.
-          sig do
-            returns(T::Array[Orb::Plan::Adjustment::PercentageDiscount::Filter])
-          end
-          attr_accessor :filters
-
-          # True for adjustments that apply to an entire invocice, false for adjustments
-          # that apply to only one price.
-          sig { returns(T::Boolean) }
-          attr_accessor :is_invoice_level
-
-          # The percentage (as a value between 0 and 1) by which to discount the price
-          # intervals this adjustment applies to in a given billing period.
-          sig { returns(Float) }
-          attr_accessor :percentage_discount
-
-          # The plan phase in which this adjustment is active.
-          sig { returns(T.nilable(Integer)) }
-          attr_accessor :plan_phase_order
-
-          # The reason for the adjustment.
-          sig { returns(T.nilable(String)) }
-          attr_accessor :reason
-
-          sig do
-            params(
-              id: String,
-              applies_to_price_ids: T::Array[String],
-              filters:
-                T::Array[
-                  Orb::Plan::Adjustment::PercentageDiscount::Filter::OrHash
-                ],
-              is_invoice_level: T::Boolean,
-              percentage_discount: Float,
-              plan_phase_order: T.nilable(Integer),
-              reason: T.nilable(String),
-              adjustment_type: Symbol
-            ).returns(T.attached_class)
-          end
-          def self.new(
-            id:,
-            # The price IDs that this adjustment applies to.
-            applies_to_price_ids:,
-            # The filters that determine which prices to apply this adjustment to.
-            filters:,
-            # True for adjustments that apply to an entire invocice, false for adjustments
-            # that apply to only one price.
-            is_invoice_level:,
-            # The percentage (as a value between 0 and 1) by which to discount the price
-            # intervals this adjustment applies to in a given billing period.
-            percentage_discount:,
-            # The plan phase in which this adjustment is active.
-            plan_phase_order:,
-            # The reason for the adjustment.
-            reason:,
-            adjustment_type: :percentage_discount
-          )
-          end
-
-          sig do
-            override.returns(
-              {
-                id: String,
-                adjustment_type: Symbol,
-                applies_to_price_ids: T::Array[String],
-                filters:
-                  T::Array[Orb::Plan::Adjustment::PercentageDiscount::Filter],
-                is_invoice_level: T::Boolean,
-                percentage_discount: Float,
-                plan_phase_order: T.nilable(Integer),
-                reason: T.nilable(String)
-              }
-            )
-          end
-          def to_hash
-          end
-
-          class Filter < Orb::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  Orb::Plan::Adjustment::PercentageDiscount::Filter,
-                  Orb::Internal::AnyHash
-                )
-              end
-
-            # The property of the price to filter on.
-            sig do
-              returns(
-                Orb::Plan::Adjustment::PercentageDiscount::Filter::Field::TaggedSymbol
-              )
-            end
-            attr_accessor :field
-
-            # Should prices that match the filter be included or excluded.
-            sig do
-              returns(
-                Orb::Plan::Adjustment::PercentageDiscount::Filter::Operator::TaggedSymbol
-              )
-            end
-            attr_accessor :operator
-
-            # The IDs or values that match this filter.
-            sig { returns(T::Array[String]) }
-            attr_accessor :values
-
-            sig do
-              params(
-                field:
-                  Orb::Plan::Adjustment::PercentageDiscount::Filter::Field::OrSymbol,
-                operator:
-                  Orb::Plan::Adjustment::PercentageDiscount::Filter::Operator::OrSymbol,
-                values: T::Array[String]
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              # The property of the price to filter on.
-              field:,
-              # Should prices that match the filter be included or excluded.
-              operator:,
-              # The IDs or values that match this filter.
-              values:
-            )
-            end
-
-            sig do
-              override.returns(
-                {
-                  field:
-                    Orb::Plan::Adjustment::PercentageDiscount::Filter::Field::TaggedSymbol,
-                  operator:
-                    Orb::Plan::Adjustment::PercentageDiscount::Filter::Operator::TaggedSymbol,
-                  values: T::Array[String]
-                }
-              )
-            end
-            def to_hash
-            end
-
-            # The property of the price to filter on.
-            module Field
-              extend Orb::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Orb::Plan::Adjustment::PercentageDiscount::Filter::Field
-                  )
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              PRICE_ID =
-                T.let(
-                  :price_id,
-                  Orb::Plan::Adjustment::PercentageDiscount::Filter::Field::TaggedSymbol
-                )
-              ITEM_ID =
-                T.let(
-                  :item_id,
-                  Orb::Plan::Adjustment::PercentageDiscount::Filter::Field::TaggedSymbol
-                )
-              PRICE_TYPE =
-                T.let(
-                  :price_type,
-                  Orb::Plan::Adjustment::PercentageDiscount::Filter::Field::TaggedSymbol
-                )
-              CURRENCY =
-                T.let(
-                  :currency,
-                  Orb::Plan::Adjustment::PercentageDiscount::Filter::Field::TaggedSymbol
-                )
-              PRICING_UNIT_ID =
-                T.let(
-                  :pricing_unit_id,
-                  Orb::Plan::Adjustment::PercentageDiscount::Filter::Field::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Orb::Plan::Adjustment::PercentageDiscount::Filter::Field::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-
-            # Should prices that match the filter be included or excluded.
-            module Operator
-              extend Orb::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Orb::Plan::Adjustment::PercentageDiscount::Filter::Operator
-                  )
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              INCLUDES =
-                T.let(
-                  :includes,
-                  Orb::Plan::Adjustment::PercentageDiscount::Filter::Operator::TaggedSymbol
-                )
-              EXCLUDES =
-                T.let(
-                  :excludes,
-                  Orb::Plan::Adjustment::PercentageDiscount::Filter::Operator::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Orb::Plan::Adjustment::PercentageDiscount::Filter::Operator::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-          end
-        end
-
-        class Minimum < Orb::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(Orb::Plan::Adjustment::Minimum, Orb::Internal::AnyHash)
-            end
-
-          sig { returns(String) }
-          attr_accessor :id
-
-          sig { returns(Symbol) }
-          attr_accessor :adjustment_type
-
-          # The price IDs that this adjustment applies to.
-          sig { returns(T::Array[String]) }
-          attr_accessor :applies_to_price_ids
-
-          # The filters that determine which prices to apply this adjustment to.
-          sig { returns(T::Array[Orb::Plan::Adjustment::Minimum::Filter]) }
-          attr_accessor :filters
-
-          # True for adjustments that apply to an entire invocice, false for adjustments
-          # that apply to only one price.
-          sig { returns(T::Boolean) }
-          attr_accessor :is_invoice_level
-
-          # The item ID that revenue from this minimum will be attributed to.
-          sig { returns(String) }
-          attr_accessor :item_id
-
-          # The minimum amount to charge in a given billing period for the prices this
-          # adjustment applies to.
-          sig { returns(String) }
-          attr_accessor :minimum_amount
-
-          # The plan phase in which this adjustment is active.
-          sig { returns(T.nilable(Integer)) }
-          attr_accessor :plan_phase_order
-
-          # The reason for the adjustment.
-          sig { returns(T.nilable(String)) }
-          attr_accessor :reason
-
-          sig do
-            params(
-              id: String,
-              applies_to_price_ids: T::Array[String],
-              filters: T::Array[Orb::Plan::Adjustment::Minimum::Filter::OrHash],
-              is_invoice_level: T::Boolean,
-              item_id: String,
-              minimum_amount: String,
-              plan_phase_order: T.nilable(Integer),
-              reason: T.nilable(String),
-              adjustment_type: Symbol
-            ).returns(T.attached_class)
-          end
-          def self.new(
-            id:,
-            # The price IDs that this adjustment applies to.
-            applies_to_price_ids:,
-            # The filters that determine which prices to apply this adjustment to.
-            filters:,
-            # True for adjustments that apply to an entire invocice, false for adjustments
-            # that apply to only one price.
-            is_invoice_level:,
-            # The item ID that revenue from this minimum will be attributed to.
-            item_id:,
-            # The minimum amount to charge in a given billing period for the prices this
-            # adjustment applies to.
-            minimum_amount:,
-            # The plan phase in which this adjustment is active.
-            plan_phase_order:,
-            # The reason for the adjustment.
-            reason:,
-            adjustment_type: :minimum
-          )
-          end
-
-          sig do
-            override.returns(
-              {
-                id: String,
-                adjustment_type: Symbol,
-                applies_to_price_ids: T::Array[String],
-                filters: T::Array[Orb::Plan::Adjustment::Minimum::Filter],
-                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
-
-          class Filter < Orb::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  Orb::Plan::Adjustment::Minimum::Filter,
-                  Orb::Internal::AnyHash
-                )
-              end
-
-            # The property of the price to filter on.
-            sig do
-              returns(
-                Orb::Plan::Adjustment::Minimum::Filter::Field::TaggedSymbol
-              )
-            end
-            attr_accessor :field
-
-            # Should prices that match the filter be included or excluded.
-            sig do
-              returns(
-                Orb::Plan::Adjustment::Minimum::Filter::Operator::TaggedSymbol
-              )
-            end
-            attr_accessor :operator
-
-            # The IDs or values that match this filter.
-            sig { returns(T::Array[String]) }
-            attr_accessor :values
-
-            sig do
-              params(
-                field: Orb::Plan::Adjustment::Minimum::Filter::Field::OrSymbol,
-                operator:
-                  Orb::Plan::Adjustment::Minimum::Filter::Operator::OrSymbol,
-                values: T::Array[String]
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              # The property of the price to filter on.
-              field:,
-              # Should prices that match the filter be included or excluded.
-              operator:,
-              # The IDs or values that match this filter.
-              values:
-            )
-            end
-
-            sig do
-              override.returns(
-                {
-                  field:
-                    Orb::Plan::Adjustment::Minimum::Filter::Field::TaggedSymbol,
-                  operator:
-                    Orb::Plan::Adjustment::Minimum::Filter::Operator::TaggedSymbol,
-                  values: T::Array[String]
-                }
-              )
-            end
-            def to_hash
-            end
-
-            # The property of the price to filter on.
-            module Field
-              extend Orb::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(Symbol, Orb::Plan::Adjustment::Minimum::Filter::Field)
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              PRICE_ID =
-                T.let(
-                  :price_id,
-                  Orb::Plan::Adjustment::Minimum::Filter::Field::TaggedSymbol
-                )
-              ITEM_ID =
-                T.let(
-                  :item_id,
-                  Orb::Plan::Adjustment::Minimum::Filter::Field::TaggedSymbol
-                )
-              PRICE_TYPE =
-                T.let(
-                  :price_type,
-                  Orb::Plan::Adjustment::Minimum::Filter::Field::TaggedSymbol
-                )
-              CURRENCY =
-                T.let(
-                  :currency,
-                  Orb::Plan::Adjustment::Minimum::Filter::Field::TaggedSymbol
-                )
-              PRICING_UNIT_ID =
-                T.let(
-                  :pricing_unit_id,
-                  Orb::Plan::Adjustment::Minimum::Filter::Field::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Orb::Plan::Adjustment::Minimum::Filter::Field::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-
-            # Should prices that match the filter be included or excluded.
-            module Operator
-              extend Orb::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Orb::Plan::Adjustment::Minimum::Filter::Operator
-                  )
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              INCLUDES =
-                T.let(
-                  :includes,
-                  Orb::Plan::Adjustment::Minimum::Filter::Operator::TaggedSymbol
-                )
-              EXCLUDES =
-                T.let(
-                  :excludes,
-                  Orb::Plan::Adjustment::Minimum::Filter::Operator::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Orb::Plan::Adjustment::Minimum::Filter::Operator::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-          end
-        end
-
-        class Maximum < Orb::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(Orb::Plan::Adjustment::Maximum, Orb::Internal::AnyHash)
-            end
-
-          sig { returns(String) }
-          attr_accessor :id
-
-          sig { returns(Symbol) }
-          attr_accessor :adjustment_type
-
-          # The price IDs that this adjustment applies to.
-          sig { returns(T::Array[String]) }
-          attr_accessor :applies_to_price_ids
-
-          # The filters that determine which prices to apply this adjustment to.
-          sig { returns(T::Array[Orb::Plan::Adjustment::Maximum::Filter]) }
-          attr_accessor :filters
-
-          # True for adjustments that apply to an entire invocice, false for adjustments
-          # that apply to only one price.
-          sig { returns(T::Boolean) }
-          attr_accessor :is_invoice_level
-
-          # The maximum amount to charge in a given billing period for the prices this
-          # adjustment applies to.
-          sig { returns(String) }
-          attr_accessor :maximum_amount
-
-          # The plan phase in which this adjustment is active.
-          sig { returns(T.nilable(Integer)) }
-          attr_accessor :plan_phase_order
-
-          # The reason for the adjustment.
-          sig { returns(T.nilable(String)) }
-          attr_accessor :reason
-
-          sig do
-            params(
-              id: String,
-              applies_to_price_ids: T::Array[String],
-              filters: T::Array[Orb::Plan::Adjustment::Maximum::Filter::OrHash],
-              is_invoice_level: T::Boolean,
-              maximum_amount: String,
-              plan_phase_order: T.nilable(Integer),
-              reason: T.nilable(String),
-              adjustment_type: Symbol
-            ).returns(T.attached_class)
-          end
-          def self.new(
-            id:,
-            # The price IDs that this adjustment applies to.
-            applies_to_price_ids:,
-            # The filters that determine which prices to apply this adjustment to.
-            filters:,
-            # True for adjustments that apply to an entire invocice, false for adjustments
-            # that apply to only one price.
-            is_invoice_level:,
-            # The maximum amount to charge in a given billing period for the prices this
-            # adjustment applies to.
-            maximum_amount:,
-            # The plan phase in which this adjustment is active.
-            plan_phase_order:,
-            # The reason for the adjustment.
-            reason:,
-            adjustment_type: :maximum
-          )
-          end
-
-          sig do
-            override.returns(
-              {
-                id: String,
-                adjustment_type: Symbol,
-                applies_to_price_ids: T::Array[String],
-                filters: T::Array[Orb::Plan::Adjustment::Maximum::Filter],
-                is_invoice_level: T::Boolean,
-                maximum_amount: String,
-                plan_phase_order: T.nilable(Integer),
-                reason: T.nilable(String)
-              }
-            )
-          end
-          def to_hash
-          end
-
-          class Filter < Orb::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  Orb::Plan::Adjustment::Maximum::Filter,
-                  Orb::Internal::AnyHash
-                )
-              end
-
-            # The property of the price to filter on.
-            sig do
-              returns(
-                Orb::Plan::Adjustment::Maximum::Filter::Field::TaggedSymbol
-              )
-            end
-            attr_accessor :field
-
-            # Should prices that match the filter be included or excluded.
-            sig do
-              returns(
-                Orb::Plan::Adjustment::Maximum::Filter::Operator::TaggedSymbol
-              )
-            end
-            attr_accessor :operator
-
-            # The IDs or values that match this filter.
-            sig { returns(T::Array[String]) }
-            attr_accessor :values
-
-            sig do
-              params(
-                field: Orb::Plan::Adjustment::Maximum::Filter::Field::OrSymbol,
-                operator:
-                  Orb::Plan::Adjustment::Maximum::Filter::Operator::OrSymbol,
-                values: T::Array[String]
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              # The property of the price to filter on.
-              field:,
-              # Should prices that match the filter be included or excluded.
-              operator:,
-              # The IDs or values that match this filter.
-              values:
-            )
-            end
-
-            sig do
-              override.returns(
-                {
-                  field:
-                    Orb::Plan::Adjustment::Maximum::Filter::Field::TaggedSymbol,
-                  operator:
-                    Orb::Plan::Adjustment::Maximum::Filter::Operator::TaggedSymbol,
-                  values: T::Array[String]
-                }
-              )
-            end
-            def to_hash
-            end
-
-            # The property of the price to filter on.
-            module Field
-              extend Orb::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(Symbol, Orb::Plan::Adjustment::Maximum::Filter::Field)
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              PRICE_ID =
-                T.let(
-                  :price_id,
-                  Orb::Plan::Adjustment::Maximum::Filter::Field::TaggedSymbol
-                )
-              ITEM_ID =
-                T.let(
-                  :item_id,
-                  Orb::Plan::Adjustment::Maximum::Filter::Field::TaggedSymbol
-                )
-              PRICE_TYPE =
-                T.let(
-                  :price_type,
-                  Orb::Plan::Adjustment::Maximum::Filter::Field::TaggedSymbol
-                )
-              CURRENCY =
-                T.let(
-                  :currency,
-                  Orb::Plan::Adjustment::Maximum::Filter::Field::TaggedSymbol
-                )
-              PRICING_UNIT_ID =
-                T.let(
-                  :pricing_unit_id,
-                  Orb::Plan::Adjustment::Maximum::Filter::Field::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Orb::Plan::Adjustment::Maximum::Filter::Field::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-
-            # Should prices that match the filter be included or excluded.
-            module Operator
-              extend Orb::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Orb::Plan::Adjustment::Maximum::Filter::Operator
-                  )
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              INCLUDES =
-                T.let(
-                  :includes,
-                  Orb::Plan::Adjustment::Maximum::Filter::Operator::TaggedSymbol
-                )
-              EXCLUDES =
-                T.let(
-                  :excludes,
-                  Orb::Plan::Adjustment::Maximum::Filter::Operator::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Orb::Plan::Adjustment::Maximum::Filter::Operator::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-          end
-        end
-
         sig { override.returns(T::Array[Orb::Plan::Adjustment::Variants]) }
         def self.variants
         end
@@ -1549,326 +347,6 @@ module Orb
         end
       end
 
-      class Maximum < Orb::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias { T.any(Orb::Plan::Maximum, Orb::Internal::AnyHash) }
-
-        # List of price_ids that this maximum amount applies to. For plan/plan phase
-        # maximums, this can be a subset of prices.
-        sig { returns(T::Array[String]) }
-        attr_accessor :applies_to_price_ids
-
-        # The filters that determine which prices to apply this maximum to.
-        sig { returns(T::Array[Orb::Plan::Maximum::Filter]) }
-        attr_accessor :filters
-
-        # Maximum amount applied
-        sig { returns(String) }
-        attr_accessor :maximum_amount
-
-        sig do
-          params(
-            applies_to_price_ids: T::Array[String],
-            filters: T::Array[Orb::Plan::Maximum::Filter::OrHash],
-            maximum_amount: String
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # List of price_ids that this maximum amount applies to. For plan/plan phase
-          # maximums, this can be a subset of prices.
-          applies_to_price_ids:,
-          # The filters that determine which prices to apply this maximum to.
-          filters:,
-          # Maximum amount applied
-          maximum_amount:
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              applies_to_price_ids: T::Array[String],
-              filters: T::Array[Orb::Plan::Maximum::Filter],
-              maximum_amount: String
-            }
-          )
-        end
-        def to_hash
-        end
-
-        class Filter < Orb::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(Orb::Plan::Maximum::Filter, Orb::Internal::AnyHash)
-            end
-
-          # The property of the price to filter on.
-          sig { returns(Orb::Plan::Maximum::Filter::Field::TaggedSymbol) }
-          attr_accessor :field
-
-          # Should prices that match the filter be included or excluded.
-          sig { returns(Orb::Plan::Maximum::Filter::Operator::TaggedSymbol) }
-          attr_accessor :operator
-
-          # The IDs or values that match this filter.
-          sig { returns(T::Array[String]) }
-          attr_accessor :values
-
-          sig do
-            params(
-              field: Orb::Plan::Maximum::Filter::Field::OrSymbol,
-              operator: Orb::Plan::Maximum::Filter::Operator::OrSymbol,
-              values: T::Array[String]
-            ).returns(T.attached_class)
-          end
-          def self.new(
-            # The property of the price to filter on.
-            field:,
-            # Should prices that match the filter be included or excluded.
-            operator:,
-            # The IDs or values that match this filter.
-            values:
-          )
-          end
-
-          sig do
-            override.returns(
-              {
-                field: Orb::Plan::Maximum::Filter::Field::TaggedSymbol,
-                operator: Orb::Plan::Maximum::Filter::Operator::TaggedSymbol,
-                values: T::Array[String]
-              }
-            )
-          end
-          def to_hash
-          end
-
-          # The property of the price to filter on.
-          module Field
-            extend Orb::Internal::Type::Enum
-
-            TaggedSymbol =
-              T.type_alias { T.all(Symbol, Orb::Plan::Maximum::Filter::Field) }
-            OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-            PRICE_ID =
-              T.let(:price_id, Orb::Plan::Maximum::Filter::Field::TaggedSymbol)
-            ITEM_ID =
-              T.let(:item_id, Orb::Plan::Maximum::Filter::Field::TaggedSymbol)
-            PRICE_TYPE =
-              T.let(
-                :price_type,
-                Orb::Plan::Maximum::Filter::Field::TaggedSymbol
-              )
-            CURRENCY =
-              T.let(:currency, Orb::Plan::Maximum::Filter::Field::TaggedSymbol)
-            PRICING_UNIT_ID =
-              T.let(
-                :pricing_unit_id,
-                Orb::Plan::Maximum::Filter::Field::TaggedSymbol
-              )
-
-            sig do
-              override.returns(
-                T::Array[Orb::Plan::Maximum::Filter::Field::TaggedSymbol]
-              )
-            end
-            def self.values
-            end
-          end
-
-          # Should prices that match the filter be included or excluded.
-          module Operator
-            extend Orb::Internal::Type::Enum
-
-            TaggedSymbol =
-              T.type_alias do
-                T.all(Symbol, Orb::Plan::Maximum::Filter::Operator)
-              end
-            OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-            INCLUDES =
-              T.let(
-                :includes,
-                Orb::Plan::Maximum::Filter::Operator::TaggedSymbol
-              )
-            EXCLUDES =
-              T.let(
-                :excludes,
-                Orb::Plan::Maximum::Filter::Operator::TaggedSymbol
-              )
-
-            sig do
-              override.returns(
-                T::Array[Orb::Plan::Maximum::Filter::Operator::TaggedSymbol]
-              )
-            end
-            def self.values
-            end
-          end
-        end
-      end
-
-      class Minimum < Orb::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias { T.any(Orb::Plan::Minimum, Orb::Internal::AnyHash) }
-
-        # List of price_ids that this minimum amount applies to. For plan/plan phase
-        # minimums, this can be a subset of prices.
-        sig { returns(T::Array[String]) }
-        attr_accessor :applies_to_price_ids
-
-        # The filters that determine which prices to apply this minimum to.
-        sig { returns(T::Array[Orb::Plan::Minimum::Filter]) }
-        attr_accessor :filters
-
-        # Minimum amount applied
-        sig { returns(String) }
-        attr_accessor :minimum_amount
-
-        sig do
-          params(
-            applies_to_price_ids: T::Array[String],
-            filters: T::Array[Orb::Plan::Minimum::Filter::OrHash],
-            minimum_amount: String
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # List of price_ids that this minimum amount applies to. For plan/plan phase
-          # minimums, this can be a subset of prices.
-          applies_to_price_ids:,
-          # The filters that determine which prices to apply this minimum to.
-          filters:,
-          # Minimum amount applied
-          minimum_amount:
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              applies_to_price_ids: T::Array[String],
-              filters: T::Array[Orb::Plan::Minimum::Filter],
-              minimum_amount: String
-            }
-          )
-        end
-        def to_hash
-        end
-
-        class Filter < Orb::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(Orb::Plan::Minimum::Filter, Orb::Internal::AnyHash)
-            end
-
-          # The property of the price to filter on.
-          sig { returns(Orb::Plan::Minimum::Filter::Field::TaggedSymbol) }
-          attr_accessor :field
-
-          # Should prices that match the filter be included or excluded.
-          sig { returns(Orb::Plan::Minimum::Filter::Operator::TaggedSymbol) }
-          attr_accessor :operator
-
-          # The IDs or values that match this filter.
-          sig { returns(T::Array[String]) }
-          attr_accessor :values
-
-          sig do
-            params(
-              field: Orb::Plan::Minimum::Filter::Field::OrSymbol,
-              operator: Orb::Plan::Minimum::Filter::Operator::OrSymbol,
-              values: T::Array[String]
-            ).returns(T.attached_class)
-          end
-          def self.new(
-            # The property of the price to filter on.
-            field:,
-            # Should prices that match the filter be included or excluded.
-            operator:,
-            # The IDs or values that match this filter.
-            values:
-          )
-          end
-
-          sig do
-            override.returns(
-              {
-                field: Orb::Plan::Minimum::Filter::Field::TaggedSymbol,
-                operator: Orb::Plan::Minimum::Filter::Operator::TaggedSymbol,
-                values: T::Array[String]
-              }
-            )
-          end
-          def to_hash
-          end
-
-          # The property of the price to filter on.
-          module Field
-            extend Orb::Internal::Type::Enum
-
-            TaggedSymbol =
-              T.type_alias { T.all(Symbol, Orb::Plan::Minimum::Filter::Field) }
-            OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-            PRICE_ID =
-              T.let(:price_id, Orb::Plan::Minimum::Filter::Field::TaggedSymbol)
-            ITEM_ID =
-              T.let(:item_id, Orb::Plan::Minimum::Filter::Field::TaggedSymbol)
-            PRICE_TYPE =
-              T.let(
-                :price_type,
-                Orb::Plan::Minimum::Filter::Field::TaggedSymbol
-              )
-            CURRENCY =
-              T.let(:currency, Orb::Plan::Minimum::Filter::Field::TaggedSymbol)
-            PRICING_UNIT_ID =
-              T.let(
-                :pricing_unit_id,
-                Orb::Plan::Minimum::Filter::Field::TaggedSymbol
-              )
-
-            sig do
-              override.returns(
-                T::Array[Orb::Plan::Minimum::Filter::Field::TaggedSymbol]
-              )
-            end
-            def self.values
-            end
-          end
-
-          # Should prices that match the filter be included or excluded.
-          module Operator
-            extend Orb::Internal::Type::Enum
-
-            TaggedSymbol =
-              T.type_alias do
-                T.all(Symbol, Orb::Plan::Minimum::Filter::Operator)
-              end
-            OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-            INCLUDES =
-              T.let(
-                :includes,
-                Orb::Plan::Minimum::Filter::Operator::TaggedSymbol
-              )
-            EXCLUDES =
-              T.let(
-                :excludes,
-                Orb::Plan::Minimum::Filter::Operator::TaggedSymbol
-              )
-
-            sig do
-              override.returns(
-                T::Array[Orb::Plan::Minimum::Filter::Operator::TaggedSymbol]
-              )
-            end
-            def self.values
-            end
-          end
-        end
-      end
-
       class PlanPhase < Orb::Internal::Type::BaseModel
         OrHash =
           T.type_alias { T.any(Orb::Plan::PlanPhase, Orb::Internal::AnyHash) }
@@ -1892,23 +370,19 @@ module Orb
         end
         attr_accessor :duration_unit
 
-        sig { returns(T.nilable(Orb::Plan::PlanPhase::Maximum)) }
+        sig { returns(T.nilable(Orb::Maximum)) }
         attr_reader :maximum
 
-        sig do
-          params(maximum: T.nilable(Orb::Plan::PlanPhase::Maximum::OrHash)).void
-        end
+        sig { params(maximum: T.nilable(Orb::Maximum::OrHash)).void }
         attr_writer :maximum
 
         sig { returns(T.nilable(String)) }
         attr_accessor :maximum_amount
 
-        sig { returns(T.nilable(Orb::Plan::PlanPhase::Minimum)) }
+        sig { returns(T.nilable(Orb::Minimum)) }
         attr_reader :minimum
 
-        sig do
-          params(minimum: T.nilable(Orb::Plan::PlanPhase::Minimum::OrHash)).void
-        end
+        sig { params(minimum: T.nilable(Orb::Minimum::OrHash)).void }
         attr_writer :minimum
 
         sig { returns(T.nilable(String)) }
@@ -1937,9 +411,9 @@ module Orb
             duration: T.nilable(Integer),
             duration_unit:
               T.nilable(Orb::Plan::PlanPhase::DurationUnit::OrSymbol),
-            maximum: T.nilable(Orb::Plan::PlanPhase::Maximum::OrHash),
+            maximum: T.nilable(Orb::Maximum::OrHash),
             maximum_amount: T.nilable(String),
-            minimum: T.nilable(Orb::Plan::PlanPhase::Minimum::OrHash),
+            minimum: T.nilable(Orb::Minimum::OrHash),
             minimum_amount: T.nilable(String),
             name: String,
             order: Integer
@@ -1972,9 +446,9 @@ module Orb
               duration: T.nilable(Integer),
               duration_unit:
                 T.nilable(Orb::Plan::PlanPhase::DurationUnit::TaggedSymbol),
-              maximum: T.nilable(Orb::Plan::PlanPhase::Maximum),
+              maximum: T.nilable(Orb::Maximum),
               maximum_amount: T.nilable(String),
-              minimum: T.nilable(Orb::Plan::PlanPhase::Minimum),
+              minimum: T.nilable(Orb::Minimum),
               minimum_amount: T.nilable(String),
               name: String,
               order: Integer
@@ -2013,388 +487,6 @@ module Orb
           def self.values
           end
         end
-
-        class Maximum < Orb::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(Orb::Plan::PlanPhase::Maximum, Orb::Internal::AnyHash)
-            end
-
-          # List of price_ids that this maximum amount applies to. For plan/plan phase
-          # maximums, this can be a subset of prices.
-          sig { returns(T::Array[String]) }
-          attr_accessor :applies_to_price_ids
-
-          # The filters that determine which prices to apply this maximum to.
-          sig { returns(T::Array[Orb::Plan::PlanPhase::Maximum::Filter]) }
-          attr_accessor :filters
-
-          # Maximum amount applied
-          sig { returns(String) }
-          attr_accessor :maximum_amount
-
-          sig do
-            params(
-              applies_to_price_ids: T::Array[String],
-              filters: T::Array[Orb::Plan::PlanPhase::Maximum::Filter::OrHash],
-              maximum_amount: String
-            ).returns(T.attached_class)
-          end
-          def self.new(
-            # List of price_ids that this maximum amount applies to. For plan/plan phase
-            # maximums, this can be a subset of prices.
-            applies_to_price_ids:,
-            # The filters that determine which prices to apply this maximum to.
-            filters:,
-            # Maximum amount applied
-            maximum_amount:
-          )
-          end
-
-          sig do
-            override.returns(
-              {
-                applies_to_price_ids: T::Array[String],
-                filters: T::Array[Orb::Plan::PlanPhase::Maximum::Filter],
-                maximum_amount: String
-              }
-            )
-          end
-          def to_hash
-          end
-
-          class Filter < Orb::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  Orb::Plan::PlanPhase::Maximum::Filter,
-                  Orb::Internal::AnyHash
-                )
-              end
-
-            # The property of the price to filter on.
-            sig do
-              returns(
-                Orb::Plan::PlanPhase::Maximum::Filter::Field::TaggedSymbol
-              )
-            end
-            attr_accessor :field
-
-            # Should prices that match the filter be included or excluded.
-            sig do
-              returns(
-                Orb::Plan::PlanPhase::Maximum::Filter::Operator::TaggedSymbol
-              )
-            end
-            attr_accessor :operator
-
-            # The IDs or values that match this filter.
-            sig { returns(T::Array[String]) }
-            attr_accessor :values
-
-            sig do
-              params(
-                field: Orb::Plan::PlanPhase::Maximum::Filter::Field::OrSymbol,
-                operator:
-                  Orb::Plan::PlanPhase::Maximum::Filter::Operator::OrSymbol,
-                values: T::Array[String]
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              # The property of the price to filter on.
-              field:,
-              # Should prices that match the filter be included or excluded.
-              operator:,
-              # The IDs or values that match this filter.
-              values:
-            )
-            end
-
-            sig do
-              override.returns(
-                {
-                  field:
-                    Orb::Plan::PlanPhase::Maximum::Filter::Field::TaggedSymbol,
-                  operator:
-                    Orb::Plan::PlanPhase::Maximum::Filter::Operator::TaggedSymbol,
-                  values: T::Array[String]
-                }
-              )
-            end
-            def to_hash
-            end
-
-            # The property of the price to filter on.
-            module Field
-              extend Orb::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(Symbol, Orb::Plan::PlanPhase::Maximum::Filter::Field)
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              PRICE_ID =
-                T.let(
-                  :price_id,
-                  Orb::Plan::PlanPhase::Maximum::Filter::Field::TaggedSymbol
-                )
-              ITEM_ID =
-                T.let(
-                  :item_id,
-                  Orb::Plan::PlanPhase::Maximum::Filter::Field::TaggedSymbol
-                )
-              PRICE_TYPE =
-                T.let(
-                  :price_type,
-                  Orb::Plan::PlanPhase::Maximum::Filter::Field::TaggedSymbol
-                )
-              CURRENCY =
-                T.let(
-                  :currency,
-                  Orb::Plan::PlanPhase::Maximum::Filter::Field::TaggedSymbol
-                )
-              PRICING_UNIT_ID =
-                T.let(
-                  :pricing_unit_id,
-                  Orb::Plan::PlanPhase::Maximum::Filter::Field::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Orb::Plan::PlanPhase::Maximum::Filter::Field::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-
-            # Should prices that match the filter be included or excluded.
-            module Operator
-              extend Orb::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(Symbol, Orb::Plan::PlanPhase::Maximum::Filter::Operator)
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              INCLUDES =
-                T.let(
-                  :includes,
-                  Orb::Plan::PlanPhase::Maximum::Filter::Operator::TaggedSymbol
-                )
-              EXCLUDES =
-                T.let(
-                  :excludes,
-                  Orb::Plan::PlanPhase::Maximum::Filter::Operator::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Orb::Plan::PlanPhase::Maximum::Filter::Operator::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-          end
-        end
-
-        class Minimum < Orb::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(Orb::Plan::PlanPhase::Minimum, Orb::Internal::AnyHash)
-            end
-
-          # List of price_ids that this minimum amount applies to. For plan/plan phase
-          # minimums, this can be a subset of prices.
-          sig { returns(T::Array[String]) }
-          attr_accessor :applies_to_price_ids
-
-          # The filters that determine which prices to apply this minimum to.
-          sig { returns(T::Array[Orb::Plan::PlanPhase::Minimum::Filter]) }
-          attr_accessor :filters
-
-          # Minimum amount applied
-          sig { returns(String) }
-          attr_accessor :minimum_amount
-
-          sig do
-            params(
-              applies_to_price_ids: T::Array[String],
-              filters: T::Array[Orb::Plan::PlanPhase::Minimum::Filter::OrHash],
-              minimum_amount: String
-            ).returns(T.attached_class)
-          end
-          def self.new(
-            # List of price_ids that this minimum amount applies to. For plan/plan phase
-            # minimums, this can be a subset of prices.
-            applies_to_price_ids:,
-            # The filters that determine which prices to apply this minimum to.
-            filters:,
-            # Minimum amount applied
-            minimum_amount:
-          )
-          end
-
-          sig do
-            override.returns(
-              {
-                applies_to_price_ids: T::Array[String],
-                filters: T::Array[Orb::Plan::PlanPhase::Minimum::Filter],
-                minimum_amount: String
-              }
-            )
-          end
-          def to_hash
-          end
-
-          class Filter < Orb::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  Orb::Plan::PlanPhase::Minimum::Filter,
-                  Orb::Internal::AnyHash
-                )
-              end
-
-            # The property of the price to filter on.
-            sig do
-              returns(
-                Orb::Plan::PlanPhase::Minimum::Filter::Field::TaggedSymbol
-              )
-            end
-            attr_accessor :field
-
-            # Should prices that match the filter be included or excluded.
-            sig do
-              returns(
-                Orb::Plan::PlanPhase::Minimum::Filter::Operator::TaggedSymbol
-              )
-            end
-            attr_accessor :operator
-
-            # The IDs or values that match this filter.
-            sig { returns(T::Array[String]) }
-            attr_accessor :values
-
-            sig do
-              params(
-                field: Orb::Plan::PlanPhase::Minimum::Filter::Field::OrSymbol,
-                operator:
-                  Orb::Plan::PlanPhase::Minimum::Filter::Operator::OrSymbol,
-                values: T::Array[String]
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              # The property of the price to filter on.
-              field:,
-              # Should prices that match the filter be included or excluded.
-              operator:,
-              # The IDs or values that match this filter.
-              values:
-            )
-            end
-
-            sig do
-              override.returns(
-                {
-                  field:
-                    Orb::Plan::PlanPhase::Minimum::Filter::Field::TaggedSymbol,
-                  operator:
-                    Orb::Plan::PlanPhase::Minimum::Filter::Operator::TaggedSymbol,
-                  values: T::Array[String]
-                }
-              )
-            end
-            def to_hash
-            end
-
-            # The property of the price to filter on.
-            module Field
-              extend Orb::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(Symbol, Orb::Plan::PlanPhase::Minimum::Filter::Field)
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              PRICE_ID =
-                T.let(
-                  :price_id,
-                  Orb::Plan::PlanPhase::Minimum::Filter::Field::TaggedSymbol
-                )
-              ITEM_ID =
-                T.let(
-                  :item_id,
-                  Orb::Plan::PlanPhase::Minimum::Filter::Field::TaggedSymbol
-                )
-              PRICE_TYPE =
-                T.let(
-                  :price_type,
-                  Orb::Plan::PlanPhase::Minimum::Filter::Field::TaggedSymbol
-                )
-              CURRENCY =
-                T.let(
-                  :currency,
-                  Orb::Plan::PlanPhase::Minimum::Filter::Field::TaggedSymbol
-                )
-              PRICING_UNIT_ID =
-                T.let(
-                  :pricing_unit_id,
-                  Orb::Plan::PlanPhase::Minimum::Filter::Field::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Orb::Plan::PlanPhase::Minimum::Filter::Field::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-
-            # Should prices that match the filter be included or excluded.
-            module Operator
-              extend Orb::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(Symbol, Orb::Plan::PlanPhase::Minimum::Filter::Operator)
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              INCLUDES =
-                T.let(
-                  :includes,
-                  Orb::Plan::PlanPhase::Minimum::Filter::Operator::TaggedSymbol
-                )
-              EXCLUDES =
-                T.let(
-                  :excludes,
-                  Orb::Plan::PlanPhase::Minimum::Filter::Operator::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Orb::Plan::PlanPhase::Minimum::Filter::Operator::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-          end
-        end
       end
 
       class Product < Orb::Internal::Type::BaseModel