orb-billing 1.30.0 → 1.32.0

data/rbi/orb/models/price_create_params.rbi

@@ -28,6 +28,7 @@ module Orb
             Orb::NewFloatingPackageWithAllocationPrice,
             Orb::NewFloatingUnitWithPercentPrice,
             Orb::NewFloatingMatrixWithAllocationPrice,
+            Orb::PriceCreateParams::Body::TieredMatrixWithAllocation,
             Orb::PriceCreateParams::Body::MatrixWithThresholdDiscounts,
             Orb::NewFloatingTieredWithProrationPrice,
             Orb::NewFloatingUnitWithProrationPrice,
@@ -72,6 +73,7 @@ module Orb
               Orb::NewFloatingPackageWithAllocationPrice::OrHash,
               Orb::NewFloatingUnitWithPercentPrice::OrHash,
               Orb::NewFloatingMatrixWithAllocationPrice::OrHash,
+              Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::OrHash,
               Orb::PriceCreateParams::Body::MatrixWithThresholdDiscounts::OrHash,
               Orb::NewFloatingTieredWithProrationPrice::OrHash,
               Orb::NewFloatingUnitWithProrationPrice::OrHash,
@@ -123,6 +125,7 @@ module Orb
                 Orb::NewFloatingPackageWithAllocationPrice,
                 Orb::NewFloatingUnitWithPercentPrice,
                 Orb::NewFloatingMatrixWithAllocationPrice,
+                Orb::PriceCreateParams::Body::TieredMatrixWithAllocation,
                 Orb::PriceCreateParams::Body::MatrixWithThresholdDiscounts,
                 Orb::NewFloatingTieredWithProrationPrice,
                 Orb::NewFloatingUnitWithProrationPrice,
@@ -173,6 +176,7 @@ module Orb
               Orb::NewFloatingPackageWithAllocationPrice,
               Orb::NewFloatingUnitWithPercentPrice,
               Orb::NewFloatingMatrixWithAllocationPrice,
+              Orb::PriceCreateParams::Body::TieredMatrixWithAllocation,
               Orb::PriceCreateParams::Body::MatrixWithThresholdDiscounts,
               Orb::NewFloatingTieredWithProrationPrice,
               Orb::NewFloatingUnitWithProrationPrice,
@@ -1099,6 +1103,453 @@ module Orb
           end
         end
 
