orb-billing 0.11.0 → 1.0.0

data/rbi/orb/models/alert.rbi

@@ -18,10 +18,10 @@ module Orb
       attr_accessor :currency
 
       # The customer the alert applies to.
-      sig { returns(T.nilable(Orb::Alert::Customer)) }
+      sig { returns(T.nilable(Orb::CustomerMinified)) }
       attr_reader :customer
 
-      sig { params(customer: T.nilable(Orb::Alert::Customer::OrHash)).void }
+      sig { params(customer: T.nilable(Orb::CustomerMinified::OrHash)).void }
       attr_writer :customer
 
       # Whether the alert is enabled or disabled.
@@ -43,17 +43,17 @@ module Orb
       attr_writer :plan
 
       # The subscription the alert applies to.
-      sig { returns(T.nilable(Orb::Alert::Subscription)) }
+      sig { returns(T.nilable(Orb::SubscriptionMinified)) }
       attr_reader :subscription
 
       sig do
-        params(subscription: T.nilable(Orb::Alert::Subscription::OrHash)).void
+        params(subscription: T.nilable(Orb::SubscriptionMinified::OrHash)).void
       end
       attr_writer :subscription
 
       # The thresholds that define the conditions under which the alert will be
       # triggered.
-      sig { returns(T.nilable(T::Array[Orb::Alert::Threshold])) }
+      sig { returns(T.nilable(T::Array[Orb::Threshold])) }
       attr_accessor :thresholds
 
       # The type of alert. This must be a valid alert type.
@@ -75,12 +75,12 @@ module Orb
           id: String,
           created_at: Time,
           currency: T.nilable(String),
-          customer: T.nilable(Orb::Alert::Customer::OrHash),
+          customer: T.nilable(Orb::CustomerMinified::OrHash),
           enabled: T::Boolean,
           metric: T.nilable(Orb::Alert::Metric::OrHash),
           plan: T.nilable(Orb::Alert::Plan::OrHash),
-          subscription: T.nilable(Orb::Alert::Subscription::OrHash),
-          thresholds: T.nilable(T::Array[Orb::Alert::Threshold::OrHash]),
+          subscription: T.nilable(Orb::SubscriptionMinified::OrHash),
+          thresholds: T.nilable(T::Array[Orb::Threshold::OrHash]),
           type: Orb::Alert::Type::OrSymbol,
           balance_alert_status:
             T.nilable(T::Array[Orb::Alert::BalanceAlertStatus::OrHash])
@@ -120,12 +120,12 @@ module Orb
             id: String,
             created_at: Time,
             currency: T.nilable(String),
-            customer: T.nilable(Orb::Alert::Customer),
+            customer: T.nilable(Orb::CustomerMinified),
             enabled: T::Boolean,
             metric: T.nilable(Orb::Alert::Metric),
             plan: T.nilable(Orb::Alert::Plan),
-            subscription: T.nilable(Orb::Alert::Subscription),
-            thresholds: T.nilable(T::Array[Orb::Alert::Threshold]),
+            subscription: T.nilable(Orb::SubscriptionMinified),
+            thresholds: T.nilable(T::Array[Orb::Threshold]),
             type: Orb::Alert::Type::TaggedSymbol,
             balance_alert_status:
               T.nilable(T::Array[Orb::Alert::BalanceAlertStatus])
@@ -135,34 +135,6 @@ module Orb
       def to_hash
       end
 
-      class Customer < Orb::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias { T.any(Orb::Alert::Customer, Orb::Internal::AnyHash) }
-
-        sig { returns(String) }
-        attr_accessor :id
-
-        sig { returns(T.nilable(String)) }
-        attr_accessor :external_customer_id
-
-        # The customer the alert applies to.
-        sig do
-          params(id: String, external_customer_id: T.nilable(String)).returns(
-            T.attached_class
-          )
-        end
-        def self.new(id:, external_customer_id:)
-        end
-
-        sig do
-          override.returns(
-            { id: String, external_customer_id: T.nilable(String) }
-          )
-        end
-        def to_hash
-        end
-      end
-
       class Metric < Orb::Internal::Type::BaseModel
         OrHash =
           T.type_alias { T.any(Orb::Alert::Metric, Orb::Internal::AnyHash) }
