orb-billing 1.13.0 → 1.15.0

data/rbi/orb/models/plan_create_params.rbi

@@ -31,6 +31,10 @@ module Orb
       sig { returns(T.nilable(String)) }
       attr_accessor :default_invoice_memo
 
+      # An optional user-defined description of the plan.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
       sig { returns(T.nilable(String)) }
       attr_accessor :external_plan_id
 
@@ -67,6 +71,7 @@ module Orb
           adjustments:
             T.nilable(T::Array[Orb::PlanCreateParams::Adjustment::OrHash]),
           default_invoice_memo: T.nilable(String),
+          description: T.nilable(String),
           external_plan_id: T.nilable(String),
           metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
           net_terms: T.nilable(Integer),
@@ -89,6 +94,8 @@ module Orb
         adjustments: nil,
         # Free-form text which is available on the invoice PDF and the Orb invoice portal.
         default_invoice_memo: nil,
+        # An optional user-defined description of the plan.
+        description: nil,
         external_plan_id: nil,
         # User-specified key/value pairs for the resource. Individual keys can be removed
         # by setting the value to `null`, and the entire metadata mapping can be cleared
@@ -116,6 +123,7 @@ module Orb
             prices: T::Array[Orb::PlanCreateParams::Price],
             adjustments: T.nilable(T::Array[Orb::PlanCreateParams::Adjustment]),
             default_invoice_memo: T.nilable(String),
+            description: T.nilable(String),
             external_plan_id: T.nilable(String),
             metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
             net_terms: T.nilable(Integer),
@@ -145,6 +153,24 @@ module Orb
         end
         attr_writer :allocation_price
 
+        # The license allocation price to add to the plan.
+        sig do
+          returns(
+            T.nilable(Orb::PlanCreateParams::Price::LicenseAllocationPrice)
+          )
+        end
+        attr_reader :license_allocation_price
+
+        sig do
+          params(
+            license_allocation_price:
+              T.nilable(
+                Orb::PlanCreateParams::Price::LicenseAllocationPrice::OrHash
+              )
+          ).void
+        end
+        attr_writer :license_allocation_price
+
         # The phase to add this price to.
         sig { returns(T.nilable(Integer)) }
         attr_accessor :plan_phase_order
@@ -168,6 +194,7 @@ module Orb
                 Orb::NewPlanPackageWithAllocationPrice,
                 Orb::NewPlanUnitWithPercentPrice,
                 Orb::NewPlanMatrixWithAllocationPrice,
+                Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts,
                 Orb::PlanCreateParams::Price::Price::TieredWithProration,
                 Orb::NewPlanUnitWithProrationPrice,
                 Orb::NewPlanGroupedAllocationPrice,
@@ -182,6 +209,8 @@ module Orb
                 Orb::NewPlanScalableMatrixWithTieredPricingPrice,
                 Orb::NewPlanCumulativeGroupedBulkPrice,
                 Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation,
+                Orb::PlanCreateParams::Price::Price::DailyCreditAllowance,
+                Orb::PlanCreateParams::Price::Price::MeteredAllowance,
                 Orb::NewPlanMinimumCompositePrice,
                 Orb::PlanCreateParams::Price::Price::Percent,
                 Orb::PlanCreateParams::Price::Price::EventOutput
