orb-billing 1.13.0 → 1.15.0

data/rbi/orb/models/price_evaluate_multiple_params.rbi

@@ -137,6 +137,7 @@ module Orb
                 Orb::NewFloatingPackageWithAllocationPrice,
                 Orb::NewFloatingUnitWithPercentPrice,
                 Orb::NewFloatingMatrixWithAllocationPrice,
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts,
                 Orb::NewFloatingTieredWithProrationPrice,
                 Orb::NewFloatingUnitWithProrationPrice,
                 Orb::NewFloatingGroupedAllocationPrice,
@@ -151,6 +152,8 @@ module Orb
                 Orb::NewFloatingScalableMatrixWithTieredPricingPrice,
                 Orb::NewFloatingCumulativeGroupedBulkPrice,
                 Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation,
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance,
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance,
                 Orb::NewFloatingMinimumCompositePrice,
                 Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::Percent,
                 Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::EventOutput
@@ -187,6 +190,7 @@ module Orb
                   Orb::NewFloatingPackageWithAllocationPrice::OrHash,
                   Orb::NewFloatingUnitWithPercentPrice::OrHash,
                   Orb::NewFloatingMatrixWithAllocationPrice::OrHash,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::OrHash,
                   Orb::NewFloatingTieredWithProrationPrice::OrHash,
                   Orb::NewFloatingUnitWithProrationPrice::OrHash,
                   Orb::NewFloatingGroupedAllocationPrice::OrHash,
@@ -201,6 +205,8 @@ module Orb
                   Orb::NewFloatingScalableMatrixWithTieredPricingPrice::OrHash,
                   Orb::NewFloatingCumulativeGroupedBulkPrice::OrHash,
                   Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::OrHash,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance::OrHash,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::OrHash,
                   Orb::NewFloatingMinimumCompositePrice::OrHash,
                   Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::Percent::OrHash,
                   Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::EventOutput::OrHash
@@ -255,6 +261,7 @@ module Orb
                     Orb::NewFloatingPackageWithAllocationPrice,
                     Orb::NewFloatingUnitWithPercentPrice,
                     Orb::NewFloatingMatrixWithAllocationPrice,
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts,
                     Orb::NewFloatingTieredWithProrationPrice,
                     Orb::NewFloatingUnitWithProrationPrice,
                     Orb::NewFloatingGroupedAllocationPrice,
@@ -269,6 +276,8 @@ module Orb
                     Orb::NewFloatingScalableMatrixWithTieredPricingPrice,
                     Orb::NewFloatingCumulativeGroupedBulkPrice,
                     Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation,
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance,
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance,
                     Orb::NewFloatingMinimumCompositePrice,
                     Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::Percent,
                     Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::EventOutput
@@ -302,6 +311,7 @@ module Orb
                 Orb::NewFloatingPackageWithAllocationPrice,
                 Orb::NewFloatingUnitWithPercentPrice,
                 Orb::NewFloatingMatrixWithAllocationPrice,
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts,
                 Orb::NewFloatingTieredWithProrationPrice,
                 Orb::NewFloatingUnitWithProrationPrice,
                 Orb::NewFloatingGroupedAllocationPrice,
@@ -316,6 +326,8 @@ module Orb
                 Orb::NewFloatingScalableMatrixWithTieredPricingPrice,
                 Orb::NewFloatingCumulativeGroupedBulkPrice,
                 Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation,
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance,
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance,
                 Orb::NewFloatingMinimumCompositePrice,
                 Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::Percent,
                 Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::EventOutput
@@ -782,11 +794,1280 @@ module Orb
             end
           end
 
