orb-billing 0.11.0 → 1.0.0

data/rbi/orb/models/invoice_tiny.rbi

@@ -0,0 +1,24 @@
+# typed: strong
+
+module Orb
+  module Models
+    class InvoiceTiny < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::InvoiceTiny, Orb::Internal::AnyHash) }
+
+      # The Invoice id
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { params(id: String).returns(T.attached_class) }
+      def self.new(
+        # The Invoice id
+        id:
+      )
+      end
+
+      sig { override.returns({ id: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/item_slim.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module Orb
+  module Models
+    class ItemSlim < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::ItemSlim, Orb::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { params(id: String, name: String).returns(T.attached_class) }
+      def self.new(id:, name:)
+      end
+
+      sig { override.returns({ id: String, name: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/matrix_config.rbi

@@ -0,0 +1,50 @@
+# typed: strong
+
+module Orb
+  module Models
+    class MatrixConfig < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::MatrixConfig, Orb::Internal::AnyHash) }
+
+      # Default per unit rate for any usage not bucketed into a specified matrix_value
+      sig { returns(String) }
+      attr_accessor :default_unit_amount
+
+      # One or two event property values to evaluate matrix groups by
+      sig { returns(T::Array[T.nilable(String)]) }
+      attr_accessor :dimensions
+
+      # Matrix values for specified matrix grouping keys
+      sig { returns(T::Array[Orb::MatrixValue]) }
+      attr_accessor :matrix_values
+
+      sig do
+        params(
+          default_unit_amount: String,
+          dimensions: T::Array[T.nilable(String)],
+          matrix_values: T::Array[Orb::MatrixValue::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Default per unit 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:,
+        # Matrix values for specified matrix grouping keys
+        matrix_values:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            default_unit_amount: String,
+            dimensions: T::Array[T.nilable(String)],
+            matrix_values: T::Array[Orb::MatrixValue]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/matrix_sub_line_item.rbi

@@ -0,0 +1,87 @@
+# typed: strong
+
+module Orb
+  module Models
+    class MatrixSubLineItem < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Orb::MatrixSubLineItem, Orb::Internal::AnyHash) }
+
+      # The total amount for this sub line item.
+      sig { returns(String) }
+      attr_accessor :amount
+
+      sig { returns(T.nilable(Orb::SubLineItemGrouping)) }
+      attr_reader :grouping
+
+      sig { params(grouping: T.nilable(Orb::SubLineItemGrouping::OrHash)).void }
+      attr_writer :grouping
+
+      sig { returns(Orb::SubLineItemMatrixConfig) }
+      attr_reader :matrix_config
+
+      sig { params(matrix_config: Orb::SubLineItemMatrixConfig::OrHash).void }
+      attr_writer :matrix_config
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(Float) }
+      attr_accessor :quantity
+
+      sig { returns(Orb::MatrixSubLineItem::Type::TaggedSymbol) }
+      attr_accessor :type
+
+      sig do
+        params(
+          amount: String,
+          grouping: T.nilable(Orb::SubLineItemGrouping::OrHash),
+          matrix_config: Orb::SubLineItemMatrixConfig::OrHash,
+          name: String,
+          quantity: Float,
+          type: Orb::MatrixSubLineItem::Type::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The total amount for this sub line item.
+        amount:,
+        grouping:,
+        matrix_config:,
+        name:,
+        quantity:,
+        type:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            amount: String,
+            grouping: T.nilable(Orb::SubLineItemGrouping),
+            matrix_config: Orb::SubLineItemMatrixConfig,
+            name: String,
+            quantity: Float,
+            type: Orb::MatrixSubLineItem::Type::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend Orb::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Orb::MatrixSubLineItem::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MATRIX = T.let(:matrix, Orb::MatrixSubLineItem::Type::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Orb::MatrixSubLineItem::Type::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/orb/models/matrix_value.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Orb
+  module Models
+    class MatrixValue < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::MatrixValue, Orb::Internal::AnyHash) }
+
+      # One or two matrix keys to filter usage to this Matrix value by. For example,
+      # ["region", "tier"] could be used to filter cloud usage by a cloud region and an
+      # instance tier.
+      sig { returns(T::Array[T.nilable(String)]) }
+      attr_accessor :dimension_values
+
+      # Unit price for the specified dimension_values
+      sig { returns(String) }
+      attr_accessor :unit_amount
+
+      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 Matrix value by. For example,
+        # ["region", "tier"] could be used to filter cloud usage by a cloud region and an
+        # instance tier.
+        dimension_values:,
+        # Unit price for 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

data/rbi/orb/models/matrix_with_allocation_config.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module Orb
+  module Models
+    class MatrixWithAllocationConfig < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::MatrixWithAllocationConfig, Orb::Internal::AnyHash)
+        end
+
+      # Allocation to be used to calculate the price
+      sig { returns(Float) }
+      attr_accessor :allocation
+
+      # Default per unit rate for any usage not bucketed into a specified matrix_value
+      sig { returns(String) }
+      attr_accessor :default_unit_amount
+
+      # One or two event property values to evaluate matrix groups by
+      sig { returns(T::Array[T.nilable(String)]) }
+      attr_accessor :dimensions
+
+      # Matrix values for specified matrix grouping keys
+      sig { returns(T::Array[Orb::MatrixValue]) }
+      attr_accessor :matrix_values
+
+      sig do
+        params(
+          allocation: Float,
+          default_unit_amount: String,
+          dimensions: T::Array[T.nilable(String)],
+          matrix_values: T::Array[Orb::MatrixValue::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Allocation to be used to calculate the price
+        allocation:,
+        # Default per unit 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:,
+        # Matrix values for specified matrix grouping keys
+        matrix_values:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            allocation: Float,
+            default_unit_amount: String,
+            dimensions: T::Array[T.nilable(String)],
+            matrix_values: T::Array[Orb::MatrixValue]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/maximum.rbi

@@ -0,0 +1,52 @@
+# typed: strong
+
+module Orb
+  module Models
+    class Maximum < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::Maximum, Orb::Internal::AnyHash) }
+
+      # List of price_ids that this maximum amount applies to. For plan/plan phase
+      # maximums, this can be a subset of prices.
+      sig { returns(T::Array[String]) }
+      attr_accessor :applies_to_price_ids
+
+      # The filters that determine which prices to apply this maximum to.
+      sig { returns(T::Array[Orb::TransformPriceFilter]) }
+      attr_accessor :filters
+
+      # Maximum amount applied
+      sig { returns(String) }
+      attr_accessor :maximum_amount
+
+      sig do
+        params(
+          applies_to_price_ids: T::Array[String],
+          filters: T::Array[Orb::TransformPriceFilter::OrHash],
+          maximum_amount: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # List of price_ids that this maximum amount applies to. For plan/plan phase
+        # maximums, this can be a subset of prices.
+        applies_to_price_ids:,
+        # The filters that determine which prices to apply this maximum to.
+        filters:,
+        # Maximum amount applied
+        maximum_amount:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            applies_to_price_ids: T::Array[String],
+            filters: T::Array[Orb::TransformPriceFilter],
+            maximum_amount: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/maximum_interval.rbi

@@ -0,0 +1,69 @@
+# typed: strong
+
+module Orb
+  module Models
+    class MaximumInterval < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Orb::MaximumInterval, Orb::Internal::AnyHash) }
+
+      # The price interval ids that this maximum interval applies to.
+      sig { returns(T::Array[String]) }
+      attr_accessor :applies_to_price_interval_ids
+
+      # The end date of the maximum interval.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :end_date
+
+      # The filters that determine which prices this maximum interval applies to.
+      sig { returns(T::Array[Orb::TransformPriceFilter]) }
+      attr_accessor :filters
+
+      # The maximum amount to charge in a given billing period for the price intervals
+      # this transform applies to.
+      sig { returns(String) }
+      attr_accessor :maximum_amount
+
+      # The start date of the maximum interval.
+      sig { returns(Time) }
+      attr_accessor :start_date
+
+      sig do
+        params(
+          applies_to_price_interval_ids: T::Array[String],
+          end_date: T.nilable(Time),
+          filters: T::Array[Orb::TransformPriceFilter::OrHash],
+          maximum_amount: String,
+          start_date: Time
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The price interval ids that this maximum interval applies to.
+        applies_to_price_interval_ids:,
+        # The end date of the maximum interval.
+        end_date:,
+        # The filters that determine which prices this maximum interval applies to.
+        filters:,
+        # The maximum amount to charge in a given billing period for the price intervals
+        # this transform applies to.
+        maximum_amount:,
+        # The start date of the maximum interval.
+        start_date:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            applies_to_price_interval_ids: T::Array[String],
+            end_date: T.nilable(Time),
+            filters: T::Array[Orb::TransformPriceFilter],
+            maximum_amount: String,
+            start_date: Time
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/minimum.rbi

@@ -0,0 +1,52 @@
+# typed: strong
+
+module Orb
+  module Models
+    class Minimum < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::Minimum, Orb::Internal::AnyHash) }
+
+      # List of price_ids that this minimum amount applies to. For plan/plan phase
+      # minimums, this can be a subset of prices.
+      sig { returns(T::Array[String]) }
+      attr_accessor :applies_to_price_ids
+
+      # The filters that determine which prices to apply this minimum to.
+      sig { returns(T::Array[Orb::TransformPriceFilter]) }
+      attr_accessor :filters
+
+      # Minimum amount applied
+      sig { returns(String) }
+      attr_accessor :minimum_amount
+
+      sig do
+        params(
+          applies_to_price_ids: T::Array[String],
+          filters: T::Array[Orb::TransformPriceFilter::OrHash],
+          minimum_amount: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # List of price_ids that this minimum amount applies to. For plan/plan phase
+        # minimums, this can be a subset of prices.
+        applies_to_price_ids:,
+        # The filters that determine which prices to apply this minimum to.
+        filters:,
+        # Minimum amount applied
+        minimum_amount:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            applies_to_price_ids: T::Array[String],
+            filters: T::Array[Orb::TransformPriceFilter],
+            minimum_amount: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/minimum_interval.rbi

@@ -0,0 +1,69 @@
+# typed: strong
+
+module Orb
+  module Models
+    class MinimumInterval < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Orb::MinimumInterval, Orb::Internal::AnyHash) }
+
+      # The price interval ids that this minimum interval applies to.
+      sig { returns(T::Array[String]) }
+      attr_accessor :applies_to_price_interval_ids
+
+      # The end date of the minimum interval.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :end_date
+
+      # The filters that determine which prices this minimum interval applies to.
+      sig { returns(T::Array[Orb::TransformPriceFilter]) }
+      attr_accessor :filters
+
+      # The minimum amount to charge in a given billing period for the price intervals
+      # this minimum applies to.
+      sig { returns(String) }
+      attr_accessor :minimum_amount
+
+      # The start date of the minimum interval.
+      sig { returns(Time) }
+      attr_accessor :start_date
+
+      sig do
+        params(
+          applies_to_price_interval_ids: T::Array[String],
+          end_date: T.nilable(Time),
+          filters: T::Array[Orb::TransformPriceFilter::OrHash],
+          minimum_amount: String,
+          start_date: Time
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The price interval ids that this minimum interval applies to.
+        applies_to_price_interval_ids:,
+        # The end date of the minimum interval.
+        end_date:,
+        # The filters that determine which prices this minimum interval applies to.
+        filters:,
+        # The minimum amount to charge in a given billing period for the price intervals
+        # this minimum applies to.
+        minimum_amount:,
+        # The start date of the minimum interval.
+        start_date:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            applies_to_price_interval_ids: T::Array[String],
+            end_date: T.nilable(Time),
+            filters: T::Array[Orb::TransformPriceFilter],
+            minimum_amount: String,
+            start_date: Time
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/monetary_amount_discount_adjustment.rbi

@@ -0,0 +1,125 @@
+# typed: strong
+
+module Orb
+  module Models
+    class MonetaryAmountDiscountAdjustment < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::MonetaryAmountDiscountAdjustment, Orb::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig do
+        returns(
+          Orb::MonetaryAmountDiscountAdjustment::AdjustmentType::TaggedSymbol
+        )
+      end
+      attr_accessor :adjustment_type
+
+      # The value applied by an adjustment.
+      sig { returns(String) }
+      attr_accessor :amount
+
+      # The amount by which to discount the prices this adjustment applies to in a given
+      # billing period.
+      sig { returns(String) }
+      attr_accessor :amount_discount
+
+      # The price IDs that this adjustment applies to.
+      sig { returns(T::Array[String]) }
+      attr_accessor :applies_to_price_ids
+
+      # The filters that determine which prices to apply this adjustment to.
+      sig { returns(T::Array[Orb::TransformPriceFilter]) }
+      attr_accessor :filters
+
+      # True for adjustments that apply to an entire invocice, false for adjustments
+      # that apply to only one price.
+      sig { returns(T::Boolean) }
+      attr_accessor :is_invoice_level
+
+      # The reason for the adjustment.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :reason
+
+      sig do
+        params(
+          id: String,
+          adjustment_type:
+            Orb::MonetaryAmountDiscountAdjustment::AdjustmentType::OrSymbol,
+          amount: String,
+          amount_discount: String,
+          applies_to_price_ids: T::Array[String],
+          filters: T::Array[Orb::TransformPriceFilter::OrHash],
+          is_invoice_level: T::Boolean,
+          reason: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        adjustment_type:,
+        # The value applied by an adjustment.
+        amount:,
+        # The amount by which to discount the prices this adjustment applies to in a given
+        # billing period.
+        amount_discount:,
+        # The price IDs that this adjustment applies to.
+        applies_to_price_ids:,
+        # The filters that determine which prices to apply this adjustment to.
+        filters:,
+        # True for adjustments that apply to an entire invocice, false for adjustments
+        # that apply to only one price.
+        is_invoice_level:,
+        # The reason for the adjustment.
+        reason:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            adjustment_type:
+              Orb::MonetaryAmountDiscountAdjustment::AdjustmentType::TaggedSymbol,
+            amount: String,
+            amount_discount: String,
+            applies_to_price_ids: T::Array[String],
+            filters: T::Array[Orb::TransformPriceFilter],
+            is_invoice_level: T::Boolean,
+            reason: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module AdjustmentType
+        extend Orb::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Orb::MonetaryAmountDiscountAdjustment::AdjustmentType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        AMOUNT_DISCOUNT =
+          T.let(
+            :amount_discount,
+            Orb::MonetaryAmountDiscountAdjustment::AdjustmentType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Orb::MonetaryAmountDiscountAdjustment::AdjustmentType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end