orb-billing 0.12.0 → 1.0.1

data/rbi/orb/models/subscription_trial_info.rbi

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

data/rbi/orb/models/tax_amount.rbi

@@ -0,0 +1,50 @@
+# typed: strong
+
+module Orb
+  module Models
+    class TaxAmount < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::TaxAmount, Orb::Internal::AnyHash) }
+
+      # The amount of additional tax incurred by this tax rate.
+      sig { returns(String) }
+      attr_accessor :amount
+
+      # The human-readable description of the applied tax rate.
+      sig { returns(String) }
+      attr_accessor :tax_rate_description
+
+      # The tax rate percentage, out of 100.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :tax_rate_percentage
+
+      sig do
+        params(
+          amount: String,
+          tax_rate_description: String,
+          tax_rate_percentage: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The amount of additional tax incurred by this tax rate.
+        amount:,
+        # The human-readable description of the applied tax rate.
+        tax_rate_description:,
+        # The tax rate percentage, out of 100.
+        tax_rate_percentage:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            amount: String,
+            tax_rate_description: String,
+            tax_rate_percentage: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/threshold.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Orb
+  module Models
+    class Threshold < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::Threshold, Orb::Internal::AnyHash) }
+
+      # The value at which an alert will fire. For credit balance alerts, the alert will
+      # fire at or below this value. For usage and cost alerts, the alert will fire at
+      # or above this value.
+      sig { returns(Float) }
+      attr_accessor :value
+
+      # Thresholds are used to define the conditions under which an alert will be
+      # triggered.
+      sig { params(value: Float).returns(T.attached_class) }
+      def self.new(
+        # The value at which an alert will fire. For credit balance alerts, the alert will
+        # fire at or below this value. For usage and cost alerts, the alert will fire at
+        # or above this value.
+        value:
+      )
+      end
+
+      sig { override.returns({ value: Float }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/tier.rbi

@@ -0,0 +1,50 @@
+# typed: strong
+
+module Orb
+  module Models
+    class Tier < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::Tier, Orb::Internal::AnyHash) }
+
+      # Exclusive tier starting value
+      sig { returns(Float) }
+      attr_accessor :first_unit
+
+      # Amount per unit
+      sig { returns(String) }
+      attr_accessor :unit_amount
+
+      # Inclusive tier ending value. If null, this is treated as the last tier
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :last_unit
+
+      sig do
+        params(
+          first_unit: Float,
+          unit_amount: String,
+          last_unit: T.nilable(Float)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Exclusive tier starting value
+        first_unit:,
+        # Amount per unit
+        unit_amount:,
+        # Inclusive tier ending value. If null, this is treated as the last tier
+        last_unit: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            first_unit: Float,
+            unit_amount: String,
+            last_unit: T.nilable(Float)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/tier_config.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Orb
+  module Models
+    class TierConfig < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::TierConfig, Orb::Internal::AnyHash) }
+
+      sig { returns(Float) }
+      attr_accessor :first_unit
+
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :last_unit
+
+      sig { returns(String) }
+      attr_accessor :unit_amount
+
+      sig do
+        params(
+          first_unit: Float,
+          last_unit: T.nilable(Float),
+          unit_amount: String
+        ).returns(T.attached_class)
+      end
+      def self.new(first_unit:, last_unit:, unit_amount:)
+      end
+
+      sig do
+        override.returns(
+          {
+            first_unit: Float,
+            last_unit: T.nilable(Float),
+            unit_amount: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/tier_sub_line_item.rbi

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

data/rbi/orb/models/tiered_bps_config.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module Orb
+  module Models
+    class TieredBPSConfig < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Orb::TieredBPSConfig, Orb::Internal::AnyHash) }
+
+      # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified
+      # tiers
+      sig { returns(T::Array[Orb::BPSTier]) }
+      attr_accessor :tiers
+
+      sig do
+        params(tiers: T::Array[Orb::BPSTier::OrHash]).returns(T.attached_class)
+      end
+      def self.new(
+        # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified
+        # tiers
+        tiers:
+      )
+      end
+
+      sig { override.returns({ tiers: T::Array[Orb::BPSTier] }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/tiered_config.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module Orb
+  module Models
+    class TieredConfig < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::TieredConfig, Orb::Internal::AnyHash) }
+
+      # Tiers for rating based on total usage quantities into the specified tier
+      sig { returns(T::Array[Orb::Tier]) }
+      attr_accessor :tiers
+
+      sig do
+        params(tiers: T::Array[Orb::Tier::OrHash]).returns(T.attached_class)
+      end
+      def self.new(
+        # Tiers for rating based on total usage quantities into the specified tier
+        tiers:
+      )
+      end
+
+      sig { override.returns({ tiers: T::Array[Orb::Tier] }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/tiered_conversion_rate_config.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Orb
+  module Models
+    class TieredConversionRateConfig < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::TieredConversionRateConfig, Orb::Internal::AnyHash)
+        end
+
+      sig do
+        returns(Orb::TieredConversionRateConfig::ConversionRateType::OrSymbol)
+      end
+      attr_accessor :conversion_rate_type
+
+      sig { returns(Orb::ConversionRateTieredConfig) }
+      attr_reader :tiered_config
+
+      sig do
+        params(tiered_config: Orb::ConversionRateTieredConfig::OrHash).void
+      end
+      attr_writer :tiered_config
+
+      sig do
+        params(
+          conversion_rate_type:
+            Orb::TieredConversionRateConfig::ConversionRateType::OrSymbol,
+          tiered_config: Orb::ConversionRateTieredConfig::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(conversion_rate_type:, tiered_config:)
+      end
+
+      sig do
+        override.returns(
+          {
+            conversion_rate_type:
+              Orb::TieredConversionRateConfig::ConversionRateType::OrSymbol,
+            tiered_config: Orb::ConversionRateTieredConfig
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module ConversionRateType
+        extend Orb::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Orb::TieredConversionRateConfig::ConversionRateType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TIERED =
+          T.let(
+            :tiered,
+            Orb::TieredConversionRateConfig::ConversionRateType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Orb::TieredConversionRateConfig::ConversionRateType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/orb/models/transform_price_filter.rbi

@@ -0,0 +1,106 @@
+# typed: strong
+
+module Orb
+  module Models
+    class TransformPriceFilter < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::TransformPriceFilter, Orb::Internal::AnyHash)
+        end
+
+      # The property of the price to filter on.
+      sig { returns(Orb::TransformPriceFilter::Field::OrSymbol) }
+      attr_accessor :field
+
+      # Should prices that match the filter be included or excluded.
+      sig { returns(Orb::TransformPriceFilter::Operator::OrSymbol) }
+      attr_accessor :operator
+
+      # The IDs or values that match this filter.
+      sig { returns(T::Array[String]) }
+      attr_accessor :values
+
+      sig do
+        params(
+          field: Orb::TransformPriceFilter::Field::OrSymbol,
+          operator: Orb::TransformPriceFilter::Operator::OrSymbol,
+          values: T::Array[String]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The property of the price to filter on.
+        field:,
+        # Should prices that match the filter be included or excluded.
+        operator:,
+        # The IDs or values that match this filter.
+        values:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            field: Orb::TransformPriceFilter::Field::OrSymbol,
+            operator: Orb::TransformPriceFilter::Operator::OrSymbol,
+            values: T::Array[String]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The property of the price to filter on.
+      module Field
+        extend Orb::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Orb::TransformPriceFilter::Field) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PRICE_ID =
+          T.let(:price_id, Orb::TransformPriceFilter::Field::TaggedSymbol)
+        ITEM_ID =
+          T.let(:item_id, Orb::TransformPriceFilter::Field::TaggedSymbol)
+        PRICE_TYPE =
+          T.let(:price_type, Orb::TransformPriceFilter::Field::TaggedSymbol)
+        CURRENCY =
+          T.let(:currency, Orb::TransformPriceFilter::Field::TaggedSymbol)
+        PRICING_UNIT_ID =
+          T.let(
+            :pricing_unit_id,
+            Orb::TransformPriceFilter::Field::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Orb::TransformPriceFilter::Field::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # Should prices that match the filter be included or excluded.
+      module Operator
+        extend Orb::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Orb::TransformPriceFilter::Operator) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        INCLUDES =
+          T.let(:includes, Orb::TransformPriceFilter::Operator::TaggedSymbol)
+        EXCLUDES =
+          T.let(:excludes, Orb::TransformPriceFilter::Operator::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Orb::TransformPriceFilter::Operator::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/orb/models/trial_discount.rbi

@@ -15,7 +15,7 @@ module Orb
       attr_accessor :applies_to_price_ids
 
       # The filters that determine which prices to apply this discount to.
-      sig { returns(T.nilable(T::Array[Orb::TrialDiscount::Filter])) }
+      sig { returns(T.nilable(T::Array[Orb::TransformPriceFilter])) }
       attr_accessor :filters
 
       sig { returns(T.nilable(String)) }
@@ -33,7 +33,7 @@ module Orb
         params(
           discount_type: Orb::TrialDiscount::DiscountType::OrSymbol,
           applies_to_price_ids: T.nilable(T::Array[String]),
-          filters: T.nilable(T::Array[Orb::TrialDiscount::Filter::OrHash]),
+          filters: T.nilable(T::Array[Orb::TransformPriceFilter::OrHash]),
           reason: T.nilable(String),
           trial_amount_discount: T.nilable(String),
           trial_percentage_discount: T.nilable(Float)
@@ -59,7 +59,7 @@ module Orb
           {
             discount_type: Orb::TrialDiscount::DiscountType::OrSymbol,
             applies_to_price_ids: T.nilable(T::Array[String]),
-            filters: T.nilable(T::Array[Orb::TrialDiscount::Filter]),
+            filters: T.nilable(T::Array[Orb::TransformPriceFilter]),
             reason: T.nilable(String),
             trial_amount_discount: T.nilable(String),
             trial_percentage_discount: T.nilable(Float)
@@ -86,107 +86,6 @@ module Orb
         def self.values
         end
       end
-
-      class Filter < Orb::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Orb::TrialDiscount::Filter, Orb::Internal::AnyHash)
-          end
-
-        # The property of the price to filter on.
-        sig { returns(Orb::TrialDiscount::Filter::Field::OrSymbol) }
-        attr_accessor :field
-
-        # Should prices that match the filter be included or excluded.
-        sig { returns(Orb::TrialDiscount::Filter::Operator::OrSymbol) }
-        attr_accessor :operator
-
-        # The IDs or values that match this filter.
-        sig { returns(T::Array[String]) }
-        attr_accessor :values
-
-        sig do
-          params(
-            field: Orb::TrialDiscount::Filter::Field::OrSymbol,
-            operator: Orb::TrialDiscount::Filter::Operator::OrSymbol,
-            values: T::Array[String]
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The property of the price to filter on.
-          field:,
-          # Should prices that match the filter be included or excluded.
-          operator:,
-          # The IDs or values that match this filter.
-          values:
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              field: Orb::TrialDiscount::Filter::Field::OrSymbol,
-              operator: Orb::TrialDiscount::Filter::Operator::OrSymbol,
-              values: T::Array[String]
-            }
-          )
-        end
-        def to_hash
-        end
-
-        # The property of the price to filter on.
-        module Field
-          extend Orb::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias { T.all(Symbol, Orb::TrialDiscount::Filter::Field) }
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          PRICE_ID =
-            T.let(:price_id, Orb::TrialDiscount::Filter::Field::TaggedSymbol)
-          ITEM_ID =
-            T.let(:item_id, Orb::TrialDiscount::Filter::Field::TaggedSymbol)
-          PRICE_TYPE =
-            T.let(:price_type, Orb::TrialDiscount::Filter::Field::TaggedSymbol)
-          CURRENCY =
-            T.let(:currency, Orb::TrialDiscount::Filter::Field::TaggedSymbol)
-          PRICING_UNIT_ID =
-            T.let(
-              :pricing_unit_id,
-              Orb::TrialDiscount::Filter::Field::TaggedSymbol
-            )
-
-          sig do
-            override.returns(
-              T::Array[Orb::TrialDiscount::Filter::Field::TaggedSymbol]
-            )
-          end
-          def self.values
-          end
-        end
-
-        # Should prices that match the filter be included or excluded.
-        module Operator
-          extend Orb::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias { T.all(Symbol, Orb::TrialDiscount::Filter::Operator) }
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          INCLUDES =
-            T.let(:includes, Orb::TrialDiscount::Filter::Operator::TaggedSymbol)
-          EXCLUDES =
-            T.let(:excludes, Orb::TrialDiscount::Filter::Operator::TaggedSymbol)
-
-          sig do
-            override.returns(
-              T::Array[Orb::TrialDiscount::Filter::Operator::TaggedSymbol]
-            )
-          end
-          def self.values
-          end
-        end
-      end
     end
   end
 end

data/rbi/orb/models/unit_config.rbi

@@ -0,0 +1,24 @@
+# typed: strong
+
+module Orb
+  module Models
+    class UnitConfig < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::UnitConfig, Orb::Internal::AnyHash) }
+
+      # Rate per unit of usage
+      sig { returns(String) }
+      attr_accessor :unit_amount
+
+      sig { params(unit_amount: String).returns(T.attached_class) }
+      def self.new(
+        # Rate per unit of usage
+        unit_amount:
+      )
+      end
+
+      sig { override.returns({ unit_amount: String }) }
+      def to_hash
+      end
+    end
+  end
+end