+          class MatrixWithThresholdDiscounts < Orb::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts,
+                  Orb::Internal::AnyHash
+                )
+              end
+
+            # The cadence to bill for this price on.
+            sig do
+              returns(
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::Cadence::OrSymbol
+              )
+            end
+            attr_accessor :cadence
+
+            # An ISO 4217 currency string for which this price is billed in.
+            sig { returns(String) }
+            attr_accessor :currency
+
+            # The id of the item the price will be associated with.
+            sig { returns(String) }
+            attr_accessor :item_id
+
+            # Configuration for matrix_with_threshold_discounts pricing
+            sig do
+              returns(
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig
+              )
+            end
+            attr_reader :matrix_with_threshold_discounts_config
+
+            sig do
+              params(
+                matrix_with_threshold_discounts_config:
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::OrHash
+              ).void
+            end
+            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.
+            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
+
+            # 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
+
+            sig do
+              params(
+                cadence:
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::Cadence::OrSymbol,
+                currency: String,
+                item_id: String,
+                matrix_with_threshold_discounts_config:
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::OrHash,
+                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
+                    )
+                  ),
+                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)]),
+                model_type: Symbol
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # The cadence to bill for this price on.
+              cadence:,
+              # An ISO 4217 currency string for which this price is billed in.
+              currency:,
+              # 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:,
+              # 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,
+              # 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,
+              # The pricing model type
+              model_type: :matrix_with_threshold_discounts
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  cadence:
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::Cadence::OrSymbol,
+                  currency: String,
+                  item_id: String,
+                  matrix_with_threshold_discounts_config:
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig,
+                  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
+                      )
+                    ),
+                  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)])
+                }
+              )
+            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::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::Cadence
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              ANNUAL =
+                T.let(
+                  :annual,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::Cadence::TaggedSymbol
+                )
+              SEMI_ANNUAL =
+                T.let(
+                  :semi_annual,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::Cadence::TaggedSymbol
+                )
+              MONTHLY =
+                T.let(
+                  :monthly,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::Cadence::TaggedSymbol
+                )
+              QUARTERLY =
+                T.let(
+                  :quarterly,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::Cadence::TaggedSymbol
+                )
+              ONE_TIME =
+                T.let(
+                  :one_time,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::Cadence::TaggedSymbol
+                )
+              CUSTOM =
+                T.let(
+                  :custom,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::Cadence::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::Cadence::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+
+            class MatrixWithThresholdDiscountsConfig < Orb::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig,
+                    Orb::Internal::AnyHash
+                  )
+                end
+
+              # 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::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::MatrixValue
+                  ]
+                )
+              end
+              attr_accessor :matrix_values
+
+              # Optional second matrix dimension key.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :second_dimension
+
+              sig do
+                returns(
+                  T.nilable(
+                    T::Array[
+                      Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::ThresholdDiscountGroup
+                    ]
+                  )
+                )
+              end
+              attr_reader :threshold_discount_groups
+
+              sig do
+                params(
+                  threshold_discount_groups:
+                    T::Array[
+                      Orb::PriceEvaluateMultipleParams::PriceEvaluation::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::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::MatrixValue::OrHash
+                    ],
+                  second_dimension: T.nilable(String),
+                  threshold_discount_groups:
+                    T::Array[
+                      Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::ThresholdDiscountGroup::OrHash
+                    ]
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # 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::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::MatrixValue
+                      ],
+                    second_dimension: T.nilable(String),
+                    threshold_discount_groups:
+                      T::Array[
+                        Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MatrixWithThresholdDiscounts::MatrixWithThresholdDiscountsConfig::ThresholdDiscountGroup
+                      ]
+                  }
+                )
+              end
+              def to_hash
+              end
+
+              class MatrixValue < Orb::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Orb::PriceEvaluateMultipleParams::PriceEvaluation::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::PriceEvaluateMultipleParams::PriceEvaluation::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 GroupedWithMinMaxThresholds < Orb::Internal::Type::BaseModel
             OrHash =
               T.type_alias do
                 T.any(
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds,
+                  Orb::Internal::AnyHash
+                )
+              end
+
+            # The cadence to bill for this price on.
+            sig do
+              returns(
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::OrSymbol
+              )
+            end
+            attr_accessor :cadence
+
+            # An ISO 4217 currency string for which this price is billed in.
+            sig { returns(String) }
+            attr_accessor :currency
+
+            # Configuration for grouped_with_min_max_thresholds pricing
+            sig do
+              returns(
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig
+              )
+            end
+            attr_reader :grouped_with_min_max_thresholds_config
+
+            sig do
+              params(
+                grouped_with_min_max_thresholds_config:
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::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
+
+            # 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
+
+            sig do
+              params(
+                cadence:
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::OrSymbol,
+                currency: String,
+                grouped_with_min_max_thresholds_config:
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::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
+                    )
+                  ),
+                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)]),
+                model_type: Symbol
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # The cadence to bill for this price on.
+              cadence:,
+              # An ISO 4217 currency string for which this price is billed in.
+              currency:,
+              # 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,
+              # 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,
+              # The pricing model type
+              model_type: :grouped_with_min_max_thresholds
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  cadence:
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::OrSymbol,
+                  currency: String,
+                  grouped_with_min_max_thresholds_config:
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::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
+                      )
+                    ),
+                  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)])
+                }
+              )
+            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::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              ANNUAL =
+                T.let(
+                  :annual,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                )
+              SEMI_ANNUAL =
+                T.let(
+                  :semi_annual,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                )
+              MONTHLY =
+                T.let(
+                  :monthly,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                )
+              QUARTERLY =
+                T.let(
+                  :quarterly,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                )
+              ONE_TIME =
+                T.let(
+                  :one_time,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                )
+              CUSTOM =
+                T.let(
+                  :custom,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+
+            class GroupedWithMinMaxThresholdsConfig < Orb::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::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::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation,
+                  Orb::Internal::AnyHash
+                )
+              end
+
+            # The cadence to bill for this price on.
+            sig do
+              returns(
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::OrSymbol
+              )
+            end
+            attr_accessor :cadence
+
+            # Configuration for cumulative_grouped_allocation pricing
+            sig do
+              returns(
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig
+              )
+            end
+            attr_reader :cumulative_grouped_allocation_config
+
+            sig do
+              params(
+                cumulative_grouped_allocation_config:
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig::OrHash
+              ).void
+            end
+            attr_writer :cumulative_grouped_allocation_config
+
+            # An ISO 4217 currency string for which this price is billed in.
+            sig { returns(String) }
+            attr_accessor :currency
+
+            # 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
+
+            # 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
+
+            sig do
+              params(
+                cadence:
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::OrSymbol,
+                cumulative_grouped_allocation_config:
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig::OrHash,
+                currency: String,
+                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
+                    )
+                  ),
+                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)]),
+                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:,
+              # An ISO 4217 currency string for which this price is billed in.
+              currency:,
+              # 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,
+              # 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,
+              # The pricing model type
+              model_type: :cumulative_grouped_allocation
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  cadence:
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::OrSymbol,
+                  cumulative_grouped_allocation_config:
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig,
+                  currency: String,
+                  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
+                      )
+                    ),
+                  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)])
+                }
+              )
+            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::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              ANNUAL =
+                T.let(
+                  :annual,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                )
+              SEMI_ANNUAL =
+                T.let(
+                  :semi_annual,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                )
+              MONTHLY =
+                T.let(
+                  :monthly,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                )
+              QUARTERLY =
+                T.let(
+                  :quarterly,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                )
+              ONE_TIME =
+                T.let(
+                  :one_time,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                )
+              CUSTOM =
+                T.let(
+                  :custom,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+
+            class CumulativeGroupedAllocationConfig < Orb::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::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(
+                  {
+                    cumulative_allocation: String,
+                    group_allocation: String,
+                    grouping_key: String,
+                    unit_amount: String
+                  }
+                )
+              end
+              def to_hash
+              end
+            end
+          end
+
+          class DailyCreditAllowance < Orb::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance,
                   Orb::Internal::AnyHash
                 )
               end