@@ -233,51 +205,6 @@ module Orb
         end
       end
 
-      class Subscription < Orb::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Orb::Alert::Subscription, Orb::Internal::AnyHash)
-          end
-
-        sig { returns(String) }
-        attr_accessor :id
-
-        # The subscription the alert applies to.
-        sig { params(id: String).returns(T.attached_class) }
-        def self.new(id:)
-        end
-
-        sig { override.returns({ id: String }) }
-        def to_hash
-        end
-      end
-
-      class Threshold < Orb::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias { T.any(Orb::Alert::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
-
       # The type of alert. This must be a valid alert type.
       module Type
         extend Orb::Internal::Type::Enum

data/rbi/orb/models/alert_create_for_customer_params.rbi

@@ -20,21 +20,14 @@ module Orb
       attr_accessor :type
 
       # The thresholds that define the values at which the alert will be triggered.
-      sig do
-        returns(
-          T.nilable(T::Array[Orb::AlertCreateForCustomerParams::Threshold])
-        )
-      end
+      sig { returns(T.nilable(T::Array[Orb::Threshold])) }
       attr_accessor :thresholds
 
       sig do
         params(
           currency: String,
           type: Orb::AlertCreateForCustomerParams::Type::OrSymbol,
-          thresholds:
-            T.nilable(
-              T::Array[Orb::AlertCreateForCustomerParams::Threshold::OrHash]
-            ),
+          thresholds: T.nilable(T::Array[Orb::Threshold::OrHash]),
           request_options: Orb::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
@@ -54,8 +47,7 @@ module Orb
           {
             currency: String,
             type: Orb::AlertCreateForCustomerParams::Type::OrSymbol,
-            thresholds:
-              T.nilable(T::Array[Orb::AlertCreateForCustomerParams::Threshold]),
+            thresholds: T.nilable(T::Array[Orb::Threshold]),
             request_options: Orb::RequestOptions
           }
         )
@@ -97,37 +89,6 @@ module Orb
         def self.values
         end
       end
-
-      class Threshold < Orb::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Orb::AlertCreateForCustomerParams::Threshold,
-              Orb::Internal::AnyHash
-            )
-          end
-
-        # 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
 end

data/rbi/orb/models/alert_create_for_external_customer_params.rbi

@@ -23,25 +23,14 @@ module Orb
       attr_accessor :type
 
       # The thresholds that define the values at which the alert will be triggered.
-      sig do
-        returns(
-          T.nilable(
-            T::Array[Orb::AlertCreateForExternalCustomerParams::Threshold]
-          )
-        )
-      end
+      sig { returns(T.nilable(T::Array[Orb::Threshold])) }
       attr_accessor :thresholds
 
       sig do
         params(
           currency: String,
           type: Orb::AlertCreateForExternalCustomerParams::Type::OrSymbol,
-          thresholds:
-            T.nilable(
-              T::Array[
-                Orb::AlertCreateForExternalCustomerParams::Threshold::OrHash
-              ]
-            ),
+          thresholds: T.nilable(T::Array[Orb::Threshold::OrHash]),
           request_options: Orb::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
@@ -61,10 +50,7 @@ module Orb
           {
             currency: String,
             type: Orb::AlertCreateForExternalCustomerParams::Type::OrSymbol,
-            thresholds:
-              T.nilable(
-                T::Array[Orb::AlertCreateForExternalCustomerParams::Threshold]
-              ),
+            thresholds: T.nilable(T::Array[Orb::Threshold]),
             request_options: Orb::RequestOptions
           }
         )
@@ -108,37 +94,6 @@ module Orb
         def self.values
         end
       end
-
-      class Threshold < Orb::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Orb::AlertCreateForExternalCustomerParams::Threshold,
-              Orb::Internal::AnyHash
-            )
-          end
-
-        # 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
 end

