orb-billing 0.11.0 → 1.0.0

data/rbi/orb/models/plan_phase_amount_discount_adjustment.rbi

@@ -0,0 +1,128 @@
+# typed: strong
+
+module Orb
+  module Models
+    class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::PlanPhaseAmountDiscountAdjustment, Orb::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig do
+        returns(
+          Orb::PlanPhaseAmountDiscountAdjustment::AdjustmentType::TaggedSymbol
+        )
+      end
+      attr_accessor :adjustment_type
+
+      # 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 plan phase in which this adjustment is active.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :plan_phase_order
+
+      # The reason for the adjustment.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :reason
+
+      sig do
+        params(
+          id: String,
+          adjustment_type:
+            Orb::PlanPhaseAmountDiscountAdjustment::AdjustmentType::OrSymbol,
+          amount_discount: String,
+          applies_to_price_ids: T::Array[String],
+          filters: T::Array[Orb::TransformPriceFilter::OrHash],
+          is_invoice_level: T::Boolean,
+          plan_phase_order: T.nilable(Integer),
+          reason: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        adjustment_type:,
+        # 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 plan phase in which this adjustment is active.
+        plan_phase_order:,
+        # The reason for the adjustment.
+        reason:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            adjustment_type:
+              Orb::PlanPhaseAmountDiscountAdjustment::AdjustmentType::TaggedSymbol,
+            amount_discount: String,
+            applies_to_price_ids: T::Array[String],
+            filters: T::Array[Orb::TransformPriceFilter],
+            is_invoice_level: T::Boolean,
+            plan_phase_order: T.nilable(Integer),
+            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::PlanPhaseAmountDiscountAdjustment::AdjustmentType
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        AMOUNT_DISCOUNT =
+          T.let(
+            :amount_discount,
+            Orb::PlanPhaseAmountDiscountAdjustment::AdjustmentType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Orb::PlanPhaseAmountDiscountAdjustment::AdjustmentType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/orb/models/plan_phase_maximum_adjustment.rbi

@@ -0,0 +1,123 @@
+# typed: strong
+
+module Orb
+  module Models
+    class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::PlanPhaseMaximumAdjustment, Orb::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig do
+        returns(Orb::PlanPhaseMaximumAdjustment::AdjustmentType::TaggedSymbol)
+      end
+      attr_accessor :adjustment_type
+
+      # 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 maximum amount to charge in a given billing period for the prices this
+      # adjustment applies to.
+      sig { returns(String) }
+      attr_accessor :maximum_amount
+
+      # The plan phase in which this adjustment is active.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :plan_phase_order
+
+      # The reason for the adjustment.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :reason
+
+      sig do
+        params(
+          id: String,
+          adjustment_type:
+            Orb::PlanPhaseMaximumAdjustment::AdjustmentType::OrSymbol,
+          applies_to_price_ids: T::Array[String],
+          filters: T::Array[Orb::TransformPriceFilter::OrHash],
+          is_invoice_level: T::Boolean,
+          maximum_amount: String,
+          plan_phase_order: T.nilable(Integer),
+          reason: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        adjustment_type:,
+        # 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 maximum amount to charge in a given billing period for the prices this
+        # adjustment applies to.
+        maximum_amount:,
+        # The plan phase in which this adjustment is active.
+        plan_phase_order:,
+        # The reason for the adjustment.
+        reason:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            adjustment_type:
+              Orb::PlanPhaseMaximumAdjustment::AdjustmentType::TaggedSymbol,
+            applies_to_price_ids: T::Array[String],
+            filters: T::Array[Orb::TransformPriceFilter],
+            is_invoice_level: T::Boolean,
+            maximum_amount: String,
+            plan_phase_order: T.nilable(Integer),
+            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::PlanPhaseMaximumAdjustment::AdjustmentType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MAXIMUM =
+          T.let(
+            :maximum,
+            Orb::PlanPhaseMaximumAdjustment::AdjustmentType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Orb::PlanPhaseMaximumAdjustment::AdjustmentType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/orb/models/plan_phase_minimum_adjustment.rbi

@@ -0,0 +1,131 @@
+# typed: strong
+
+module Orb
+  module Models
+    class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::PlanPhaseMinimumAdjustment, Orb::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig do
+        returns(Orb::PlanPhaseMinimumAdjustment::AdjustmentType::TaggedSymbol)
+      end
+      attr_accessor :adjustment_type
+
+      # 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 item ID that revenue from this minimum will be attributed to.
+      sig { returns(String) }
+      attr_accessor :item_id
+
+      # The minimum amount to charge in a given billing period for the prices this
+      # adjustment applies to.
+      sig { returns(String) }
+      attr_accessor :minimum_amount
+
+      # The plan phase in which this adjustment is active.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :plan_phase_order
+
+      # The reason for the adjustment.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :reason
+
+      sig do
+        params(
+          id: String,
+          adjustment_type:
+            Orb::PlanPhaseMinimumAdjustment::AdjustmentType::OrSymbol,
+          applies_to_price_ids: T::Array[String],
+          filters: T::Array[Orb::TransformPriceFilter::OrHash],
+          is_invoice_level: T::Boolean,
+          item_id: String,
+          minimum_amount: String,
+          plan_phase_order: T.nilable(Integer),
+          reason: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        adjustment_type:,
+        # 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 item ID that revenue from this minimum will be attributed to.
+        item_id:,
+        # The minimum amount to charge in a given billing period for the prices this
+        # adjustment applies to.
+        minimum_amount:,
+        # The plan phase in which this adjustment is active.
+        plan_phase_order:,
+        # The reason for the adjustment.
+        reason:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            adjustment_type:
+              Orb::PlanPhaseMinimumAdjustment::AdjustmentType::TaggedSymbol,
+            applies_to_price_ids: T::Array[String],
+            filters: T::Array[Orb::TransformPriceFilter],
+            is_invoice_level: T::Boolean,
+            item_id: String,
+            minimum_amount: String,
+            plan_phase_order: T.nilable(Integer),
+            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::PlanPhaseMinimumAdjustment::AdjustmentType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MINIMUM =
+          T.let(
+            :minimum,
+            Orb::PlanPhaseMinimumAdjustment::AdjustmentType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Orb::PlanPhaseMinimumAdjustment::AdjustmentType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/orb/models/plan_phase_percentage_discount_adjustment.rbi

@@ -0,0 +1,131 @@
+# typed: strong
+
+module Orb
+  module Models
+    class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Orb::PlanPhasePercentageDiscountAdjustment,
+            Orb::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig do
+        returns(
+          Orb::PlanPhasePercentageDiscountAdjustment::AdjustmentType::TaggedSymbol
+        )
+      end
+      attr_accessor :adjustment_type
+
+      # 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 percentage (as a value between 0 and 1) by which to discount the price
+      # intervals this adjustment applies to in a given billing period.
+      sig { returns(Float) }
+      attr_accessor :percentage_discount
+
+      # The plan phase in which this adjustment is active.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :plan_phase_order
+
+      # The reason for the adjustment.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :reason
+
+      sig do
+        params(
+          id: String,
+          adjustment_type:
+            Orb::PlanPhasePercentageDiscountAdjustment::AdjustmentType::OrSymbol,
+          applies_to_price_ids: T::Array[String],
+          filters: T::Array[Orb::TransformPriceFilter::OrHash],
+          is_invoice_level: T::Boolean,
+          percentage_discount: Float,
+          plan_phase_order: T.nilable(Integer),
+          reason: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        adjustment_type:,
+        # 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 percentage (as a value between 0 and 1) by which to discount the price
+        # intervals this adjustment applies to in a given billing period.
+        percentage_discount:,
+        # The plan phase in which this adjustment is active.
+        plan_phase_order:,
+        # The reason for the adjustment.
+        reason:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            adjustment_type:
+              Orb::PlanPhasePercentageDiscountAdjustment::AdjustmentType::TaggedSymbol,
+            applies_to_price_ids: T::Array[String],
+            filters: T::Array[Orb::TransformPriceFilter],
+            is_invoice_level: T::Boolean,
+            percentage_discount: Float,
+            plan_phase_order: T.nilable(Integer),
+            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::PlanPhasePercentageDiscountAdjustment::AdjustmentType
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PERCENTAGE_DISCOUNT =
+          T.let(
+            :percentage_discount,
+            Orb::PlanPhasePercentageDiscountAdjustment::AdjustmentType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Orb::PlanPhasePercentageDiscountAdjustment::AdjustmentType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/orb/models/plan_phase_usage_discount_adjustment.rbi

@@ -0,0 +1,125 @@
+# typed: strong
+
+module Orb
+  module Models
+    class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::PlanPhaseUsageDiscountAdjustment, Orb::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig do
+        returns(
+          Orb::PlanPhaseUsageDiscountAdjustment::AdjustmentType::TaggedSymbol
+        )
+      end
+      attr_accessor :adjustment_type
+
+      # 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 plan phase in which this adjustment is active.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :plan_phase_order
+
+      # The reason for the adjustment.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :reason
+
+      # The number of usage units by which to discount the price this adjustment applies
+      # to in a given billing period.
+      sig { returns(Float) }
+      attr_accessor :usage_discount
+
+      sig do
+        params(
+          id: String,
+          adjustment_type:
+            Orb::PlanPhaseUsageDiscountAdjustment::AdjustmentType::OrSymbol,
+          applies_to_price_ids: T::Array[String],
+          filters: T::Array[Orb::TransformPriceFilter::OrHash],
+          is_invoice_level: T::Boolean,
+          plan_phase_order: T.nilable(Integer),
+          reason: T.nilable(String),
+          usage_discount: Float
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        adjustment_type:,
+        # 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 plan phase in which this adjustment is active.
+        plan_phase_order:,
+        # The reason for the adjustment.
+        reason:,
+        # The number of usage units by which to discount the price this adjustment applies
+        # to in a given billing period.
+        usage_discount:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            adjustment_type:
+              Orb::PlanPhaseUsageDiscountAdjustment::AdjustmentType::TaggedSymbol,
+            applies_to_price_ids: T::Array[String],
+            filters: T::Array[Orb::TransformPriceFilter],
+            is_invoice_level: T::Boolean,
+            plan_phase_order: T.nilable(Integer),
+            reason: T.nilable(String),
+            usage_discount: Float
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module AdjustmentType
+        extend Orb::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Orb::PlanPhaseUsageDiscountAdjustment::AdjustmentType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        USAGE_DISCOUNT =
+          T.let(
+            :usage_discount,
+            Orb::PlanPhaseUsageDiscountAdjustment::AdjustmentType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Orb::PlanPhaseUsageDiscountAdjustment::AdjustmentType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end