@@ -794,7 +2075,7 @@ module Orb
             # The cadence to bill for this price on.
             sig do
               returns(
-                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::OrSymbol
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance::Cadence::OrSymbol
               )
             end
             attr_accessor :cadence
@@ -803,21 +2084,21 @@ module Orb
             sig { returns(String) }
             attr_accessor :currency
 
-            # Configuration for grouped_with_min_max_thresholds pricing
+            # Configuration for daily_credit_allowance pricing
             sig do
               returns(
-                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::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::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig::OrHash
+                daily_credit_allowance_config:
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::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) }
@@ -922,10 +2203,10 @@ module Orb
             sig do
               params(
                 cadence:
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::OrSymbol,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance::Cadence::OrSymbol,
                 currency: String,
-                grouped_with_min_max_thresholds_config:
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig::OrHash,
+                daily_credit_allowance_config:
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance::DailyCreditAllowanceConfig::OrHash,
                 item_id: String,
                 name: String,
                 billable_metric_id: T.nilable(String),
@@ -957,8 +2238,8 @@ module Orb
               cadence:,
               # An ISO 4217 currency string for which this price is billed in.
               currency:,
-              # 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.
@@ -995,7 +2276,7 @@ module Orb
               # by setting `metadata` to `null`.
               metadata: nil,
               # The pricing model type
-              model_type: :grouped_with_min_max_thresholds
+              model_type: :daily_credit_allowance
             )
             end
 
