orb-billing 0.11.0 → 1.0.0

data/rbi/orb/models/new_floating_unit_with_proration_price.rbi

@@ -0,0 +1,331 @@
+# typed: strong
+
+module Orb
+  module Models
+    class NewFloatingUnitWithProrationPrice < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::NewFloatingUnitWithProrationPrice, Orb::Internal::AnyHash)
+        end
+
+      # The cadence to bill for this price on.
+      sig { returns(Orb::NewFloatingUnitWithProrationPrice::Cadence::OrSymbol) }
+      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
+
+      sig do
+        returns(Orb::NewFloatingUnitWithProrationPrice::ModelType::OrSymbol)
+      end
+      attr_accessor :model_type
+
+      # The name of the price.
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(T::Hash[Symbol, T.anything]) }
+      attr_accessor :unit_with_proration_config
+
+      # The id of the billable metric for the price. Only needed if the price is
+      # usage-based.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :billable_metric_id
+
+      # If the Price represents a fixed cost, the price will be billed in-advance if
+      # this is true, and in-arrears if this is false.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :billed_in_advance
+
+      # For custom cadence: specifies the duration of the billing period in days or
+      # months.
+      sig { returns(T.nilable(Orb::NewBillingCycleConfiguration)) }
+      attr_reader :billing_cycle_configuration
+
+      sig do
+        params(
+          billing_cycle_configuration:
+            T.nilable(Orb::NewBillingCycleConfiguration::OrHash)
+        ).void
+      end
+      attr_writer :billing_cycle_configuration
+
+      # The per unit conversion rate of the price currency to the invoicing currency.
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :conversion_rate
+
+      # The configuration for the rate of the price currency to the invoicing currency.
+      sig do
+        returns(
+          T.nilable(
+            T.any(
+              Orb::UnitConversionRateConfig,
+              Orb::TieredConversionRateConfig
+            )
+          )
+        )
+      end
+      attr_accessor :conversion_rate_config
+
+      # 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
+
+      # 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::NewFloatingUnitWithProrationPrice::Cadence::OrSymbol,
+          currency: String,
+          item_id: String,
+          model_type:
+            Orb::NewFloatingUnitWithProrationPrice::ModelType::OrSymbol,
+          name: String,
+          unit_with_proration_config: T::Hash[Symbol, T.anything],
+          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),
+          metadata: T.nilable(T::Hash[Symbol, T.nilable(String)])
+        ).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:,
+        model_type:,
+        # The name of the price.
+        name:,
+        unit_with_proration_config:,
+        # The id of the billable metric for the price. Only needed if the price is
+        # usage-based.
+        billable_metric_id: nil,
+        # If the Price represents a fixed cost, the price will be billed in-advance if
+        # this is true, and in-arrears if this is false.
+        billed_in_advance: nil,
+        # For custom cadence: specifies the duration of the billing period in days or
+        # months.
+        billing_cycle_configuration: nil,
+        # The per unit conversion rate of the price currency to the invoicing currency.
+        conversion_rate: nil,
+        # The configuration for the rate of the price currency to the invoicing currency.
+        conversion_rate_config: nil,
+        # 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,
+        # 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
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            cadence: Orb::NewFloatingUnitWithProrationPrice::Cadence::OrSymbol,
+            currency: String,
+            item_id: String,
+            model_type:
+              Orb::NewFloatingUnitWithProrationPrice::ModelType::OrSymbol,
+            name: String,
+            unit_with_proration_config: T::Hash[Symbol, T.anything],
+            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),
+            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::NewFloatingUnitWithProrationPrice::Cadence)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ANNUAL =
+          T.let(
+            :annual,
+            Orb::NewFloatingUnitWithProrationPrice::Cadence::TaggedSymbol
+          )
+        SEMI_ANNUAL =
+          T.let(
+            :semi_annual,
+            Orb::NewFloatingUnitWithProrationPrice::Cadence::TaggedSymbol
+          )
+        MONTHLY =
+          T.let(
+            :monthly,
+            Orb::NewFloatingUnitWithProrationPrice::Cadence::TaggedSymbol
+          )
+        QUARTERLY =
+          T.let(
+            :quarterly,
+            Orb::NewFloatingUnitWithProrationPrice::Cadence::TaggedSymbol
+          )
+        ONE_TIME =
+          T.let(
+            :one_time,
+            Orb::NewFloatingUnitWithProrationPrice::Cadence::TaggedSymbol
+          )
+        CUSTOM =
+          T.let(
+            :custom,
+            Orb::NewFloatingUnitWithProrationPrice::Cadence::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Orb::NewFloatingUnitWithProrationPrice::Cadence::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      module ModelType
+        extend Orb::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Orb::NewFloatingUnitWithProrationPrice::ModelType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        UNIT_WITH_PRORATION =
+          T.let(
+            :unit_with_proration,
+            Orb::NewFloatingUnitWithProrationPrice::ModelType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Orb::NewFloatingUnitWithProrationPrice::ModelType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # The configuration for the rate of the price currency to the invoicing currency.
+      module ConversionRateConfig
+        extend Orb::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              Orb::UnitConversionRateConfig,
+              Orb::TieredConversionRateConfig
+            )
+          end
+
+        sig do
+          override.returns(
+            T::Array[
+              Orb::NewFloatingUnitWithProrationPrice::ConversionRateConfig::Variants
+            ]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/orb/models/new_maximum.rbi

@@ -0,0 +1,160 @@
+# typed: strong
+
+module Orb
+  module Models
+    class NewMaximum < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::NewMaximum, Orb::Internal::AnyHash) }
+
+      sig { returns(Orb::NewMaximum::AdjustmentType::OrSymbol) }
+      attr_accessor :adjustment_type
+
+      sig { returns(String) }
+      attr_accessor :maximum_amount
+
+      # If set, the adjustment will apply to every price on the subscription.
+      sig { returns(T.nilable(Orb::NewMaximum::AppliesToAll::OrBoolean)) }
+      attr_accessor :applies_to_all
+
+      # The set of item IDs to which this adjustment applies.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :applies_to_item_ids
+
+      # The set of price IDs to which this adjustment applies.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :applies_to_price_ids
+
+      # If set, only prices in the specified currency will have the adjustment applied.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :currency
+
+      # A list of filters that determine which prices this adjustment will apply to.
+      sig { returns(T.nilable(T::Array[Orb::TransformPriceFilter])) }
+      attr_accessor :filters
+
+      # When false, this adjustment will be applied to a single price. Otherwise, it
+      # will be applied at the invoice level, possibly to multiple prices.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_invoice_level
+
+      sig { params(is_invoice_level: T::Boolean).void }
+      attr_writer :is_invoice_level
+
+      # If set, only prices of the specified type will have the adjustment applied.
+      sig { returns(T.nilable(Orb::NewMaximum::PriceType::OrSymbol)) }
+      attr_accessor :price_type
+
+      sig do
+        params(
+          adjustment_type: Orb::NewMaximum::AdjustmentType::OrSymbol,
+          maximum_amount: String,
+          applies_to_all: T.nilable(Orb::NewMaximum::AppliesToAll::OrBoolean),
+          applies_to_item_ids: T.nilable(T::Array[String]),
+          applies_to_price_ids: T.nilable(T::Array[String]),
+          currency: T.nilable(String),
+          filters: T.nilable(T::Array[Orb::TransformPriceFilter::OrHash]),
+          is_invoice_level: T::Boolean,
+          price_type: T.nilable(Orb::NewMaximum::PriceType::OrSymbol)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        adjustment_type:,
+        maximum_amount:,
+        # If set, the adjustment will apply to every price on the subscription.
+        applies_to_all: nil,
+        # The set of item IDs to which this adjustment applies.
+        applies_to_item_ids: nil,
+        # The set of price IDs to which this adjustment applies.
+        applies_to_price_ids: nil,
+        # If set, only prices in the specified currency will have the adjustment applied.
+        currency: nil,
+        # A list of filters that determine which prices this adjustment will apply to.
+        filters: nil,
+        # When false, this adjustment will be applied to a single price. Otherwise, it
+        # will be applied at the invoice level, possibly to multiple prices.
+        is_invoice_level: nil,
+        # If set, only prices of the specified type will have the adjustment applied.
+        price_type: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            adjustment_type: Orb::NewMaximum::AdjustmentType::OrSymbol,
+            maximum_amount: String,
+            applies_to_all: T.nilable(Orb::NewMaximum::AppliesToAll::OrBoolean),
+            applies_to_item_ids: T.nilable(T::Array[String]),
+            applies_to_price_ids: T.nilable(T::Array[String]),
+            currency: T.nilable(String),
+            filters: T.nilable(T::Array[Orb::TransformPriceFilter]),
+            is_invoice_level: T::Boolean,
+            price_type: T.nilable(Orb::NewMaximum::PriceType::OrSymbol)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module AdjustmentType
+        extend Orb::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Orb::NewMaximum::AdjustmentType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MAXIMUM = T.let(:maximum, Orb::NewMaximum::AdjustmentType::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Orb::NewMaximum::AdjustmentType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # If set, the adjustment will apply to every price on the subscription.
+      module AppliesToAll
+        extend Orb::Internal::Type::Enum
+
+        TaggedBoolean =
+          T.type_alias { T.all(T::Boolean, Orb::NewMaximum::AppliesToAll) }
+        OrBoolean = T.type_alias { T::Boolean }
+
+        TRUE = T.let(true, Orb::NewMaximum::AppliesToAll::TaggedBoolean)
+
+        sig do
+          override.returns(
+            T::Array[Orb::NewMaximum::AppliesToAll::TaggedBoolean]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # If set, only prices of the specified type will have the adjustment applied.
+      module PriceType
+        extend Orb::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Orb::NewMaximum::PriceType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        USAGE = T.let(:usage, Orb::NewMaximum::PriceType::TaggedSymbol)
+        FIXED_IN_ADVANCE =
+          T.let(:fixed_in_advance, Orb::NewMaximum::PriceType::TaggedSymbol)
+        FIXED_IN_ARREARS =
+          T.let(:fixed_in_arrears, Orb::NewMaximum::PriceType::TaggedSymbol)
+        FIXED = T.let(:fixed, Orb::NewMaximum::PriceType::TaggedSymbol)
+        IN_ARREARS =
+          T.let(:in_arrears, Orb::NewMaximum::PriceType::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Orb::NewMaximum::PriceType::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/orb/models/new_minimum.rbi

@@ -0,0 +1,168 @@
+# typed: strong
+
+module Orb
+  module Models
+    class NewMinimum < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::NewMinimum, Orb::Internal::AnyHash) }
+
+      sig { returns(Orb::NewMinimum::AdjustmentType::OrSymbol) }
+      attr_accessor :adjustment_type
+
+      # The item ID that revenue from this minimum will be attributed to.
+      sig { returns(String) }
+      attr_accessor :item_id
+
+      sig { returns(String) }
+      attr_accessor :minimum_amount
+
+      # If set, the adjustment will apply to every price on the subscription.
+      sig { returns(T.nilable(Orb::NewMinimum::AppliesToAll::OrBoolean)) }
+      attr_accessor :applies_to_all
+
+      # The set of item IDs to which this adjustment applies.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :applies_to_item_ids
+
+      # The set of price IDs to which this adjustment applies.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :applies_to_price_ids
+
+      # If set, only prices in the specified currency will have the adjustment applied.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :currency
+
+      # A list of filters that determine which prices this adjustment will apply to.
+      sig { returns(T.nilable(T::Array[Orb::TransformPriceFilter])) }
+      attr_accessor :filters
+
+      # When false, this adjustment will be applied to a single price. Otherwise, it
+      # will be applied at the invoice level, possibly to multiple prices.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_invoice_level
+
+      sig { params(is_invoice_level: T::Boolean).void }
+      attr_writer :is_invoice_level
+
+      # If set, only prices of the specified type will have the adjustment applied.
+      sig { returns(T.nilable(Orb::NewMinimum::PriceType::OrSymbol)) }
+      attr_accessor :price_type
+
+      sig do
+        params(
+          adjustment_type: Orb::NewMinimum::AdjustmentType::OrSymbol,
+          item_id: String,
+          minimum_amount: String,
+          applies_to_all: T.nilable(Orb::NewMinimum::AppliesToAll::OrBoolean),
+          applies_to_item_ids: T.nilable(T::Array[String]),
+          applies_to_price_ids: T.nilable(T::Array[String]),
+          currency: T.nilable(String),
+          filters: T.nilable(T::Array[Orb::TransformPriceFilter::OrHash]),
+          is_invoice_level: T::Boolean,
+          price_type: T.nilable(Orb::NewMinimum::PriceType::OrSymbol)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        adjustment_type:,
+        # The item ID that revenue from this minimum will be attributed to.
+        item_id:,
+        minimum_amount:,
+        # If set, the adjustment will apply to every price on the subscription.
+        applies_to_all: nil,
+        # The set of item IDs to which this adjustment applies.
+        applies_to_item_ids: nil,
+        # The set of price IDs to which this adjustment applies.
+        applies_to_price_ids: nil,
+        # If set, only prices in the specified currency will have the adjustment applied.
+        currency: nil,
+        # A list of filters that determine which prices this adjustment will apply to.
+        filters: nil,
+        # When false, this adjustment will be applied to a single price. Otherwise, it
+        # will be applied at the invoice level, possibly to multiple prices.
+        is_invoice_level: nil,
+        # If set, only prices of the specified type will have the adjustment applied.
+        price_type: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            adjustment_type: Orb::NewMinimum::AdjustmentType::OrSymbol,
+            item_id: String,
+            minimum_amount: String,
+            applies_to_all: T.nilable(Orb::NewMinimum::AppliesToAll::OrBoolean),
+            applies_to_item_ids: T.nilable(T::Array[String]),
+            applies_to_price_ids: T.nilable(T::Array[String]),
+            currency: T.nilable(String),
+            filters: T.nilable(T::Array[Orb::TransformPriceFilter]),
+            is_invoice_level: T::Boolean,
+            price_type: T.nilable(Orb::NewMinimum::PriceType::OrSymbol)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module AdjustmentType
+        extend Orb::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Orb::NewMinimum::AdjustmentType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MINIMUM = T.let(:minimum, Orb::NewMinimum::AdjustmentType::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Orb::NewMinimum::AdjustmentType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # If set, the adjustment will apply to every price on the subscription.
+      module AppliesToAll
+        extend Orb::Internal::Type::Enum
+
+        TaggedBoolean =
+          T.type_alias { T.all(T::Boolean, Orb::NewMinimum::AppliesToAll) }
+        OrBoolean = T.type_alias { T::Boolean }
+
+        TRUE = T.let(true, Orb::NewMinimum::AppliesToAll::TaggedBoolean)
+
+        sig do
+          override.returns(
+            T::Array[Orb::NewMinimum::AppliesToAll::TaggedBoolean]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # If set, only prices of the specified type will have the adjustment applied.
+      module PriceType
+        extend Orb::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Orb::NewMinimum::PriceType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        USAGE = T.let(:usage, Orb::NewMinimum::PriceType::TaggedSymbol)
+        FIXED_IN_ADVANCE =
+          T.let(:fixed_in_advance, Orb::NewMinimum::PriceType::TaggedSymbol)
+        FIXED_IN_ARREARS =
+          T.let(:fixed_in_arrears, Orb::NewMinimum::PriceType::TaggedSymbol)
+        FIXED = T.let(:fixed, Orb::NewMinimum::PriceType::TaggedSymbol)
+        IN_ARREARS =
+          T.let(:in_arrears, Orb::NewMinimum::PriceType::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Orb::NewMinimum::PriceType::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end