@@ -194,6 +223,10 @@ module Orb
         sig do
           params(
             allocation_price: T.nilable(Orb::NewAllocationPrice::OrHash),
+            license_allocation_price:
+              T.nilable(
+                Orb::PlanCreateParams::Price::LicenseAllocationPrice::OrHash
+              ),
             plan_phase_order: T.nilable(Integer),
             price:
               T.nilable(
@@ -212,6 +245,7 @@ module Orb
                   Orb::NewPlanPackageWithAllocationPrice::OrHash,
                   Orb::NewPlanUnitWithPercentPrice::OrHash,
                   Orb::NewPlanMatrixWithAllocationPrice::OrHash,
+                  Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::OrHash,
                   Orb::PlanCreateParams::Price::Price::TieredWithProration::OrHash,
                   Orb::NewPlanUnitWithProrationPrice::OrHash,
                   Orb::NewPlanGroupedAllocationPrice::OrHash,
@@ -226,6 +260,8 @@ module Orb
                   Orb::NewPlanScalableMatrixWithTieredPricingPrice::OrHash,
                   Orb::NewPlanCumulativeGroupedBulkPrice::OrHash,
                   Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::OrHash,
+                  Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::OrHash,
+                  Orb::PlanCreateParams::Price::Price::MeteredAllowance::OrHash,
                   Orb::NewPlanMinimumCompositePrice::OrHash,
                   Orb::PlanCreateParams::Price::Price::Percent::OrHash,
                   Orb::PlanCreateParams::Price::Price::EventOutput::OrHash
@@ -236,6 +272,8 @@ module Orb
         def self.new(
           # The allocation price to add to the plan.
           allocation_price: nil,
+          # The license allocation price to add to the plan.
+          license_allocation_price: nil,
           # The phase to add this price to.
           plan_phase_order: nil,
           # New plan price request body params.
@@ -247,6 +285,8 @@ module Orb
           override.returns(
             {
               allocation_price: T.nilable(Orb::NewAllocationPrice),
+              license_allocation_price:
+                T.nilable(Orb::PlanCreateParams::Price::LicenseAllocationPrice),
               plan_phase_order: T.nilable(Integer),
               price:
                 T.nilable(
@@ -265,6 +305,7 @@ module Orb
                     Orb::NewPlanPackageWithAllocationPrice,
                     Orb::NewPlanUnitWithPercentPrice,
                     Orb::NewPlanMatrixWithAllocationPrice,
+                    Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts,
                     Orb::PlanCreateParams::Price::Price::TieredWithProration,
                     Orb::NewPlanUnitWithProrationPrice,
                     Orb::NewPlanGroupedAllocationPrice,
@@ -279,6 +320,8 @@ module Orb
                     Orb::NewPlanScalableMatrixWithTieredPricingPrice,
                     Orb::NewPlanCumulativeGroupedBulkPrice,
                     Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation,
+                    Orb::PlanCreateParams::Price::Price::DailyCreditAllowance,
+                    Orb::PlanCreateParams::Price::Price::MeteredAllowance,
                     Orb::NewPlanMinimumCompositePrice,
                     Orb::PlanCreateParams::Price::Price::Percent,
                     Orb::PlanCreateParams::Price::Price::EventOutput
@@ -290,6 +333,430 @@ module Orb
         def to_hash
         end
 
+        class LicenseAllocationPrice < Orb::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Orb::PlanCreateParams::Price::LicenseAllocationPrice,
+                Orb::Internal::AnyHash
+              )
+            end
+
+          # The cadence to bill for this price on.
+          sig do
+            returns(
+              Orb::PlanCreateParams::Price::LicenseAllocationPrice::Cadence::OrSymbol
+            )
+          end
+          attr_accessor :cadence
+
+          # The id of the item the price will be associated with.
+          sig { returns(String) }
+          attr_accessor :item_id
+
+          # License allocations to associate with this price. Each entry defines a
+          # per-license credit pool granted each cadence. Requires license_type_id or
+          # license_type_configuration to be set.
+          sig do
+            returns(
+              T::Array[
+                Orb::PlanCreateParams::Price::LicenseAllocationPrice::LicenseAllocation
+              ]
+            )
+          end
+          attr_accessor :license_allocations
+
+          # The pricing model type
+          sig do
+            returns(
+              Orb::PlanCreateParams::Price::LicenseAllocationPrice::ModelType::OrSymbol
+            )
+          end
+          attr_accessor :model_type
+
+          # The name of the price.
+          sig { returns(String) }
+          attr_accessor :name
+
+          # Configuration for unit pricing
+          sig { returns(Orb::UnitConfig) }
+          attr_reader :unit_config
+
+          sig { params(unit_config: Orb::UnitConfig::OrHash).void }
+          attr_writer :unit_config
+
+          # The id of the billable metric for the price. Only needed if the price is
+          # usage-based.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :billable_metric_id
+
+          # If the Price represents a fixed cost, the price will be billed in-advance if
+          # this is true, and in-arrears if this is false.
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_accessor :billed_in_advance
+
+          # For custom cadence: specifies the duration of the billing period in days or
+          # months.
+          sig { returns(T.nilable(Orb::NewBillingCycleConfiguration)) }
+          attr_reader :billing_cycle_configuration
+
+          sig do
+            params(
+              billing_cycle_configuration:
+                T.nilable(Orb::NewBillingCycleConfiguration::OrHash)
+            ).void
+          end
+          attr_writer :billing_cycle_configuration
+
+          # The per unit conversion rate of the price currency to the invoicing currency.
+          sig { returns(T.nilable(Float)) }
+          attr_accessor :conversion_rate
+
+          # The configuration for the rate of the price currency to the invoicing currency.
+          sig do
+            returns(
+              T.nilable(
+                T.any(
+                  Orb::UnitConversionRateConfig,
+                  Orb::TieredConversionRateConfig
+                )
+              )
+            )
+          end
+          attr_accessor :conversion_rate_config
+
+          # An ISO 4217 currency string, or custom pricing unit identifier, in which this
+          # price is billed.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :currency
+
+          # For dimensional price: specifies a price group and dimension values
+          sig { returns(T.nilable(Orb::NewDimensionalPriceConfiguration)) }
+          attr_reader :dimensional_price_configuration
+
+          sig do
+            params(
+              dimensional_price_configuration:
+                T.nilable(Orb::NewDimensionalPriceConfiguration::OrHash)
+            ).void
+          end
+          attr_writer :dimensional_price_configuration
+
+          # An alias for the price.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :external_price_id
+
+          # If the Price represents a fixed cost, this represents the quantity of units
+          # applied.
+          sig { returns(T.nilable(Float)) }
+          attr_accessor :fixed_price_quantity
+
+          # The property used to group this price on an invoice
+          sig { returns(T.nilable(String)) }
+          attr_accessor :invoice_grouping_key
+
+          # Within each billing cycle, specifies the cadence at which invoices are produced.
+          # If unspecified, a single invoice is produced per billing cycle.
+          sig { returns(T.nilable(Orb::NewBillingCycleConfiguration)) }
+          attr_reader :invoicing_cycle_configuration
+
+          sig do
+            params(
+              invoicing_cycle_configuration:
+                T.nilable(Orb::NewBillingCycleConfiguration::OrHash)
+            ).void
+          end
+          attr_writer :invoicing_cycle_configuration
+
+          # The ID of the license type to associate with this price.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :license_type_id
+
+          # User-specified key/value pairs for the resource. Individual keys can be removed
+          # by setting the value to `null`, and the entire metadata mapping can be cleared
+          # by setting `metadata` to `null`.
+          sig { returns(T.nilable(T::Hash[Symbol, T.nilable(String)])) }
+          attr_accessor :metadata
+
+          # A transient ID that can be used to reference this price when adding adjustments
+          # in the same API call.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :reference_id
+
+          # The license allocation price to add to the plan.
+          sig do
+            params(
+              cadence:
+                Orb::PlanCreateParams::Price::LicenseAllocationPrice::Cadence::OrSymbol,
+              item_id: String,
+              license_allocations:
+                T::Array[
+                  Orb::PlanCreateParams::Price::LicenseAllocationPrice::LicenseAllocation::OrHash
+                ],
+              model_type:
+                Orb::PlanCreateParams::Price::LicenseAllocationPrice::ModelType::OrSymbol,
+              name: String,
+              unit_config: Orb::UnitConfig::OrHash,
+              billable_metric_id: T.nilable(String),
+              billed_in_advance: T.nilable(T::Boolean),
+              billing_cycle_configuration:
+                T.nilable(Orb::NewBillingCycleConfiguration::OrHash),
+              conversion_rate: T.nilable(Float),
+              conversion_rate_config:
+                T.nilable(
+                  T.any(
+                    Orb::UnitConversionRateConfig::OrHash,
+                    Orb::TieredConversionRateConfig::OrHash
+                  )
+                ),
+              currency: T.nilable(String),
+              dimensional_price_configuration:
+                T.nilable(Orb::NewDimensionalPriceConfiguration::OrHash),
+              external_price_id: T.nilable(String),
+              fixed_price_quantity: T.nilable(Float),
+              invoice_grouping_key: T.nilable(String),
+              invoicing_cycle_configuration:
+                T.nilable(Orb::NewBillingCycleConfiguration::OrHash),
+              license_type_id: T.nilable(String),
+              metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+              reference_id: T.nilable(String)
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The cadence to bill for this price on.
+            cadence:,
+            # The id of the item the price will be associated with.
+            item_id:,
+            # License allocations to associate with this price. Each entry defines a
+            # per-license credit pool granted each cadence. Requires license_type_id or
+            # license_type_configuration to be set.
+            license_allocations:,
+            # The pricing model type
+            model_type:,
+            # The name of the price.
+            name:,
+            # Configuration for unit pricing
+            unit_config:,
+            # The id of the billable metric for the price. Only needed if the price is
+            # usage-based.
+            billable_metric_id: nil,
+            # If the Price represents a fixed cost, the price will be billed in-advance if
+            # this is true, and in-arrears if this is false.
+            billed_in_advance: nil,
+            # For custom cadence: specifies the duration of the billing period in days or
+            # months.
+            billing_cycle_configuration: nil,
+            # The per unit conversion rate of the price currency to the invoicing currency.
+            conversion_rate: nil,
+            # The configuration for the rate of the price currency to the invoicing currency.
+            conversion_rate_config: nil,
+            # An ISO 4217 currency string, or custom pricing unit identifier, in which this
+            # price is billed.
+            currency: nil,
+            # For dimensional price: specifies a price group and dimension values
+            dimensional_price_configuration: nil,
+            # An alias for the price.
+            external_price_id: nil,
+            # If the Price represents a fixed cost, this represents the quantity of units
+            # applied.
+            fixed_price_quantity: nil,
+            # The property used to group this price on an invoice
+            invoice_grouping_key: nil,
+            # Within each billing cycle, specifies the cadence at which invoices are produced.
+            # If unspecified, a single invoice is produced per billing cycle.
+            invoicing_cycle_configuration: nil,
+            # The ID of the license type to associate with this price.
+            license_type_id: nil,
+            # User-specified key/value pairs for the resource. Individual keys can be removed
+            # by setting the value to `null`, and the entire metadata mapping can be cleared
+            # by setting `metadata` to `null`.
+            metadata: nil,
+            # A transient ID that can be used to reference this price when adding adjustments
+            # in the same API call.
+            reference_id: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                cadence:
+                  Orb::PlanCreateParams::Price::LicenseAllocationPrice::Cadence::OrSymbol,
+                item_id: String,
+                license_allocations:
+                  T::Array[
+                    Orb::PlanCreateParams::Price::LicenseAllocationPrice::LicenseAllocation
+                  ],
+                model_type:
+                  Orb::PlanCreateParams::Price::LicenseAllocationPrice::ModelType::OrSymbol,
+                name: String,
+                unit_config: Orb::UnitConfig,
+                billable_metric_id: T.nilable(String),
+                billed_in_advance: T.nilable(T::Boolean),
+                billing_cycle_configuration:
+                  T.nilable(Orb::NewBillingCycleConfiguration),
+                conversion_rate: T.nilable(Float),
+                conversion_rate_config:
+                  T.nilable(
+                    T.any(
+                      Orb::UnitConversionRateConfig,
+                      Orb::TieredConversionRateConfig
+                    )
+                  ),
+                currency: T.nilable(String),
+                dimensional_price_configuration:
+                  T.nilable(Orb::NewDimensionalPriceConfiguration),
+                external_price_id: T.nilable(String),
+                fixed_price_quantity: T.nilable(Float),
+                invoice_grouping_key: T.nilable(String),
+                invoicing_cycle_configuration:
+                  T.nilable(Orb::NewBillingCycleConfiguration),
+                license_type_id: T.nilable(String),
+                metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+                reference_id: T.nilable(String)
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # The cadence to bill for this price on.
+          module Cadence
+            extend Orb::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Orb::PlanCreateParams::Price::LicenseAllocationPrice::Cadence
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            ANNUAL =
+              T.let(
+                :annual,
+                Orb::PlanCreateParams::Price::LicenseAllocationPrice::Cadence::TaggedSymbol
+              )
+            SEMI_ANNUAL =
+              T.let(
+                :semi_annual,
+                Orb::PlanCreateParams::Price::LicenseAllocationPrice::Cadence::TaggedSymbol
+              )
+            MONTHLY =
+              T.let(
+                :monthly,
+                Orb::PlanCreateParams::Price::LicenseAllocationPrice::Cadence::TaggedSymbol
+              )
+            QUARTERLY =
+              T.let(
+                :quarterly,
+                Orb::PlanCreateParams::Price::LicenseAllocationPrice::Cadence::TaggedSymbol
+              )
+            ONE_TIME =
+              T.let(
+                :one_time,
+                Orb::PlanCreateParams::Price::LicenseAllocationPrice::Cadence::TaggedSymbol
+              )
+            CUSTOM =
+              T.let(
+                :custom,
+                Orb::PlanCreateParams::Price::LicenseAllocationPrice::Cadence::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Orb::PlanCreateParams::Price::LicenseAllocationPrice::Cadence::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+
+          class LicenseAllocation < Orb::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Orb::PlanCreateParams::Price::LicenseAllocationPrice::LicenseAllocation,
+                  Orb::Internal::AnyHash
+                )
+              end
+
+            # The amount of credits granted per active license per cadence.
+            sig { returns(String) }
+            attr_accessor :amount
+
+            # The currency of the license allocation.
+            sig { returns(String) }
+            attr_accessor :currency
+
+            # When True, overage beyond the allocation is written off.
+            sig { returns(T.nilable(T::Boolean)) }
+            attr_accessor :write_off_overage
+
+            sig do
+              params(
+                amount: String,
+                currency: String,
+                write_off_overage: T.nilable(T::Boolean)
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # The amount of credits granted per active license per cadence.
+              amount:,
+              # The currency of the license allocation.
+              currency:,
+              # When True, overage beyond the allocation is written off.
+              write_off_overage: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  amount: String,
+                  currency: String,
+                  write_off_overage: T.nilable(T::Boolean)
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+
+          # The pricing model type
+          module ModelType
+            extend Orb::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Orb::PlanCreateParams::Price::LicenseAllocationPrice::ModelType
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            UNIT =
+              T.let(
+                :unit,
+                Orb::PlanCreateParams::Price::LicenseAllocationPrice::ModelType::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Orb::PlanCreateParams::Price::LicenseAllocationPrice::ModelType::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
         # New plan price request body params.
         module Price
           extend Orb::Internal::Type::Union
@@ -311,6 +778,7 @@ module Orb
                 Orb::NewPlanPackageWithAllocationPrice,
                 Orb::NewPlanUnitWithPercentPrice,
                 Orb::NewPlanMatrixWithAllocationPrice,
+                Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts,
                 Orb::PlanCreateParams::Price::Price::TieredWithProration,
                 Orb::NewPlanUnitWithProrationPrice,
                 Orb::NewPlanGroupedAllocationPrice,
@@ -325,6 +793,8 @@ module Orb
                 Orb::NewPlanScalableMatrixWithTieredPricingPrice,
                 Orb::NewPlanCumulativeGroupedBulkPrice,
                 Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation,
+                Orb::PlanCreateParams::Price::Price::DailyCreditAllowance,
+                Orb::PlanCreateParams::Price::Price::MeteredAllowance,
                 Orb::NewPlanMinimumCompositePrice,
                 Orb::PlanCreateParams::Price::Price::Percent,
                 Orb::PlanCreateParams::Price::Price::EventOutput
@@ -803,11 +1273,11 @@ module Orb
             end
           end
 
-          class TieredWithProration < Orb::Internal::Type::BaseModel
+          class MatrixWithThresholdDiscounts < Orb::Internal::Type::BaseModel
             OrHash =
               T.type_alias do
                 T.any(
-                  Orb::PlanCreateParams::Price::Price::TieredWithProration,
+                  Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts,
                   Orb::Internal::AnyHash
                 )
               end
@@ -815,7 +1285,7 @@ module Orb
             # The cadence to bill for this price on.
             sig do
               returns(
-                Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::OrSymbol
+                Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::Cadence::OrSymbol
               )
             end
             attr_accessor :cadence
@@ -824,29 +1294,29 @@ module Orb
             sig { returns(String) }
             attr_accessor :item_id
 
-            # The pricing model type
-            sig { returns(Symbol) }
-            attr_accessor :model_type
-
-            # The name of the price.
-            sig { returns(String) }
-            attr_accessor :name
-
-            # Configuration for tiered_with_proration pricing
+            # Configuration for matrix_with_threshold_discounts pricing
             sig do
               returns(
-                Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig
+                Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig
               )
             end
-            attr_reader :tiered_with_proration_config
+            attr_reader :matrix_with_threshold_discounts_config
 
             sig do
               params(
-                tiered_with_proration_config:
-                  Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig::OrHash
+                matrix_with_threshold_discounts_config:
+                  Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::OrHash
               ).void
             end
-            attr_writer :tiered_with_proration_config
+            attr_writer :matrix_with_threshold_discounts_config
+
+            # The pricing model type
+            sig { returns(Symbol) }
+            attr_accessor :model_type
+
+            # The name of the price.
+            sig { returns(String) }
+            attr_accessor :name
 
             # The id of the billable metric for the price. Only needed if the price is
             # usage-based.
@@ -949,11 +1419,11 @@ module Orb
             sig do
               params(
                 cadence:
-                  Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::OrSymbol,
+                  Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::Cadence::OrSymbol,
                 item_id: String,
+                matrix_with_threshold_discounts_config:
+                  Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::OrHash,
                 name: String,
-                tiered_with_proration_config:
-                  Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig::OrHash,
                 billable_metric_id: T.nilable(String),
                 billed_in_advance: T.nilable(T::Boolean),
                 billing_cycle_configuration:
@@ -985,10 +1455,10 @@ module Orb
               cadence:,
               # The id of the item the price will be associated with.
               item_id:,
+              # Configuration for matrix_with_threshold_discounts pricing
+              matrix_with_threshold_discounts_config:,
               # The name of the price.
               name:,
-              # Configuration for tiered_with_proration pricing
-              tiered_with_proration_config:,
               # The id of the billable metric for the price. Only needed if the price is
               # usage-based.
               billable_metric_id: nil,
@@ -1027,7 +1497,7 @@ module Orb
               # in the same API call.
               reference_id: nil,
               # The pricing model type
-              model_type: :tiered_with_proration
+              model_type: :matrix_with_threshold_discounts
             )
             end
 
@@ -1035,12 +1505,12 @@ module Orb
               override.returns(
                 {
                   cadence:
-                    Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::OrSymbol,
+                    Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::Cadence::OrSymbol,
                   item_id: String,
+                  matrix_with_threshold_discounts_config:
+                    Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig,
                   model_type: Symbol,
                   name: String,
-                  tiered_with_proration_config:
-                    Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig,
                   billable_metric_id: T.nilable(String),
                   billed_in_advance: T.nilable(T::Boolean),
                   billing_cycle_configuration:
@@ -1078,7 +1548,7 @@ module Orb
                 T.type_alias do
                   T.all(
                     Symbol,
-                    Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence
+                    Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::Cadence
                   )
                 end
               OrSymbol = T.type_alias { T.any(Symbol, String) }
@@ -1086,38 +1556,38 @@ module Orb
               ANNUAL =
                 T.let(
                   :annual,
-                  Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::Cadence::TaggedSymbol
                 )
               SEMI_ANNUAL =
                 T.let(
                   :semi_annual,
-                  Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::Cadence::TaggedSymbol
                 )
               MONTHLY =
                 T.let(
                   :monthly,
-                  Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::Cadence::TaggedSymbol
                 )
               QUARTERLY =
                 T.let(
                   :quarterly,
-                  Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::Cadence::TaggedSymbol
                 )
               ONE_TIME =
                 T.let(
                   :one_time,
-                  Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::Cadence::TaggedSymbol
                 )
               CUSTOM =
                 T.let(
                   :custom,
-                  Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::Cadence::TaggedSymbol
                 )
 
               sig do
                 override.returns(
                   T::Array[
-                    Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::TaggedSymbol
+                    Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::Cadence::TaggedSymbol
                   ]
                 )
               end
@@ -1125,102 +1595,1407 @@ module Orb
               end
             end
 
-            class TieredWithProrationConfig < Orb::Internal::Type::BaseModel
+            class MatrixWithThresholdDiscountsConfig < Orb::Internal::Type::BaseModel
               OrHash =
                 T.type_alias do
                   T.any(
-                    Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig,
+                    Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig,
                     Orb::Internal::AnyHash
                   )
                 end
 
-              # Tiers for rating based on total usage quantities into the specified tier with
-              # proration
+              # Unit price used for usage that does not match any defined matrix cell.
+              sig { returns(String) }
+              attr_accessor :default_unit_amount
+
+              # First matrix dimension key.
+              sig { returns(String) }
+              attr_accessor :first_dimension
+
+              # Per-cell unit prices.
               sig do
                 returns(
                   T::Array[
-                    Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig::Tier
+                    Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::MatrixValue
                   ]
                 )
               end
-              attr_accessor :tiers
+              attr_accessor :matrix_values
+
+              # Optional second matrix dimension key.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :second_dimension
 
-              # Configuration for tiered_with_proration pricing
               sig do
-                params(
-                  tiers:
-                    T::Array[
-                      Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig::Tier::OrHash
+                returns(
+                  T.nilable(
+                    T::Array[
+                      Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::ThresholdDiscountGroup
+                    ]
+                  )
+                )
+              end
+              attr_reader :threshold_discount_groups
+
+              sig do
+                params(
+                  threshold_discount_groups:
+                    T::Array[
+                      Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::ThresholdDiscountGroup::OrHash
+                    ]
+                ).void
+              end
+              attr_writer :threshold_discount_groups
+
+              # Configuration for matrix_with_threshold_discounts pricing
+              sig do
+                params(
+                  default_unit_amount: String,
+                  first_dimension: String,
+                  matrix_values:
+                    T::Array[
+                      Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::MatrixValue::OrHash
+                    ],
+                  second_dimension: T.nilable(String),
+                  threshold_discount_groups:
+                    T::Array[
+                      Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::ThresholdDiscountGroup::OrHash
                     ]
                 ).returns(T.attached_class)
               end
               def self.new(
-                # Tiers for rating based on total usage quantities into the specified tier with
-                # proration
-                tiers:
+                # Unit price used for usage that does not match any defined matrix cell.
+                default_unit_amount:,
+                # First matrix dimension key.
+                first_dimension:,
+                # Per-cell unit prices.
+                matrix_values:,
+                # Optional second matrix dimension key.
+                second_dimension: nil,
+                threshold_discount_groups: nil
+              )
+              end
+
+              sig do
+                override.returns(
+                  {
+                    default_unit_amount: String,
+                    first_dimension: String,
+                    matrix_values:
+                      T::Array[
+                        Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::MatrixValue
+                      ],
+                    second_dimension: T.nilable(String),
+                    threshold_discount_groups:
+                      T::Array[
+                        Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::ThresholdDiscountGroup
+                      ]
+                  }
+                )
+              end
+              def to_hash
+              end
+
+              class MatrixValue < Orb::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::MatrixValue,
+                      Orb::Internal::AnyHash
+                    )
+                  end
+
+                sig { returns(String) }
+                attr_accessor :first_dimension_value
+
+                sig { returns(String) }
+                attr_accessor :unit_amount
+
+                sig { returns(T.nilable(String)) }
+                attr_accessor :second_dimension_value
+
+                sig do
+                  params(
+                    first_dimension_value: String,
+                    unit_amount: String,
+                    second_dimension_value: T.nilable(String)
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  first_dimension_value:,
+                  unit_amount:,
+                  second_dimension_value: nil
+                )
+                end
+
+                sig do
+                  override.returns(
+                    {
+                      first_dimension_value: String,
+                      unit_amount: String,
+                      second_dimension_value: T.nilable(String)
+                    }
+                  )
+                end
+                def to_hash
+                end
+              end
+
+              class ThresholdDiscountGroup < Orb::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Orb::PlanCreateParams::Price::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::ThresholdDiscountGroup,
+                      Orb::Internal::AnyHash
+                    )
+                  end
+
+                # Discount rate applied to spend above the threshold.
+                sig { returns(String) }
+                attr_accessor :above_threshold_discount_percentage
+
+                # Discount rate applied to spend at or below the threshold. Set to 0 for no
+                # baseline discount.
+                sig { returns(String) }
+                attr_accessor :below_threshold_discount_percentage
+
+                # Semicolon-separated list of matrix cell coordinates targeted by this group. Each
+                # coordinate is `first,second` when the matrix has two dimensions, or just `first`
+                # for a single-dimension matrix. Example: `blue,circle;green,triangle`.
+                sig { returns(String) }
+                attr_accessor :cell_coordinates
+
+                sig { returns(String) }
+                attr_accessor :threshold_amount
+
+                sig { returns(T.nilable(String)) }
+                attr_accessor :description
+
+                sig do
+                  params(
+                    above_threshold_discount_percentage: String,
+                    below_threshold_discount_percentage: String,
+                    cell_coordinates: String,
+                    threshold_amount: String,
+                    description: T.nilable(String)
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  # Discount rate applied to spend above the threshold.
+                  above_threshold_discount_percentage:,
+                  # Discount rate applied to spend at or below the threshold. Set to 0 for no
+                  # baseline discount.
+                  below_threshold_discount_percentage:,
+                  # Semicolon-separated list of matrix cell coordinates targeted by this group. Each
+                  # coordinate is `first,second` when the matrix has two dimensions, or just `first`
+                  # for a single-dimension matrix. Example: `blue,circle;green,triangle`.
+                  cell_coordinates:,
+                  threshold_amount:,
+                  description: nil
+                )
+                end
+
+                sig do
+                  override.returns(
+                    {
+                      above_threshold_discount_percentage: String,
+                      below_threshold_discount_percentage: String,
+                      cell_coordinates: String,
+                      threshold_amount: String,
+                      description: T.nilable(String)
+                    }
+                  )
+                end
+                def to_hash
+                end
+              end
+            end
+          end
+
+          class TieredWithProration < Orb::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Orb::PlanCreateParams::Price::Price::TieredWithProration,
+                  Orb::Internal::AnyHash
+                )
+              end
+
+            # The cadence to bill for this price on.
+            sig do
+              returns(
+                Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::OrSymbol
+              )
+            end
+            attr_accessor :cadence
+
+            # The id of the item the price will be associated with.
+            sig { returns(String) }
+            attr_accessor :item_id
+
+            # The pricing model type
+            sig { returns(Symbol) }
+            attr_accessor :model_type
+
+            # The name of the price.
+            sig { returns(String) }
+            attr_accessor :name
+
+            # Configuration for tiered_with_proration pricing
+            sig do
+              returns(
+                Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig
+              )
+            end
+            attr_reader :tiered_with_proration_config
+
+            sig do
+              params(
+                tiered_with_proration_config:
+                  Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig::OrHash
+              ).void
+            end
+            attr_writer :tiered_with_proration_config
+
+            # The id of the billable metric for the price. Only needed if the price is
+            # usage-based.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :billable_metric_id
+
+            # If the Price represents a fixed cost, the price will be billed in-advance if
+            # this is true, and in-arrears if this is false.
+            sig { returns(T.nilable(T::Boolean)) }
+            attr_accessor :billed_in_advance
+
+            # For custom cadence: specifies the duration of the billing period in days or
+            # months.
+            sig { returns(T.nilable(Orb::NewBillingCycleConfiguration)) }
+            attr_reader :billing_cycle_configuration
+
+            sig do
+              params(
+                billing_cycle_configuration:
+                  T.nilable(Orb::NewBillingCycleConfiguration::OrHash)
+              ).void
+            end
+            attr_writer :billing_cycle_configuration
+
+            # The per unit conversion rate of the price currency to the invoicing currency.
+            sig { returns(T.nilable(Float)) }
+            attr_accessor :conversion_rate
+
+            # The configuration for the rate of the price currency to the invoicing currency.
+            sig do
+              returns(
+                T.nilable(
+                  T.any(
+                    Orb::UnitConversionRateConfig,
+                    Orb::TieredConversionRateConfig
+                  )
+                )
+              )
+            end
+            attr_accessor :conversion_rate_config
+
+            # An ISO 4217 currency string, or custom pricing unit identifier, in which this
+            # price is billed.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :currency
+
+            # For dimensional price: specifies a price group and dimension values
+            sig { returns(T.nilable(Orb::NewDimensionalPriceConfiguration)) }
+            attr_reader :dimensional_price_configuration
+
+            sig do
+              params(
+                dimensional_price_configuration:
+                  T.nilable(Orb::NewDimensionalPriceConfiguration::OrHash)
+              ).void
+            end
+            attr_writer :dimensional_price_configuration
+
+            # An alias for the price.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :external_price_id
+
+            # If the Price represents a fixed cost, this represents the quantity of units
+            # applied.
+            sig { returns(T.nilable(Float)) }
+            attr_accessor :fixed_price_quantity
+
+            # The property used to group this price on an invoice
+            sig { returns(T.nilable(String)) }
+            attr_accessor :invoice_grouping_key
+
+            # Within each billing cycle, specifies the cadence at which invoices are produced.
+            # If unspecified, a single invoice is produced per billing cycle.
+            sig { returns(T.nilable(Orb::NewBillingCycleConfiguration)) }
+            attr_reader :invoicing_cycle_configuration
+
+            sig do
+              params(
+                invoicing_cycle_configuration:
+                  T.nilable(Orb::NewBillingCycleConfiguration::OrHash)
+              ).void
+            end
+            attr_writer :invoicing_cycle_configuration
+
+            # The ID of the license type to associate with this price.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :license_type_id
+
+            # User-specified key/value pairs for the resource. Individual keys can be removed
+            # by setting the value to `null`, and the entire metadata mapping can be cleared
+            # by setting `metadata` to `null`.
+            sig { returns(T.nilable(T::Hash[Symbol, T.nilable(String)])) }
+            attr_accessor :metadata
+
+            # A transient ID that can be used to reference this price when adding adjustments
+            # in the same API call.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :reference_id
+
+            sig do
+              params(
+                cadence:
+                  Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::OrSymbol,
+                item_id: String,
+                name: String,
+                tiered_with_proration_config:
+                  Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig::OrHash,
+                billable_metric_id: T.nilable(String),
+                billed_in_advance: T.nilable(T::Boolean),
+                billing_cycle_configuration:
+                  T.nilable(Orb::NewBillingCycleConfiguration::OrHash),
+                conversion_rate: T.nilable(Float),
+                conversion_rate_config:
+                  T.nilable(
+                    T.any(
+                      Orb::UnitConversionRateConfig::OrHash,
+                      Orb::TieredConversionRateConfig::OrHash
+                    )
+                  ),
+                currency: T.nilable(String),
+                dimensional_price_configuration:
+                  T.nilable(Orb::NewDimensionalPriceConfiguration::OrHash),
+                external_price_id: T.nilable(String),
+                fixed_price_quantity: T.nilable(Float),
+                invoice_grouping_key: T.nilable(String),
+                invoicing_cycle_configuration:
+                  T.nilable(Orb::NewBillingCycleConfiguration::OrHash),
+                license_type_id: T.nilable(String),
+                metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+                reference_id: T.nilable(String),
+                model_type: Symbol
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # The cadence to bill for this price on.
+              cadence:,
+              # The id of the item the price will be associated with.
+              item_id:,
+              # The name of the price.
+              name:,
+              # Configuration for tiered_with_proration pricing
+              tiered_with_proration_config:,
+              # The id of the billable metric for the price. Only needed if the price is
+              # usage-based.
+              billable_metric_id: nil,
+              # If the Price represents a fixed cost, the price will be billed in-advance if
+              # this is true, and in-arrears if this is false.
+              billed_in_advance: nil,
+              # For custom cadence: specifies the duration of the billing period in days or
+              # months.
+              billing_cycle_configuration: nil,
+              # The per unit conversion rate of the price currency to the invoicing currency.
+              conversion_rate: nil,
+              # The configuration for the rate of the price currency to the invoicing currency.
+              conversion_rate_config: nil,
+              # An ISO 4217 currency string, or custom pricing unit identifier, in which this
+              # price is billed.
+              currency: nil,
+              # For dimensional price: specifies a price group and dimension values
+              dimensional_price_configuration: nil,
+              # An alias for the price.
+              external_price_id: nil,
+              # If the Price represents a fixed cost, this represents the quantity of units
+              # applied.
+              fixed_price_quantity: nil,
+              # The property used to group this price on an invoice
+              invoice_grouping_key: nil,
+              # Within each billing cycle, specifies the cadence at which invoices are produced.
+              # If unspecified, a single invoice is produced per billing cycle.
+              invoicing_cycle_configuration: nil,
+              # The ID of the license type to associate with this price.
+              license_type_id: nil,
+              # User-specified key/value pairs for the resource. Individual keys can be removed
+              # by setting the value to `null`, and the entire metadata mapping can be cleared
+              # by setting `metadata` to `null`.
+              metadata: nil,
+              # A transient ID that can be used to reference this price when adding adjustments
+              # in the same API call.
+              reference_id: nil,
+              # The pricing model type
+              model_type: :tiered_with_proration
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  cadence:
+                    Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::OrSymbol,
+                  item_id: String,
+                  model_type: Symbol,
+                  name: String,
+                  tiered_with_proration_config:
+                    Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig,
+                  billable_metric_id: T.nilable(String),
+                  billed_in_advance: T.nilable(T::Boolean),
+                  billing_cycle_configuration:
+                    T.nilable(Orb::NewBillingCycleConfiguration),
+                  conversion_rate: T.nilable(Float),
+                  conversion_rate_config:
+                    T.nilable(
+                      T.any(
+                        Orb::UnitConversionRateConfig,
+                        Orb::TieredConversionRateConfig
+                      )
+                    ),
+                  currency: T.nilable(String),
+                  dimensional_price_configuration:
+                    T.nilable(Orb::NewDimensionalPriceConfiguration),
+                  external_price_id: T.nilable(String),
+                  fixed_price_quantity: T.nilable(Float),
+                  invoice_grouping_key: T.nilable(String),
+                  invoicing_cycle_configuration:
+                    T.nilable(Orb::NewBillingCycleConfiguration),
+                  license_type_id: T.nilable(String),
+                  metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+                  reference_id: T.nilable(String)
+                }
+              )
+            end
+            def to_hash
+            end
+
+            # The cadence to bill for this price on.
+            module Cadence
+              extend Orb::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              ANNUAL =
+                T.let(
+                  :annual,
+                  Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::TaggedSymbol
+                )
+              SEMI_ANNUAL =
+                T.let(
+                  :semi_annual,
+                  Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::TaggedSymbol
+                )
+              MONTHLY =
+                T.let(
+                  :monthly,
+                  Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::TaggedSymbol
+                )
+              QUARTERLY =
+                T.let(
+                  :quarterly,
+                  Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::TaggedSymbol
+                )
+              ONE_TIME =
+                T.let(
+                  :one_time,
+                  Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::TaggedSymbol
+                )
+              CUSTOM =
+                T.let(
+                  :custom,
+                  Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Orb::PlanCreateParams::Price::Price::TieredWithProration::Cadence::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+
+            class TieredWithProrationConfig < Orb::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig,
+                    Orb::Internal::AnyHash
+                  )
+                end
+
+              # Tiers for rating based on total usage quantities into the specified tier with
+              # proration
+              sig do
+                returns(
+                  T::Array[
+                    Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig::Tier
+                  ]
+                )
+              end
+              attr_accessor :tiers
+
+              # Configuration for tiered_with_proration pricing
+              sig do
+                params(
+                  tiers:
+                    T::Array[
+                      Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig::Tier::OrHash
+                    ]
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # Tiers for rating based on total usage quantities into the specified tier with
+                # proration
+                tiers:
+              )
+              end
+
+              sig do
+                override.returns(
+                  {
+                    tiers:
+                      T::Array[
+                        Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig::Tier
+                      ]
+                  }
+                )
+              end
+              def to_hash
+              end
+
+              class Tier < Orb::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig::Tier,
+                      Orb::Internal::AnyHash
+                    )
+                  end
+
+                # Inclusive tier starting value
+                sig { returns(String) }
+                attr_accessor :tier_lower_bound
+
+                # Amount per unit
+                sig { returns(String) }
+                attr_accessor :unit_amount
+
+                # Configuration for a single tiered with proration tier
+                sig do
+                  params(tier_lower_bound: String, unit_amount: String).returns(
+                    T.attached_class
+                  )
+                end
+                def self.new(
+                  # Inclusive tier starting value
+                  tier_lower_bound:,
+                  # Amount per unit
+                  unit_amount:
+                )
+                end
+
+                sig do
+                  override.returns(
+                    { tier_lower_bound: String, unit_amount: String }
+                  )
+                end
+                def to_hash
+                end
+              end
+            end
+          end
+
+          class GroupedWithMinMaxThresholds < Orb::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds,
+                  Orb::Internal::AnyHash
+                )
+              end
+
+            # The cadence to bill for this price on.
+            sig do
+              returns(
+                Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::OrSymbol
+              )
+            end
+            attr_accessor :cadence
+
+            # Configuration for grouped_with_min_max_thresholds pricing
+            sig do
+              returns(
+                Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig
+              )
+            end
+            attr_reader :grouped_with_min_max_thresholds_config
+
+            sig do
+              params(
+                grouped_with_min_max_thresholds_config:
+                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig::OrHash
+              ).void
+            end
+            attr_writer :grouped_with_min_max_thresholds_config
+
+            # The id of the item the price will be associated with.
+            sig { returns(String) }
+            attr_accessor :item_id
+
+            # The pricing model type
+            sig { returns(Symbol) }
+            attr_accessor :model_type
+
+            # The name of the price.
+            sig { returns(String) }
+            attr_accessor :name
+
+            # The id of the billable metric for the price. Only needed if the price is
+            # usage-based.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :billable_metric_id
+
+            # If the Price represents a fixed cost, the price will be billed in-advance if
+            # this is true, and in-arrears if this is false.
+            sig { returns(T.nilable(T::Boolean)) }
+            attr_accessor :billed_in_advance
+
+            # For custom cadence: specifies the duration of the billing period in days or
+            # months.
+            sig { returns(T.nilable(Orb::NewBillingCycleConfiguration)) }
+            attr_reader :billing_cycle_configuration
+
+            sig do
+              params(
+                billing_cycle_configuration:
+                  T.nilable(Orb::NewBillingCycleConfiguration::OrHash)
+              ).void
+            end
+            attr_writer :billing_cycle_configuration
+
+            # The per unit conversion rate of the price currency to the invoicing currency.
+            sig { returns(T.nilable(Float)) }
+            attr_accessor :conversion_rate
+
+            # The configuration for the rate of the price currency to the invoicing currency.
+            sig do
+              returns(
+                T.nilable(
+                  T.any(
+                    Orb::UnitConversionRateConfig,
+                    Orb::TieredConversionRateConfig
+                  )
+                )
+              )
+            end
+            attr_accessor :conversion_rate_config
+
+            # An ISO 4217 currency string, or custom pricing unit identifier, in which this
+            # price is billed.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :currency
+
+            # For dimensional price: specifies a price group and dimension values
+            sig { returns(T.nilable(Orb::NewDimensionalPriceConfiguration)) }
+            attr_reader :dimensional_price_configuration
+
+            sig do
+              params(
+                dimensional_price_configuration:
+                  T.nilable(Orb::NewDimensionalPriceConfiguration::OrHash)
+              ).void
+            end
+            attr_writer :dimensional_price_configuration
+
+            # An alias for the price.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :external_price_id
+
+            # If the Price represents a fixed cost, this represents the quantity of units
+            # applied.
+            sig { returns(T.nilable(Float)) }
+            attr_accessor :fixed_price_quantity
+
+            # The property used to group this price on an invoice
+            sig { returns(T.nilable(String)) }
+            attr_accessor :invoice_grouping_key
+
+            # Within each billing cycle, specifies the cadence at which invoices are produced.
+            # If unspecified, a single invoice is produced per billing cycle.
+            sig { returns(T.nilable(Orb::NewBillingCycleConfiguration)) }
+            attr_reader :invoicing_cycle_configuration
+
+            sig do
+              params(
+                invoicing_cycle_configuration:
+                  T.nilable(Orb::NewBillingCycleConfiguration::OrHash)
+              ).void
+            end
+            attr_writer :invoicing_cycle_configuration
+
+            # The ID of the license type to associate with this price.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :license_type_id
+
+            # User-specified key/value pairs for the resource. Individual keys can be removed
+            # by setting the value to `null`, and the entire metadata mapping can be cleared
+            # by setting `metadata` to `null`.
+            sig { returns(T.nilable(T::Hash[Symbol, T.nilable(String)])) }
+            attr_accessor :metadata
+
+            # A transient ID that can be used to reference this price when adding adjustments
+            # in the same API call.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :reference_id
+
+            sig do
+              params(
+                cadence:
+                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::OrSymbol,
+                grouped_with_min_max_thresholds_config:
+                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig::OrHash,
+                item_id: String,
+                name: String,
+                billable_metric_id: T.nilable(String),
+                billed_in_advance: T.nilable(T::Boolean),
+                billing_cycle_configuration:
+                  T.nilable(Orb::NewBillingCycleConfiguration::OrHash),
+                conversion_rate: T.nilable(Float),
+                conversion_rate_config:
+                  T.nilable(
+                    T.any(
+                      Orb::UnitConversionRateConfig::OrHash,
+                      Orb::TieredConversionRateConfig::OrHash
+                    )
+                  ),
+                currency: T.nilable(String),
+                dimensional_price_configuration:
+                  T.nilable(Orb::NewDimensionalPriceConfiguration::OrHash),
+                external_price_id: T.nilable(String),
+                fixed_price_quantity: T.nilable(Float),
+                invoice_grouping_key: T.nilable(String),
+                invoicing_cycle_configuration:
+                  T.nilable(Orb::NewBillingCycleConfiguration::OrHash),
+                license_type_id: T.nilable(String),
+                metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+                reference_id: T.nilable(String),
+                model_type: Symbol
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # The cadence to bill for this price on.
+              cadence:,
+              # Configuration for grouped_with_min_max_thresholds pricing
+              grouped_with_min_max_thresholds_config:,
+              # The id of the item the price will be associated with.
+              item_id:,
+              # The name of the price.
+              name:,
+              # The id of the billable metric for the price. Only needed if the price is
+              # usage-based.
+              billable_metric_id: nil,
+              # If the Price represents a fixed cost, the price will be billed in-advance if
+              # this is true, and in-arrears if this is false.
+              billed_in_advance: nil,
+              # For custom cadence: specifies the duration of the billing period in days or
+              # months.
+              billing_cycle_configuration: nil,
+              # The per unit conversion rate of the price currency to the invoicing currency.
+              conversion_rate: nil,
+              # The configuration for the rate of the price currency to the invoicing currency.
+              conversion_rate_config: nil,
+              # An ISO 4217 currency string, or custom pricing unit identifier, in which this
+              # price is billed.
+              currency: nil,
+              # For dimensional price: specifies a price group and dimension values
+              dimensional_price_configuration: nil,
+              # An alias for the price.
+              external_price_id: nil,
+              # If the Price represents a fixed cost, this represents the quantity of units
+              # applied.
+              fixed_price_quantity: nil,
+              # The property used to group this price on an invoice
+              invoice_grouping_key: nil,
+              # Within each billing cycle, specifies the cadence at which invoices are produced.
+              # If unspecified, a single invoice is produced per billing cycle.
+              invoicing_cycle_configuration: nil,
+              # The ID of the license type to associate with this price.
+              license_type_id: nil,
+              # User-specified key/value pairs for the resource. Individual keys can be removed
+              # by setting the value to `null`, and the entire metadata mapping can be cleared
+              # by setting `metadata` to `null`.
+              metadata: nil,
+              # A transient ID that can be used to reference this price when adding adjustments
+              # in the same API call.
+              reference_id: nil,
+              # The pricing model type
+              model_type: :grouped_with_min_max_thresholds
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  cadence:
+                    Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::OrSymbol,
+                  grouped_with_min_max_thresholds_config:
+                    Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig,
+                  item_id: String,
+                  model_type: Symbol,
+                  name: String,
+                  billable_metric_id: T.nilable(String),
+                  billed_in_advance: T.nilable(T::Boolean),
+                  billing_cycle_configuration:
+                    T.nilable(Orb::NewBillingCycleConfiguration),
+                  conversion_rate: T.nilable(Float),
+                  conversion_rate_config:
+                    T.nilable(
+                      T.any(
+                        Orb::UnitConversionRateConfig,
+                        Orb::TieredConversionRateConfig
+                      )
+                    ),
+                  currency: T.nilable(String),
+                  dimensional_price_configuration:
+                    T.nilable(Orb::NewDimensionalPriceConfiguration),
+                  external_price_id: T.nilable(String),
+                  fixed_price_quantity: T.nilable(Float),
+                  invoice_grouping_key: T.nilable(String),
+                  invoicing_cycle_configuration:
+                    T.nilable(Orb::NewBillingCycleConfiguration),
+                  license_type_id: T.nilable(String),
+                  metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+                  reference_id: T.nilable(String)
+                }
+              )
+            end
+            def to_hash
+            end
+
+            # The cadence to bill for this price on.
+            module Cadence
+              extend Orb::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              ANNUAL =
+                T.let(
+                  :annual,
+                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                )
+              SEMI_ANNUAL =
+                T.let(
+                  :semi_annual,
+                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                )
+              MONTHLY =
+                T.let(
+                  :monthly,
+                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                )
+              QUARTERLY =
+                T.let(
+                  :quarterly,
+                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                )
+              ONE_TIME =
+                T.let(
+                  :one_time,
+                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                )
+              CUSTOM =
+                T.let(
+                  :custom,
+                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+
+            class GroupedWithMinMaxThresholdsConfig < Orb::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig,
+                    Orb::Internal::AnyHash
+                  )
+                end
+
+              # The event property used to group before applying thresholds
+              sig { returns(String) }
+              attr_accessor :grouping_key
+
+              # The maximum amount to charge each group
+              sig { returns(String) }
+              attr_accessor :maximum_charge
+
+              # The minimum amount to charge each group, regardless of usage
+              sig { returns(String) }
+              attr_accessor :minimum_charge
+
+              # The base price charged per group
+              sig { returns(String) }
+              attr_accessor :per_unit_rate
+
+              # Configuration for grouped_with_min_max_thresholds pricing
+              sig do
+                params(
+                  grouping_key: String,
+                  maximum_charge: String,
+                  minimum_charge: String,
+                  per_unit_rate: String
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # The event property used to group before applying thresholds
+                grouping_key:,
+                # The maximum amount to charge each group
+                maximum_charge:,
+                # The minimum amount to charge each group, regardless of usage
+                minimum_charge:,
+                # The base price charged per group
+                per_unit_rate:
+              )
+              end
+
+              sig do
+                override.returns(
+                  {
+                    grouping_key: String,
+                    maximum_charge: String,
+                    minimum_charge: String,
+                    per_unit_rate: String
+                  }
+                )
+              end
+              def to_hash
+              end
+            end
+          end
+
+          class CumulativeGroupedAllocation < Orb::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation,
+                  Orb::Internal::AnyHash
+                )
+              end
+
+            # The cadence to bill for this price on.
+            sig do
+              returns(
+                Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::OrSymbol
+              )
+            end
+            attr_accessor :cadence
+
+            # Configuration for cumulative_grouped_allocation pricing
+            sig do
+              returns(
+                Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig
+              )
+            end
+            attr_reader :cumulative_grouped_allocation_config
+
+            sig do
+              params(
+                cumulative_grouped_allocation_config:
+                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig::OrHash
+              ).void
+            end
+            attr_writer :cumulative_grouped_allocation_config
+
+            # The id of the item the price will be associated with.
+            sig { returns(String) }
+            attr_accessor :item_id
+
+            # The pricing model type
+            sig { returns(Symbol) }
+            attr_accessor :model_type
+
+            # The name of the price.
+            sig { returns(String) }
+            attr_accessor :name
+
+            # The id of the billable metric for the price. Only needed if the price is
+            # usage-based.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :billable_metric_id
+
+            # If the Price represents a fixed cost, the price will be billed in-advance if
+            # this is true, and in-arrears if this is false.
+            sig { returns(T.nilable(T::Boolean)) }
+            attr_accessor :billed_in_advance
+
+            # For custom cadence: specifies the duration of the billing period in days or
+            # months.
+            sig { returns(T.nilable(Orb::NewBillingCycleConfiguration)) }
+            attr_reader :billing_cycle_configuration
+
+            sig do
+              params(
+                billing_cycle_configuration:
+                  T.nilable(Orb::NewBillingCycleConfiguration::OrHash)
+              ).void
+            end
+            attr_writer :billing_cycle_configuration
+
+            # The per unit conversion rate of the price currency to the invoicing currency.
+            sig { returns(T.nilable(Float)) }
+            attr_accessor :conversion_rate
+
+            # The configuration for the rate of the price currency to the invoicing currency.
+            sig do
+              returns(
+                T.nilable(
+                  T.any(
+                    Orb::UnitConversionRateConfig,
+                    Orb::TieredConversionRateConfig
+                  )
+                )
+              )
+            end
+            attr_accessor :conversion_rate_config
+
+            # An ISO 4217 currency string, or custom pricing unit identifier, in which this
+            # price is billed.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :currency
+
+            # For dimensional price: specifies a price group and dimension values
+            sig { returns(T.nilable(Orb::NewDimensionalPriceConfiguration)) }
+            attr_reader :dimensional_price_configuration
+
+            sig do
+              params(
+                dimensional_price_configuration:
+                  T.nilable(Orb::NewDimensionalPriceConfiguration::OrHash)
+              ).void
+            end
+            attr_writer :dimensional_price_configuration
+
+            # An alias for the price.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :external_price_id
+
+            # If the Price represents a fixed cost, this represents the quantity of units
+            # applied.
+            sig { returns(T.nilable(Float)) }
+            attr_accessor :fixed_price_quantity
+
+            # The property used to group this price on an invoice
+            sig { returns(T.nilable(String)) }
+            attr_accessor :invoice_grouping_key
+
+            # Within each billing cycle, specifies the cadence at which invoices are produced.
+            # If unspecified, a single invoice is produced per billing cycle.
+            sig { returns(T.nilable(Orb::NewBillingCycleConfiguration)) }
+            attr_reader :invoicing_cycle_configuration
+
+            sig do
+              params(
+                invoicing_cycle_configuration:
+                  T.nilable(Orb::NewBillingCycleConfiguration::OrHash)
+              ).void
+            end
+            attr_writer :invoicing_cycle_configuration
+
+            # The ID of the license type to associate with this price.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :license_type_id
+
+            # User-specified key/value pairs for the resource. Individual keys can be removed
+            # by setting the value to `null`, and the entire metadata mapping can be cleared
+            # by setting `metadata` to `null`.
+            sig { returns(T.nilable(T::Hash[Symbol, T.nilable(String)])) }
+            attr_accessor :metadata
+
+            # A transient ID that can be used to reference this price when adding adjustments
+            # in the same API call.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :reference_id
+
+            sig do
+              params(
+                cadence:
+                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::OrSymbol,
+                cumulative_grouped_allocation_config:
+                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig::OrHash,
+                item_id: String,
+                name: String,
+                billable_metric_id: T.nilable(String),
+                billed_in_advance: T.nilable(T::Boolean),
+                billing_cycle_configuration:
+                  T.nilable(Orb::NewBillingCycleConfiguration::OrHash),
+                conversion_rate: T.nilable(Float),
+                conversion_rate_config:
+                  T.nilable(
+                    T.any(
+                      Orb::UnitConversionRateConfig::OrHash,
+                      Orb::TieredConversionRateConfig::OrHash
+                    )
+                  ),
+                currency: T.nilable(String),
+                dimensional_price_configuration:
+                  T.nilable(Orb::NewDimensionalPriceConfiguration::OrHash),
+                external_price_id: T.nilable(String),
+                fixed_price_quantity: T.nilable(Float),
+                invoice_grouping_key: T.nilable(String),
+                invoicing_cycle_configuration:
+                  T.nilable(Orb::NewBillingCycleConfiguration::OrHash),
+                license_type_id: T.nilable(String),
+                metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+                reference_id: T.nilable(String),
+                model_type: Symbol
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # The cadence to bill for this price on.
+              cadence:,
+              # Configuration for cumulative_grouped_allocation pricing
+              cumulative_grouped_allocation_config:,
+              # The id of the item the price will be associated with.
+              item_id:,
+              # The name of the price.
+              name:,
+              # The id of the billable metric for the price. Only needed if the price is
+              # usage-based.
+              billable_metric_id: nil,
+              # If the Price represents a fixed cost, the price will be billed in-advance if
+              # this is true, and in-arrears if this is false.
+              billed_in_advance: nil,
+              # For custom cadence: specifies the duration of the billing period in days or
+              # months.
+              billing_cycle_configuration: nil,
+              # The per unit conversion rate of the price currency to the invoicing currency.
+              conversion_rate: nil,
+              # The configuration for the rate of the price currency to the invoicing currency.
+              conversion_rate_config: nil,
+              # An ISO 4217 currency string, or custom pricing unit identifier, in which this
+              # price is billed.
+              currency: nil,
+              # For dimensional price: specifies a price group and dimension values
+              dimensional_price_configuration: nil,
+              # An alias for the price.
+              external_price_id: nil,
+              # If the Price represents a fixed cost, this represents the quantity of units
+              # applied.
+              fixed_price_quantity: nil,
+              # The property used to group this price on an invoice
+              invoice_grouping_key: nil,
+              # Within each billing cycle, specifies the cadence at which invoices are produced.
+              # If unspecified, a single invoice is produced per billing cycle.
+              invoicing_cycle_configuration: nil,
+              # The ID of the license type to associate with this price.
+              license_type_id: nil,
+              # User-specified key/value pairs for the resource. Individual keys can be removed
+              # by setting the value to `null`, and the entire metadata mapping can be cleared
+              # by setting `metadata` to `null`.
+              metadata: nil,
+              # A transient ID that can be used to reference this price when adding adjustments
+              # in the same API call.
+              reference_id: nil,
+              # The pricing model type
+              model_type: :cumulative_grouped_allocation
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  cadence:
+                    Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::OrSymbol,
+                  cumulative_grouped_allocation_config:
+                    Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig,
+                  item_id: String,
+                  model_type: Symbol,
+                  name: String,
+                  billable_metric_id: T.nilable(String),
+                  billed_in_advance: T.nilable(T::Boolean),
+                  billing_cycle_configuration:
+                    T.nilable(Orb::NewBillingCycleConfiguration),
+                  conversion_rate: T.nilable(Float),
+                  conversion_rate_config:
+                    T.nilable(
+                      T.any(
+                        Orb::UnitConversionRateConfig,
+                        Orb::TieredConversionRateConfig
+                      )
+                    ),
+                  currency: T.nilable(String),
+                  dimensional_price_configuration:
+                    T.nilable(Orb::NewDimensionalPriceConfiguration),
+                  external_price_id: T.nilable(String),
+                  fixed_price_quantity: T.nilable(Float),
+                  invoice_grouping_key: T.nilable(String),
+                  invoicing_cycle_configuration:
+                    T.nilable(Orb::NewBillingCycleConfiguration),
+                  license_type_id: T.nilable(String),
+                  metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+                  reference_id: T.nilable(String)
+                }
+              )
+            end
+            def to_hash
+            end
+
+            # The cadence to bill for this price on.
+            module Cadence
+              extend Orb::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              ANNUAL =
+                T.let(
+                  :annual,
+                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                )
+              SEMI_ANNUAL =
+                T.let(
+                  :semi_annual,
+                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                )
+              MONTHLY =
+                T.let(
+                  :monthly,
+                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                )
+              QUARTERLY =
+                T.let(
+                  :quarterly,
+                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                )
+              ONE_TIME =
+                T.let(
+                  :one_time,
+                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                )
+              CUSTOM =
+                T.let(
+                  :custom,
+                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+
+            class CumulativeGroupedAllocationConfig < Orb::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig,
+                    Orb::Internal::AnyHash
+                  )
+                end
+
+              # The overall allocation across all groups
+              sig { returns(String) }
+              attr_accessor :cumulative_allocation
+
+              # The allocation per individual group
+              sig { returns(String) }
+              attr_accessor :group_allocation
+
+              # The event property used to group usage before applying allocations
+              sig { returns(String) }
+              attr_accessor :grouping_key
+
+              # The amount to charge for each unit outside of the allocation
+              sig { returns(String) }
+              attr_accessor :unit_amount
+
+              # Configuration for cumulative_grouped_allocation pricing
+              sig do
+                params(
+                  cumulative_allocation: String,
+                  group_allocation: String,
+                  grouping_key: String,
+                  unit_amount: String
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # The overall allocation across all groups
+                cumulative_allocation:,
+                # The allocation per individual group
+                group_allocation:,
+                # The event property used to group usage before applying allocations
+                grouping_key:,
+                # The amount to charge for each unit outside of the allocation
+                unit_amount:
               )
               end
 
               sig do
                 override.returns(
                   {
-                    tiers:
-                      T::Array[
-                        Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig::Tier
-                      ]
+                    cumulative_allocation: String,
+                    group_allocation: String,
+                    grouping_key: String,
+                    unit_amount: String
                   }
                 )
               end
               def to_hash
               end
-
-              class Tier < Orb::Internal::Type::BaseModel
-                OrHash =
-                  T.type_alias do
-                    T.any(
-                      Orb::PlanCreateParams::Price::Price::TieredWithProration::TieredWithProrationConfig::Tier,
-                      Orb::Internal::AnyHash
-                    )
-                  end
-
-                # Inclusive tier starting value
-                sig { returns(String) }
-                attr_accessor :tier_lower_bound
-
-                # Amount per unit
-                sig { returns(String) }
-                attr_accessor :unit_amount
-
-                # Configuration for a single tiered with proration tier
-                sig do
-                  params(tier_lower_bound: String, unit_amount: String).returns(
-                    T.attached_class
-                  )
-                end
-                def self.new(
-                  # Inclusive tier starting value
-                  tier_lower_bound:,
-                  # Amount per unit
-                  unit_amount:
-                )
-                end
-
-                sig do
-                  override.returns(
-                    { tier_lower_bound: String, unit_amount: String }
-                  )
-                end
-                def to_hash
-                end
-              end
             end
           end
 
-          class GroupedWithMinMaxThresholds < Orb::Internal::Type::BaseModel
+          class DailyCreditAllowance < Orb::Internal::Type::BaseModel
             OrHash =
               T.type_alias do
                 T.any(
-                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds,
+                  Orb::PlanCreateParams::Price::Price::DailyCreditAllowance,
                   Orb::Internal::AnyHash
                 )
               end
@@ -1228,26 +3003,26 @@ module Orb
             # The cadence to bill for this price on.
             sig do
               returns(
-                Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::OrSymbol
+                Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::Cadence::OrSymbol
               )
             end
             attr_accessor :cadence
 
-            # Configuration for grouped_with_min_max_thresholds pricing
+            # Configuration for daily_credit_allowance pricing
             sig do
               returns(
-                Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig
+                Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::DailyCreditAllowanceConfig
               )
             end
-            attr_reader :grouped_with_min_max_thresholds_config
+            attr_reader :daily_credit_allowance_config
 
             sig do
               params(
-                grouped_with_min_max_thresholds_config:
-                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig::OrHash
+                daily_credit_allowance_config:
+                  Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::DailyCreditAllowanceConfig::OrHash
               ).void
             end
-            attr_writer :grouped_with_min_max_thresholds_config
+            attr_writer :daily_credit_allowance_config
 
             # The id of the item the price will be associated with.
             sig { returns(String) }
@@ -1362,9 +3137,9 @@ module Orb
             sig do
               params(
                 cadence:
-                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::OrSymbol,
-                grouped_with_min_max_thresholds_config:
-                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig::OrHash,
+                  Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::Cadence::OrSymbol,
+                daily_credit_allowance_config:
+                  Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::DailyCreditAllowanceConfig::OrHash,
                 item_id: String,
                 name: String,
                 billable_metric_id: T.nilable(String),
@@ -1396,8 +3171,8 @@ module Orb
             def self.new(
               # The cadence to bill for this price on.
               cadence:,
-              # Configuration for grouped_with_min_max_thresholds pricing
-              grouped_with_min_max_thresholds_config:,
+              # Configuration for daily_credit_allowance pricing
+              daily_credit_allowance_config:,
               # The id of the item the price will be associated with.
               item_id:,
               # The name of the price.
@@ -1440,7 +3215,7 @@ module Orb
               # in the same API call.
               reference_id: nil,
               # The pricing model type
-              model_type: :grouped_with_min_max_thresholds
+              model_type: :daily_credit_allowance
             )
             end
 
@@ -1448,9 +3223,9 @@ module Orb
               override.returns(
                 {
                   cadence:
-                    Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::OrSymbol,
-                  grouped_with_min_max_thresholds_config:
-                    Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig,
+                    Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::Cadence::OrSymbol,
+                  daily_credit_allowance_config:
+                    Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::DailyCreditAllowanceConfig,
                   item_id: String,
                   model_type: Symbol,
                   name: String,
@@ -1491,7 +3266,7 @@ module Orb
                 T.type_alias do
                   T.all(
                     Symbol,
-                    Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence
+                    Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::Cadence
                   )
                 end
               OrSymbol = T.type_alias { T.any(Symbol, String) }
@@ -1499,38 +3274,38 @@ module Orb
               ANNUAL =
                 T.let(
                   :annual,
-                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::Cadence::TaggedSymbol
                 )
               SEMI_ANNUAL =
                 T.let(
                   :semi_annual,
-                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::Cadence::TaggedSymbol
                 )
               MONTHLY =
                 T.let(
                   :monthly,
-                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::Cadence::TaggedSymbol
                 )
               QUARTERLY =
                 T.let(
                   :quarterly,
-                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::Cadence::TaggedSymbol
                 )
               ONE_TIME =
                 T.let(
                   :one_time,
-                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::Cadence::TaggedSymbol
                 )
               CUSTOM =
                 T.let(
                   :custom,
-                  Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::Cadence::TaggedSymbol
                 )
 
               sig do
                 override.returns(
                   T::Array[
-                    Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                    Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::Cadence::TaggedSymbol
                   ]
                 )
               end
@@ -1538,72 +3313,144 @@ module Orb
               end
             end
 
-            class GroupedWithMinMaxThresholdsConfig < Orb::Internal::Type::BaseModel
+            class DailyCreditAllowanceConfig < Orb::Internal::Type::BaseModel
               OrHash =
                 T.type_alias do
                   T.any(
-                    Orb::PlanCreateParams::Price::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig,
+                    Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::DailyCreditAllowanceConfig,
                     Orb::Internal::AnyHash
                   )
                 end
 
-              # The event property used to group before applying thresholds
+              # Credits granted per day. Lose-it-or-use-it; does not roll over.
               sig { returns(String) }
-              attr_accessor :grouping_key
+              attr_accessor :daily_allowance
 
-              # The maximum amount to charge each group
+              # Default per-unit credit rate for any usage not bucketed into a specified
+              # matrix_value
               sig { returns(String) }
-              attr_accessor :maximum_charge
+              attr_accessor :default_unit_amount
 
-              # The minimum amount to charge each group, regardless of usage
-              sig { returns(String) }
-              attr_accessor :minimum_charge
+              # One or two event property values to evaluate matrix groups by
+              sig { returns(T::Array[T.nilable(String)]) }
+              attr_accessor :dimensions
 
-              # The base price charged per group
+              # Event property whose value identifies the day bucket the event belongs to (e.g.
+              # 'event_day' set to an ISO date string in the customer's timezone). The allowance
+              # resets per distinct value of this property.
               sig { returns(String) }
-              attr_accessor :per_unit_rate
+              attr_accessor :event_day_property
 
-              # Configuration for grouped_with_min_max_thresholds pricing
+              # Per-dimension credit rates
+              sig do
+                returns(
+                  T::Array[
+                    Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::DailyCreditAllowanceConfig::MatrixValue
+                  ]
+                )
+              end
+              attr_accessor :matrix_values
+
+              # Configuration for daily_credit_allowance pricing
               sig do
                 params(
-                  grouping_key: String,
-                  maximum_charge: String,
-                  minimum_charge: String,
-                  per_unit_rate: String
+                  daily_allowance: String,
+                  default_unit_amount: String,
+                  dimensions: T::Array[T.nilable(String)],
+                  event_day_property: String,
+                  matrix_values:
+                    T::Array[
+                      Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::DailyCreditAllowanceConfig::MatrixValue::OrHash
+                    ]
                 ).returns(T.attached_class)
               end
               def self.new(
-                # The event property used to group before applying thresholds
-                grouping_key:,
-                # The maximum amount to charge each group
-                maximum_charge:,
-                # The minimum amount to charge each group, regardless of usage
-                minimum_charge:,
-                # The base price charged per group
-                per_unit_rate:
+                # Credits granted per day. Lose-it-or-use-it; does not roll over.
+                daily_allowance:,
+                # Default per-unit credit rate for any usage not bucketed into a specified
+                # matrix_value
+                default_unit_amount:,
+                # One or two event property values to evaluate matrix groups by
+                dimensions:,
+                # Event property whose value identifies the day bucket the event belongs to (e.g.
+                # 'event_day' set to an ISO date string in the customer's timezone). The allowance
+                # resets per distinct value of this property.
+                event_day_property:,
+                # Per-dimension credit rates
+                matrix_values:
               )
               end
 
               sig do
                 override.returns(
                   {
-                    grouping_key: String,
-                    maximum_charge: String,
-                    minimum_charge: String,
-                    per_unit_rate: String
+                    daily_allowance: String,
+                    default_unit_amount: String,
+                    dimensions: T::Array[T.nilable(String)],
+                    event_day_property: String,
+                    matrix_values:
+                      T::Array[
+                        Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::DailyCreditAllowanceConfig::MatrixValue
+                      ]
                   }
                 )
               end
               def to_hash
               end
+
+              class MatrixValue < Orb::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Orb::PlanCreateParams::Price::Price::DailyCreditAllowance::DailyCreditAllowanceConfig::MatrixValue,
+                      Orb::Internal::AnyHash
+                    )
+                  end
+
+                # One or two matrix keys to filter usage to this value by. For example, ["model"]
+                # could be used to apply a different credit rate to each AI model.
+                sig { returns(T::Array[T.nilable(String)]) }
+                attr_accessor :dimension_values
+
+                # Credits charged per unit of usage matching the specified dimension_values
+                sig { returns(String) }
+                attr_accessor :unit_amount
+
+                # Per-dimension credit price for the daily credit allowance model.
+                sig do
+                  params(
+                    dimension_values: T::Array[T.nilable(String)],
+                    unit_amount: String
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  # One or two matrix keys to filter usage to this value by. For example, ["model"]
+                  # could be used to apply a different credit rate to each AI model.
+                  dimension_values:,
+                  # Credits charged per unit of usage matching the specified dimension_values
+                  unit_amount:
+                )
+                end
+
+                sig do
+                  override.returns(
+                    {
+                      dimension_values: T::Array[T.nilable(String)],
+                      unit_amount: String
+                    }
+                  )
+                end
+                def to_hash
+                end
+              end
             end
           end
 
-          class CumulativeGroupedAllocation < Orb::Internal::Type::BaseModel
+          class MeteredAllowance < Orb::Internal::Type::BaseModel
             OrHash =
               T.type_alias do
                 T.any(
-                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation,
+                  Orb::PlanCreateParams::Price::Price::MeteredAllowance,
                   Orb::Internal::AnyHash
                 )
               end
@@ -1611,30 +3458,30 @@ module Orb
             # The cadence to bill for this price on.
             sig do
               returns(
-                Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::OrSymbol
+                Orb::PlanCreateParams::Price::Price::MeteredAllowance::Cadence::OrSymbol
               )
             end
             attr_accessor :cadence
 
-            # Configuration for cumulative_grouped_allocation pricing
+            # The id of the item the price will be associated with.
+            sig { returns(String) }
+            attr_accessor :item_id
+
+            # Configuration for metered_allowance pricing
             sig do
               returns(
-                Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig
+                Orb::PlanCreateParams::Price::Price::MeteredAllowance::MeteredAllowanceConfig
               )
             end
-            attr_reader :cumulative_grouped_allocation_config
+            attr_reader :metered_allowance_config
 
             sig do
               params(
-                cumulative_grouped_allocation_config:
-                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig::OrHash
+                metered_allowance_config:
+                  Orb::PlanCreateParams::Price::Price::MeteredAllowance::MeteredAllowanceConfig::OrHash
               ).void
             end
-            attr_writer :cumulative_grouped_allocation_config
-
-            # The id of the item the price will be associated with.
-            sig { returns(String) }
-            attr_accessor :item_id
+            attr_writer :metered_allowance_config
 
             # The pricing model type
             sig { returns(Symbol) }
@@ -1745,10 +3592,10 @@ module Orb
             sig do
               params(
                 cadence:
-                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::OrSymbol,
-                cumulative_grouped_allocation_config:
-                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig::OrHash,
+                  Orb::PlanCreateParams::Price::Price::MeteredAllowance::Cadence::OrSymbol,
                 item_id: String,
+                metered_allowance_config:
+                  Orb::PlanCreateParams::Price::Price::MeteredAllowance::MeteredAllowanceConfig::OrHash,
                 name: String,
                 billable_metric_id: T.nilable(String),
                 billed_in_advance: T.nilable(T::Boolean),
@@ -1779,10 +3626,10 @@ module Orb
             def self.new(
               # The cadence to bill for this price on.
               cadence:,
-              # Configuration for cumulative_grouped_allocation pricing
-              cumulative_grouped_allocation_config:,
               # The id of the item the price will be associated with.
               item_id:,
+              # Configuration for metered_allowance pricing
+              metered_allowance_config:,
               # The name of the price.
               name:,
               # The id of the billable metric for the price. Only needed if the price is
@@ -1823,7 +3670,7 @@ module Orb
               # in the same API call.
               reference_id: nil,
               # The pricing model type
-              model_type: :cumulative_grouped_allocation
+              model_type: :metered_allowance
             )
             end
 
@@ -1831,10 +3678,10 @@ module Orb
               override.returns(
                 {
                   cadence:
-                    Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::OrSymbol,
-                  cumulative_grouped_allocation_config:
-                    Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig,
+                    Orb::PlanCreateParams::Price::Price::MeteredAllowance::Cadence::OrSymbol,
                   item_id: String,
+                  metered_allowance_config:
+                    Orb::PlanCreateParams::Price::Price::MeteredAllowance::MeteredAllowanceConfig,
                   model_type: Symbol,
                   name: String,
                   billable_metric_id: T.nilable(String),
@@ -1874,7 +3721,7 @@ module Orb
                 T.type_alias do
                   T.all(
                     Symbol,
-                    Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence
+                    Orb::PlanCreateParams::Price::Price::MeteredAllowance::Cadence
                   )
                 end
               OrSymbol = T.type_alias { T.any(Symbol, String) }
@@ -1882,38 +3729,38 @@ module Orb
               ANNUAL =
                 T.let(
                   :annual,
-                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::MeteredAllowance::Cadence::TaggedSymbol
                 )
               SEMI_ANNUAL =
                 T.let(
                   :semi_annual,
-                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::MeteredAllowance::Cadence::TaggedSymbol
                 )
               MONTHLY =
                 T.let(
                   :monthly,
-                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::MeteredAllowance::Cadence::TaggedSymbol
                 )
               QUARTERLY =
                 T.let(
                   :quarterly,
-                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::MeteredAllowance::Cadence::TaggedSymbol
                 )
               ONE_TIME =
                 T.let(
                   :one_time,
-                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::MeteredAllowance::Cadence::TaggedSymbol
                 )
               CUSTOM =
                 T.let(
                   :custom,
-                  Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                  Orb::PlanCreateParams::Price::Price::MeteredAllowance::Cadence::TaggedSymbol
                 )
 
               sig do
                 override.returns(
                   T::Array[
-                    Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                    Orb::PlanCreateParams::Price::Price::MeteredAllowance::Cadence::TaggedSymbol
                   ]
                 )
               end
@@ -1921,59 +3768,91 @@ module Orb
               end
             end
 
-            class CumulativeGroupedAllocationConfig < Orb::Internal::Type::BaseModel
+            class MeteredAllowanceConfig < Orb::Internal::Type::BaseModel
               OrHash =
                 T.type_alias do
                   T.any(
-                    Orb::PlanCreateParams::Price::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig,
+                    Orb::PlanCreateParams::Price::Price::MeteredAllowance::MeteredAllowanceConfig,
                     Orb::Internal::AnyHash
                   )
                 end
 
-              # The overall allocation across all groups
+              # The grouping_key value whose summed quantity represents the allowance for this
+              # period (e.g. 'storage_snapshot' emitting 3 × avg storage). Capped at consumption
+              # — credit can never exceed actual usage.
               sig { returns(String) }
-              attr_accessor :cumulative_allocation
+              attr_accessor :allowance_grouping_value
 
-              # The allocation per individual group
+              # The grouping_key value whose summed quantity represents consumption (e.g.
+              # 'download'). Charged at unit_amount.
               sig { returns(String) }
-              attr_accessor :group_allocation
+              attr_accessor :consumption_grouping_value
 
-              # The event property used to group usage before applying allocations
+              # Event property used to partition the metric into consumption and allowance
+              # quantities (e.g. 'event_name'). The metric is queried with this key and the two
+              # values below select which partition is which.
               sig { returns(String) }
               attr_accessor :grouping_key
 
-              # The amount to charge for each unit outside of the allocation
+              # Per-unit price applied to gross consumption and to the allowance credit.
               sig { returns(String) }
               attr_accessor :unit_amount
 
-              # Configuration for cumulative_grouped_allocation pricing
+              # Sub-line label for the credit row (e.g. 'Up to 3x free egress').
+              sig { returns(T.nilable(String)) }
+              attr_reader :allowance_display_name
+
+              sig { params(allowance_display_name: String).void }
+              attr_writer :allowance_display_name
+
+              # Sub-line label for the gross consumption row (e.g. 'bytes gotten').
+              sig { returns(T.nilable(String)) }
+              attr_reader :consumption_display_name
+
+              sig { params(consumption_display_name: String).void }
+              attr_writer :consumption_display_name
+
+              # Configuration for metered_allowance pricing
               sig do
                 params(
-                  cumulative_allocation: String,
-                  group_allocation: String,
+                  allowance_grouping_value: String,
+                  consumption_grouping_value: String,
                   grouping_key: String,
-                  unit_amount: String
+                  unit_amount: String,
+                  allowance_display_name: String,
+                  consumption_display_name: String
                 ).returns(T.attached_class)
               end
               def self.new(
-                # The overall allocation across all groups
-                cumulative_allocation:,
-                # The allocation per individual group
-                group_allocation:,
-                # The event property used to group usage before applying allocations
+                # The grouping_key value whose summed quantity represents the allowance for this
+                # period (e.g. 'storage_snapshot' emitting 3 × avg storage). Capped at consumption
+                # — credit can never exceed actual usage.
+                allowance_grouping_value:,
+                # The grouping_key value whose summed quantity represents consumption (e.g.
+                # 'download'). Charged at unit_amount.
+                consumption_grouping_value:,
+                # Event property used to partition the metric into consumption and allowance
+                # quantities (e.g. 'event_name'). The metric is queried with this key and the two
+                # values below select which partition is which.
                 grouping_key:,
-                # The amount to charge for each unit outside of the allocation
-                unit_amount:
+                # Per-unit price applied to gross consumption and to the allowance credit.
+                unit_amount:,
+                # Sub-line label for the credit row (e.g. 'Up to 3x free egress').
+                allowance_display_name: nil,
+                # Sub-line label for the gross consumption row (e.g. 'bytes gotten').
+                consumption_display_name: nil
               )
               end
 
               sig do
                 override.returns(
                   {
-                    cumulative_allocation: String,
-                    group_allocation: String,
+                    allowance_grouping_value: String,
+                    consumption_grouping_value: String,
                     grouping_key: String,
-                    unit_amount: String
+                    unit_amount: String,
+                    allowance_display_name: String,
+                    consumption_display_name: String
                   }
                 )
               end
@@ -2313,19 +4192,60 @@ module Orb
                   )
                 end
 
-              # What percent of the component subtotals to charge
-              sig { returns(Float) }
-              attr_accessor :percent
+              # Fraction of the component subtotals to charge (0 < percent <= 1).
+              sig { returns(Float) }
+              attr_accessor :percent
+
+              # Maximum amount to charge. If unset, the fee has no upper bound.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :maximum_amount
+
+              # Minimum amount to charge. If unset, the fee is bounded below by 0.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :minimum_amount
+
+              # If true, the minimum_amount is prorated based on the service period. The
+              # maximum_amount is an absolute cap (never prorated), and the percent applied to
+              # upstream subtotals is never prorated either.
+              sig { returns(T.nilable(T::Boolean)) }
+              attr_reader :prorated
+
+              sig { params(prorated: T::Boolean).void }
+              attr_writer :prorated
 
               # Configuration for percent pricing
-              sig { params(percent: Float).returns(T.attached_class) }
+              sig do
+                params(
+                  percent: Float,
+                  maximum_amount: T.nilable(String),
+                  minimum_amount: T.nilable(String),
+                  prorated: T::Boolean
+                ).returns(T.attached_class)
+              end
               def self.new(
-                # What percent of the component subtotals to charge
-                percent:
+                # Fraction of the component subtotals to charge (0 < percent <= 1).
+                percent:,
+                # Maximum amount to charge. If unset, the fee has no upper bound.
+                maximum_amount: nil,
+                # Minimum amount to charge. If unset, the fee is bounded below by 0.
+                minimum_amount: nil,
+                # If true, the minimum_amount is prorated based on the service period. The
+                # maximum_amount is an absolute cap (never prorated), and the percent applied to
+                # upstream subtotals is never prorated either.
+                prorated: nil
               )
               end
 
-              sig { override.returns({ percent: Float }) }
+              sig do
+                override.returns(
+                  {
+                    percent: Float,
+                    maximum_amount: T.nilable(String),
+                    minimum_amount: T.nilable(String),
+                    prorated: T::Boolean
+                  }
+                )
+              end
               def to_hash
               end
             end
@@ -2736,7 +4656,8 @@ module Orb
               Orb::NewUsageDiscount,
               Orb::NewAmountDiscount,
               Orb::NewMinimum,
-              Orb::NewMaximum
+              Orb::NewMaximum,
+              Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount
             )
           )
         end
@@ -2754,7 +4675,8 @@ module Orb
                 Orb::NewUsageDiscount::OrHash,
                 Orb::NewAmountDiscount::OrHash,
                 Orb::NewMinimum::OrHash,
-                Orb::NewMaximum::OrHash
+                Orb::NewMaximum::OrHash,
+                Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::OrHash
               ),
             plan_phase_order: T.nilable(Integer)
           ).returns(T.attached_class)
@@ -2776,7 +4698,8 @@ module Orb
                   Orb::NewUsageDiscount,
                   Orb::NewAmountDiscount,
                   Orb::NewMinimum,
-                  Orb::NewMaximum
+                  Orb::NewMaximum,
+                  Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount
                 ),
               plan_phase_order: T.nilable(Integer)
             }
@@ -2796,10 +4719,444 @@ module Orb
                 Orb::NewUsageDiscount,
                 Orb::NewAmountDiscount,
                 Orb::NewMinimum,
-                Orb::NewMaximum
+                Orb::NewMaximum,
+                Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount
+              )
+            end
+
+          class TieredPercentageDiscount < Orb::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount,
+                  Orb::Internal::AnyHash
+                )
+              end
+
+            sig { returns(Symbol) }
+            attr_accessor :adjustment_type
+
+            sig do
+              returns(
+                T::Array[
+                  Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Tier
+                ]
+              )
+            end
+            attr_accessor :tiers
+
+            # If set, the adjustment will apply to every price on the subscription.
+            sig do
+              returns(
+                T.nilable(
+                  Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::AppliesToAll::OrBoolean
+                )
+              )
+            end
+            attr_accessor :applies_to_all
+
+            # The set of item IDs to which this adjustment applies.
+            sig { returns(T.nilable(T::Array[String])) }
+            attr_accessor :applies_to_item_ids
+
+            # The set of price IDs to which this adjustment applies.
+            sig { returns(T.nilable(T::Array[String])) }
+            attr_accessor :applies_to_price_ids
+
+            # If set, only prices in the specified currency will have the adjustment applied.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :currency
+
+            # A list of filters that determine which prices this adjustment will apply to.
+            sig do
+              returns(
+                T.nilable(
+                  T::Array[
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter
+                  ]
+                )
+              )
+            end
+            attr_accessor :filters
+
+            # When false, this adjustment will be applied to a single price. Otherwise, it
+            # will be applied at the invoice level, possibly to multiple prices.
+            sig { returns(T.nilable(T::Boolean)) }
+            attr_reader :is_invoice_level
+
+            sig { params(is_invoice_level: T::Boolean).void }
+            attr_writer :is_invoice_level
+
+            # If set, only prices of the specified type will have the adjustment applied.
+            sig do
+              returns(
+                T.nilable(
+                  Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::PriceType::OrSymbol
+                )
+              )
+            end
+            attr_accessor :price_type
+
+            sig do
+              params(
+                tiers:
+                  T::Array[
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Tier::OrHash
+                  ],
+                applies_to_all:
+                  T.nilable(
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::AppliesToAll::OrBoolean
+                  ),
+                applies_to_item_ids: T.nilable(T::Array[String]),
+                applies_to_price_ids: T.nilable(T::Array[String]),
+                currency: T.nilable(String),
+                filters:
+                  T.nilable(
+                    T::Array[
+                      Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::OrHash
+                    ]
+                  ),
+                is_invoice_level: T::Boolean,
+                price_type:
+                  T.nilable(
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::PriceType::OrSymbol
+                  ),
+                adjustment_type: Symbol
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              tiers:,
+              # If set, the adjustment will apply to every price on the subscription.
+              applies_to_all: nil,
+              # The set of item IDs to which this adjustment applies.
+              applies_to_item_ids: nil,
+              # The set of price IDs to which this adjustment applies.
+              applies_to_price_ids: nil,
+              # If set, only prices in the specified currency will have the adjustment applied.
+              currency: nil,
+              # A list of filters that determine which prices this adjustment will apply to.
+              filters: nil,
+              # When false, this adjustment will be applied to a single price. Otherwise, it
+              # will be applied at the invoice level, possibly to multiple prices.
+              is_invoice_level: nil,
+              # If set, only prices of the specified type will have the adjustment applied.
+              price_type: nil,
+              adjustment_type: :tiered_percentage_discount
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  adjustment_type: Symbol,
+                  tiers:
+                    T::Array[
+                      Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Tier
+                    ],
+                  applies_to_all:
+                    T.nilable(
+                      Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::AppliesToAll::OrBoolean
+                    ),
+                  applies_to_item_ids: T.nilable(T::Array[String]),
+                  applies_to_price_ids: T.nilable(T::Array[String]),
+                  currency: T.nilable(String),
+                  filters:
+                    T.nilable(
+                      T::Array[
+                        Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter
+                      ]
+                    ),
+                  is_invoice_level: T::Boolean,
+                  price_type:
+                    T.nilable(
+                      Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::PriceType::OrSymbol
+                    )
+                }
+              )
+            end
+            def to_hash
+            end
+
+            class Tier < Orb::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Tier,
+                    Orb::Internal::AnyHash
+                  )
+                end
+
+              # Exclusive lower bound of cumulative spend for this tier.
+              sig { returns(Float) }
+              attr_accessor :lower_bound
+
+              # The percentage (0-1) discounted from spend in this tier.
+              sig { returns(Float) }
+              attr_accessor :percentage
+
+              # Inclusive upper bound of cumulative spend; null for the final open-ended tier.
+              sig { returns(T.nilable(Float)) }
+              attr_accessor :upper_bound
+
+              sig do
+                params(
+                  lower_bound: Float,
+                  percentage: Float,
+                  upper_bound: T.nilable(Float)
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # Exclusive lower bound of cumulative spend for this tier.
+                lower_bound:,
+                # The percentage (0-1) discounted from spend in this tier.
+                percentage:,
+                # Inclusive upper bound of cumulative spend; null for the final open-ended tier.
+                upper_bound: nil
+              )
+              end
+
+              sig do
+                override.returns(
+                  {
+                    lower_bound: Float,
+                    percentage: Float,
+                    upper_bound: T.nilable(Float)
+                  }
+                )
+              end
+              def to_hash
+              end
+            end
+
+            # If set, the adjustment will apply to every price on the subscription.
+            module AppliesToAll
+              extend Orb::Internal::Type::Enum
+
+              TaggedBoolean =
+                T.type_alias do
+                  T.all(
+                    T::Boolean,
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::AppliesToAll
+                  )
+                end
+              OrBoolean = T.type_alias { T::Boolean }
+
+              TRUE =
+                T.let(
+                  true,
+                  Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::AppliesToAll::TaggedBoolean
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::AppliesToAll::TaggedBoolean
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+
+            class Filter < Orb::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter,
+                    Orb::Internal::AnyHash
+                  )
+                end
+
+              # The property of the price to filter on.
+              sig do
+                returns(
+                  Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::Field::OrSymbol
+                )
+              end
+              attr_accessor :field
+
+              # Should prices that match the filter be included or excluded.
+              sig do
+                returns(
+                  Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::Operator::OrSymbol
+                )
+              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::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::Field::OrSymbol,
+                  operator:
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::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::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::Field::OrSymbol,
+                    operator:
+                      Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::Operator::OrSymbol,
+                    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::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::Field
+                    )
+                  end
+                OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+                PRICE_ID =
+                  T.let(
+                    :price_id,
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::Field::TaggedSymbol
+                  )
+                ITEM_ID =
+                  T.let(
+                    :item_id,
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::Field::TaggedSymbol
+                  )
+                PRICE_TYPE =
+                  T.let(
+                    :price_type,
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::Field::TaggedSymbol
+                  )
+                CURRENCY =
+                  T.let(
+                    :currency,
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::Field::TaggedSymbol
+                  )
+                PRICING_UNIT_ID =
+                  T.let(
+                    :pricing_unit_id,
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::Field::TaggedSymbol
+                  )
+
+                sig do
+                  override.returns(
+                    T::Array[
+                      Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::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::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::Operator
+                    )
+                  end
+                OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+                INCLUDES =
+                  T.let(
+                    :includes,
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::Operator::TaggedSymbol
+                  )
+                EXCLUDES =
+                  T.let(
+                    :excludes,
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::Operator::TaggedSymbol
+                  )
+
+                sig do
+                  override.returns(
+                    T::Array[
+                      Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::Filter::Operator::TaggedSymbol
+                    ]
+                  )
+                end
+                def self.values
+                end
+              end
             end
 
+            # If set, only prices of the specified type will have the adjustment applied.
+            module PriceType
+              extend Orb::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::PriceType
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              USAGE =
+                T.let(
+                  :usage,
+                  Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::PriceType::TaggedSymbol
+                )
+              FIXED_IN_ADVANCE =
+                T.let(
+                  :fixed_in_advance,
+                  Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::PriceType::TaggedSymbol
+                )
+              FIXED_IN_ARREARS =
+                T.let(
+                  :fixed_in_arrears,
+                  Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::PriceType::TaggedSymbol
+                )
+              FIXED =
+                T.let(
+                  :fixed,
+                  Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::PriceType::TaggedSymbol
+                )
+              IN_ARREARS =
+                T.let(
+                  :in_arrears,
+                  Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::PriceType::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Orb::PlanCreateParams::Adjustment::Adjustment::TieredPercentageDiscount::PriceType::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+          end
+
           sig do
             override.returns(
               T::Array[Orb::PlanCreateParams::Adjustment::Adjustment::Variants]