@@ -1003,10 +2284,10 @@ module Orb
               override.returns(
                 {
                   cadence:
-                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::OrSymbol,
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance::Cadence::OrSymbol,
                   currency: String,
-                  grouped_with_min_max_thresholds_config:
-                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig,
+                  daily_credit_allowance_config:
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance::DailyCreditAllowanceConfig,
                   item_id: String,
                   model_type: Symbol,
                   name: String,
@@ -1045,7 +2326,7 @@ module Orb
                 T.type_alias do
                   T.all(
                     Symbol,
-                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance::Cadence
                   )
                 end
               OrSymbol = T.type_alias { T.any(Symbol, String) }
@@ -1053,38 +2334,38 @@ module Orb
               ANNUAL =
                 T.let(
                   :annual,
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance::Cadence::TaggedSymbol
                 )
               SEMI_ANNUAL =
                 T.let(
                   :semi_annual,
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance::Cadence::TaggedSymbol
                 )
               MONTHLY =
                 T.let(
                   :monthly,
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance::Cadence::TaggedSymbol
                 )
               QUARTERLY =
                 T.let(
                   :quarterly,
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance::Cadence::TaggedSymbol
                 )
               ONE_TIME =
                 T.let(
                   :one_time,
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance::Cadence::TaggedSymbol
                 )
               CUSTOM =
                 T.let(
                   :custom,
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance::Cadence::TaggedSymbol
                 )
 
               sig do
                 override.returns(
                   T::Array[
-                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::Cadence::TaggedSymbol
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance::Cadence::TaggedSymbol
                   ]
                 )
               end
@@ -1092,72 +2373,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::PriceEvaluateMultipleParams::PriceEvaluation::Price::GroupedWithMinMaxThresholds::GroupedWithMinMaxThresholdsConfig,
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::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::PriceEvaluateMultipleParams::PriceEvaluation::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::PriceEvaluateMultipleParams::PriceEvaluation::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::PriceEvaluateMultipleParams::PriceEvaluation::Price::DailyCreditAllowance::DailyCreditAllowanceConfig::MatrixValue
+                      ]
                   }
                 )
               end
               def to_hash
               end
+
+              class MatrixValue < Orb::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Orb::PriceEvaluateMultipleParams::PriceEvaluation::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::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance,
                   Orb::Internal::AnyHash
                 )
               end
@@ -1165,34 +2518,34 @@ module Orb
             # The cadence to bill for this price on.
             sig do
               returns(
-                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::OrSymbol
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::Cadence::OrSymbol
               )
             end
             attr_accessor :cadence
 