+        class TieredMatrixWithAllocation < Orb::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Orb::PriceCreateParams::Body::TieredMatrixWithAllocation,
+                Orb::Internal::AnyHash
+              )
+            end
+
+          # The cadence to bill for this price on.
+          sig do
+            returns(
+              Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::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
+
+          # 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_matrix_with_allocation pricing
+          sig do
+            returns(
+              Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::TieredMatrixWithAllocationConfig
+            )
+          end
+          attr_reader :tiered_matrix_with_allocation_config
+
+          sig do
+            params(
+              tiered_matrix_with_allocation_config:
+                Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::TieredMatrixWithAllocationConfig::OrHash
+            ).void
+          end
+          attr_writer :tiered_matrix_with_allocation_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
+
+          # 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. On a usage price this
+          # also marks the price as eligible to draw down from that license type's
+          # allocation; a usage price created without it is billed normally. Usage prices
+          # with a license type must use the `unit` model, and only draw down when their
+          # currency matches the allocation's.
+          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::PriceCreateParams::Body::TieredMatrixWithAllocation::Cadence::OrSymbol,
+              currency: String,
+              item_id: String,
+              name: String,
+              tiered_matrix_with_allocation_config:
+                Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::TieredMatrixWithAllocationConfig::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
+                  )
+                ),
+              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:,
+            # The name of the price.
+            name:,
+            # Configuration for tiered_matrix_with_allocation pricing
+            tiered_matrix_with_allocation_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,
+            # 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. On a usage price this
+            # also marks the price as eligible to draw down from that license type's
+            # allocation; a usage price created without it is billed normally. Usage prices
+            # with a license type must use the `unit` model, and only draw down when their
+            # currency matches the allocation's.
+            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: :tiered_matrix_with_allocation
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                cadence:
+                  Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::Cadence::OrSymbol,
+                currency: String,
+                item_id: String,
+                model_type: Symbol,
+                name: String,
+                tiered_matrix_with_allocation_config:
+                  Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::TieredMatrixWithAllocationConfig,
+                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::PriceCreateParams::Body::TieredMatrixWithAllocation::Cadence
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            ANNUAL =
+              T.let(
+                :annual,
+                Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::Cadence::TaggedSymbol
+              )
+            SEMI_ANNUAL =
+              T.let(
+                :semi_annual,
+                Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::Cadence::TaggedSymbol
+              )
+            MONTHLY =
+              T.let(
+                :monthly,
+                Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::Cadence::TaggedSymbol
+              )
+            QUARTERLY =
+              T.let(
+                :quarterly,
+                Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::Cadence::TaggedSymbol
+              )
+            ONE_TIME =
+              T.let(
+                :one_time,
+                Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::Cadence::TaggedSymbol
+              )
+            CUSTOM =
+              T.let(
+                :custom,
+                Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::Cadence::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::Cadence::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+
+          class TieredMatrixWithAllocationConfig < Orb::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::TieredMatrixWithAllocationConfig,
+                  Orb::Internal::AnyHash
+                )
+              end
+
+            # Usage allocation, pooled across all matrix cells
+            sig { returns(String) }
+            attr_accessor :allocation
+
+            # Per unit rate for usage whose matrix cell has no configured tiers
+            sig { returns(String) }
+            attr_accessor :default_unit_amount
+
+            # One or two event property values to evaluate matrix cells by
+            sig { returns(T::Array[String]) }
+            attr_accessor :dimensions
+
+            # Graduated tiers keyed by matrix cell; usage in a cell is tiered only against its
+            # own rows
+            sig do
+              returns(
+                T::Array[
+                  Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::TieredMatrixWithAllocationConfig::Tier
+                ]
+              )
+            end
+            attr_accessor :tiers
+
+            # Configuration for tiered_matrix_with_allocation pricing
+            sig do
+              params(
+                allocation: String,
+                default_unit_amount: String,
+                dimensions: T::Array[String],
+                tiers:
+                  T::Array[
+                    Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::TieredMatrixWithAllocationConfig::Tier::OrHash
+                  ]
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # Usage allocation, pooled across all matrix cells
+              allocation:,
+              # Per unit rate for usage whose matrix cell has no configured tiers
+              default_unit_amount:,
+              # One or two event property values to evaluate matrix cells by
+              dimensions:,
+              # Graduated tiers keyed by matrix cell; usage in a cell is tiered only against its
+              # own rows
+              tiers:
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  allocation: String,
+                  default_unit_amount: String,
+                  dimensions: T::Array[String],
+                  tiers:
+                    T::Array[
+                      Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::TieredMatrixWithAllocationConfig::Tier
+                    ]
+                }
+              )
+            end
+            def to_hash
+            end
+
+            class Tier < Orb::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Orb::PriceCreateParams::Body::TieredMatrixWithAllocation::TieredMatrixWithAllocationConfig::Tier,
+                    Orb::Internal::AnyHash
+                  )
+                end
+
+              # The matrix cell this tier applies to, as one or two dimension values
+              sig { returns(T::Array[String]) }
+              attr_accessor :dimension_values
+
+              # Exclusive tier starting value. The tier runs up to and including the next bound
+              # configured for the same matrix cell.
+              sig { returns(String) }
+              attr_accessor :tier_lower_bound
+
+              # Per unit amount
+              sig { returns(String) }
+              attr_accessor :unit_amount
+
+              # Configuration for a single tier scoped to one matrix cell
+              sig do
+                params(
+                  dimension_values: T::Array[String],
+                  tier_lower_bound: String,
+                  unit_amount: String
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # The matrix cell this tier applies to, as one or two dimension values
+                dimension_values:,
+                # Exclusive tier starting value. The tier runs up to and including the next bound
+                # configured for the same matrix cell.
+                tier_lower_bound:,
+                # Per unit amount
+                unit_amount:
+              )
+              end
+
+              sig do
+                override.returns(
+                  {
+                    dimension_values: T::Array[String],
+                    tier_lower_bound: String,
+                    unit_amount: String
+                  }
+                )
+              end
+              def to_hash
+              end
+            end
+          end
+        end
+
         class MatrixWithThresholdDiscounts < Orb::Internal::Type::BaseModel
           OrHash =
             T.type_alias do