data/rbi/orb/models/alert_create_for_subscription_params.rbi

@@ -12,9 +12,7 @@ module Orb
         end
 
       # The thresholds that define the values at which the alert will be triggered.
-      sig do
-        returns(T::Array[Orb::AlertCreateForSubscriptionParams::Threshold])
-      end
+      sig { returns(T::Array[Orb::Threshold]) }
       attr_accessor :thresholds
 
       # The type of alert to create. This must be a valid alert type.
@@ -27,8 +25,7 @@ module Orb
 
       sig do
         params(
-          thresholds:
-            T::Array[Orb::AlertCreateForSubscriptionParams::Threshold::OrHash],
+          thresholds: T::Array[Orb::Threshold::OrHash],
           type: Orb::AlertCreateForSubscriptionParams::Type::OrSymbol,
           metric_id: T.nilable(String),
           request_options: Orb::RequestOptions::OrHash
@@ -48,8 +45,7 @@ module Orb
       sig do
         override.returns(
           {
-            thresholds:
-              T::Array[Orb::AlertCreateForSubscriptionParams::Threshold],
+            thresholds: T::Array[Orb::Threshold],
             type: Orb::AlertCreateForSubscriptionParams::Type::OrSymbol,
             metric_id: T.nilable(String),
             request_options: Orb::RequestOptions
@@ -59,37 +55,6 @@ module Orb
       def to_hash
       end
 
-      class Threshold < Orb::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Orb::AlertCreateForSubscriptionParams::Threshold,
-              Orb::Internal::AnyHash
-            )
-          end
-
-        # 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
-
       # The type of alert to create. This must be a valid alert type.
       module Type
         extend Orb::Internal::Type::Enum

data/rbi/orb/models/alert_update_params.rbi

@@ -10,12 +10,12 @@ module Orb
         T.type_alias { T.any(Orb::AlertUpdateParams, Orb::Internal::AnyHash) }
 
       # The thresholds that define the values at which the alert will be triggered.
-      sig { returns(T::Array[Orb::AlertUpdateParams::Threshold]) }
+      sig { returns(T::Array[Orb::Threshold]) }
       attr_accessor :thresholds
 
       sig do
         params(
-          thresholds: T::Array[Orb::AlertUpdateParams::Threshold::OrHash],
+          thresholds: T::Array[Orb::Threshold::OrHash],
           request_options: Orb::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
@@ -29,41 +29,13 @@ module Orb
       sig do
         override.returns(
           {
-            thresholds: T::Array[Orb::AlertUpdateParams::Threshold],
+            thresholds: T::Array[Orb::Threshold],
             request_options: Orb::RequestOptions
           }
         )
       end
       def to_hash
       end
-
-      class Threshold < Orb::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Orb::AlertUpdateParams::Threshold, Orb::Internal::AnyHash)
-          end
-
-        # 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
 end

data/rbi/orb/models/allocation.rbi

@@ -0,0 +1,45 @@
+# typed: strong
+
+module Orb
+  module Models
+    class Allocation < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::Allocation, Orb::Internal::AnyHash) }
+
+      sig { returns(T::Boolean) }
+      attr_accessor :allows_rollover
+
+      sig { returns(String) }
+      attr_accessor :currency
+
+      sig { returns(T.nilable(Orb::CustomExpiration)) }
+      attr_reader :custom_expiration
+
+      sig do
+        params(custom_expiration: T.nilable(Orb::CustomExpiration::OrHash)).void
+      end
+      attr_writer :custom_expiration
+
+      sig do
+        params(
+          allows_rollover: T::Boolean,
+          currency: String,
+          custom_expiration: T.nilable(Orb::CustomExpiration::OrHash)
+        ).returns(T.attached_class)
+      end
+      def self.new(allows_rollover:, currency:, custom_expiration:)
+      end
+
+      sig do
+        override.returns(
+          {
+            allows_rollover: T::Boolean,
+            currency: String,
+            custom_expiration: T.nilable(Orb::CustomExpiration)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/amount_discount.rbi

@@ -18,6 +18,10 @@ module Orb
       sig { returns(T.nilable(T::Array[String])) }
       attr_accessor :applies_to_price_ids
 
+      # The filters that determine which prices to apply this discount to.
+      sig { returns(T.nilable(T::Array[Orb::TransformPriceFilter])) }
+      attr_accessor :filters
+
       sig { returns(T.nilable(String)) }
       attr_accessor :reason
 
@@ -26,6 +30,7 @@ module Orb
           amount_discount: String,
           discount_type: Orb::AmountDiscount::DiscountType::OrSymbol,
           applies_to_price_ids: T.nilable(T::Array[String]),
+          filters: T.nilable(T::Array[Orb::TransformPriceFilter::OrHash]),
           reason: T.nilable(String)
         ).returns(T.attached_class)
       end
@@ -36,6 +41,8 @@ module Orb
         # List of price_ids that this discount applies to. For plan/plan phase discounts,
         # this can be a subset of prices.
         applies_to_price_ids: nil,
+        # The filters that determine which prices to apply this discount to.
+        filters: nil,
         reason: nil
       )
       end