-            # Configuration for cumulative_grouped_allocation pricing
+            # An ISO 4217 currency string for which this price is billed in.
+            sig { returns(String) }
+            attr_accessor :currency
+
+            # 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::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig
+                Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::MeteredAllowanceConfig
               )
             end
-            attr_reader :cumulative_grouped_allocation_config
+            attr_reader :metered_allowance_config
 
             sig do
               params(
-                cumulative_grouped_allocation_config:
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig::OrHash
+                metered_allowance_config:
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::MeteredAllowanceConfig::OrHash
               ).void
             end
-            attr_writer :cumulative_grouped_allocation_config
-
-            # An ISO 4217 currency string for which this price is billed in.
-            sig { returns(String) }
-            attr_accessor :currency
-
-            # 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) }
@@ -1293,11 +2646,11 @@ module Orb
             sig do
               params(
                 cadence:
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::OrSymbol,
-                cumulative_grouped_allocation_config:
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig::OrHash,
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::Cadence::OrSymbol,
                 currency: String,
                 item_id: String,
+                metered_allowance_config:
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::MeteredAllowanceConfig::OrHash,
                 name: String,
                 billable_metric_id: T.nilable(String),
                 billed_in_advance: T.nilable(T::Boolean),
@@ -1326,12 +2679,12 @@ module Orb
             def self.new(
               # The cadence to bill for this price on.
               cadence:,
-              # Configuration for cumulative_grouped_allocation pricing
-              cumulative_grouped_allocation_config:,
               # An ISO 4217 currency string for which this price is billed in.
               currency:,
               # 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
@@ -1366,7 +2719,7 @@ module Orb
               # by setting `metadata` to `null`.
               metadata: nil,
               # The pricing model type
-              model_type: :cumulative_grouped_allocation
+              model_type: :metered_allowance
             )
             end
 
@@ -1374,11 +2727,11 @@ module Orb
               override.returns(
                 {
                   cadence:
-                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::OrSymbol,
-                  cumulative_grouped_allocation_config:
-                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig,
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::Cadence::OrSymbol,
                   currency: String,
                   item_id: String,
+                  metered_allowance_config:
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::MeteredAllowanceConfig,
                   model_type: Symbol,
                   name: String,
                   billable_metric_id: T.nilable(String),
@@ -1416,7 +2769,7 @@ module Orb
                 T.type_alias do
                   T.all(
                     Symbol,
-                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::Cadence
                   )
                 end
               OrSymbol = T.type_alias { T.any(Symbol, String) }
@@ -1424,38 +2777,38 @@ module Orb
               ANNUAL =
                 T.let(
                   :annual,
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::Cadence::TaggedSymbol
                 )
               SEMI_ANNUAL =
                 T.let(
                   :semi_annual,
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::Cadence::TaggedSymbol
                 )
               MONTHLY =
                 T.let(
                   :monthly,
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::Cadence::TaggedSymbol
                 )
               QUARTERLY =
                 T.let(
                   :quarterly,
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::Cadence::TaggedSymbol
                 )
               ONE_TIME =
                 T.let(
                   :one_time,
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::Cadence::TaggedSymbol
                 )
               CUSTOM =
                 T.let(
                   :custom,
-                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                  Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::Cadence::TaggedSymbol
                 )
 
               sig do
                 override.returns(
                   T::Array[
-                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::Cadence::TaggedSymbol
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::Price::MeteredAllowance::Cadence::TaggedSymbol
                   ]
                 )
               end
@@ -1463,59 +2816,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::PriceEvaluateMultipleParams::PriceEvaluation::Price::CumulativeGroupedAllocation::CumulativeGroupedAllocationConfig,
+                    Orb::PriceEvaluateMultipleParams::PriceEvaluation::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
@@ -1843,19 +3228,60 @@ module Orb
                   )
                 end
 
-              # What percent of the component subtotals to charge
+              # 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