@@ -46,6 +53,7 @@ module Orb
             amount_discount: String,
             discount_type: Orb::AmountDiscount::DiscountType::OrSymbol,
             applies_to_price_ids: T.nilable(T::Array[String]),
+            filters: T.nilable(T::Array[Orb::TransformPriceFilter]),
             reason: T.nilable(String)
           }
         )

data/rbi/orb/models/amount_discount_interval.rbi

@@ -0,0 +1,100 @@
+# typed: strong
+
+module Orb
+  module Models
+    class AmountDiscountInterval < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::AmountDiscountInterval, Orb::Internal::AnyHash)
+        end
+
+      # Only available if discount_type is `amount`.
+      sig { returns(String) }
+      attr_accessor :amount_discount
+
+      # The price interval ids that this discount interval applies to.
+      sig { returns(T::Array[String]) }
+      attr_accessor :applies_to_price_interval_ids
+
+      sig { returns(Orb::AmountDiscountInterval::DiscountType::TaggedSymbol) }
+      attr_accessor :discount_type
+
+      # The end date of the discount interval.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :end_date
+
+      # The filters that determine which prices this discount interval applies to.
+      sig { returns(T::Array[Orb::TransformPriceFilter]) }
+      attr_accessor :filters
+
+      # The start date of the discount interval.
+      sig { returns(Time) }
+      attr_accessor :start_date
+
+      sig do
+        params(
+          amount_discount: String,
+          applies_to_price_interval_ids: T::Array[String],
+          discount_type: Orb::AmountDiscountInterval::DiscountType::OrSymbol,
+          end_date: T.nilable(Time),
+          filters: T::Array[Orb::TransformPriceFilter::OrHash],
+          start_date: Time
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Only available if discount_type is `amount`.
+        amount_discount:,
+        # The price interval ids that this discount interval applies to.
+        applies_to_price_interval_ids:,
+        discount_type:,
+        # The end date of the discount interval.
+        end_date:,
+        # The filters that determine which prices this discount interval applies to.
+        filters:,
+        # The start date of the discount interval.
+        start_date:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            amount_discount: String,
+            applies_to_price_interval_ids: T::Array[String],
+            discount_type:
+              Orb::AmountDiscountInterval::DiscountType::TaggedSymbol,
+            end_date: T.nilable(Time),
+            filters: T::Array[Orb::TransformPriceFilter],
+            start_date: Time
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module DiscountType
+        extend Orb::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Orb::AmountDiscountInterval::DiscountType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        AMOUNT =
+          T.let(
+            :amount,
+            Orb::AmountDiscountInterval::DiscountType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Orb::AmountDiscountInterval::DiscountType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end