orb-billing 0.3.1 → 0.3.2

data/rbi/orb/models/alert.rbi

@@ -3,6 +3,8 @@
 module Orb
   module Models
     class Alert < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       # Also referred to as alert_id in this documentation.
       sig { returns(String) }
       attr_accessor :id
@@ -16,10 +18,10 @@ module Orb
       attr_accessor :currency
 
       # The customer the alert applies to.
-      sig { returns(T.nilable(Orb::Models::Alert::Customer)) }
+      sig { returns(T.nilable(Orb::Alert::Customer)) }
       attr_reader :customer
 
-      sig { params(customer: T.nilable(T.any(Orb::Models::Alert::Customer, Orb::Internal::AnyHash))).void }
+      sig { params(customer: T.nilable(Orb::Alert::Customer::OrHash)).void }
       attr_writer :customer
 
       # Whether the alert is enabled or disabled.
@@ -27,33 +29,35 @@ module Orb
       attr_accessor :enabled
 
       # The metric the alert applies to.
-      sig { returns(T.nilable(Orb::Models::Alert::Metric)) }
+      sig { returns(T.nilable(Orb::Alert::Metric)) }
       attr_reader :metric
 
-      sig { params(metric: T.nilable(T.any(Orb::Models::Alert::Metric, Orb::Internal::AnyHash))).void }
+      sig { params(metric: T.nilable(Orb::Alert::Metric::OrHash)).void }
       attr_writer :metric
 
       # The plan the alert applies to.
-      sig { returns(T.nilable(Orb::Models::Alert::Plan)) }
+      sig { returns(T.nilable(Orb::Alert::Plan)) }
       attr_reader :plan
 
-      sig { params(plan: T.nilable(T.any(Orb::Models::Alert::Plan, Orb::Internal::AnyHash))).void }
+      sig { params(plan: T.nilable(Orb::Alert::Plan::OrHash)).void }
       attr_writer :plan
 
       # The subscription the alert applies to.
-      sig { returns(T.nilable(Orb::Models::Alert::Subscription)) }
+      sig { returns(T.nilable(Orb::Alert::Subscription)) }
       attr_reader :subscription
 
-      sig { params(subscription: T.nilable(T.any(Orb::Models::Alert::Subscription, Orb::Internal::AnyHash))).void }
+      sig do
+        params(subscription: T.nilable(Orb::Alert::Subscription::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::Models::Alert::Threshold])) }
+      sig { returns(T.nilable(T::Array[Orb::Alert::Threshold])) }
       attr_accessor :thresholds
 
       # The type of alert. This must be a valid alert type.
-      sig { returns(Orb::Models::Alert::Type::TaggedSymbol) }
+      sig { returns(Orb::Alert::Type::TaggedSymbol) }
       attr_accessor :type
 
       # [Alerts within Orb](/product-catalog/configuring-alerts) monitor spending,
@@ -66,15 +70,14 @@ module Orb
           id: String,
           created_at: Time,
           currency: T.nilable(String),
-          customer: T.nilable(T.any(Orb::Models::Alert::Customer, Orb::Internal::AnyHash)),
+          customer: T.nilable(Orb::Alert::Customer::OrHash),
           enabled: T::Boolean,
-          metric: T.nilable(T.any(Orb::Models::Alert::Metric, Orb::Internal::AnyHash)),
-          plan: T.nilable(T.any(Orb::Models::Alert::Plan, Orb::Internal::AnyHash)),
-          subscription: T.nilable(T.any(Orb::Models::Alert::Subscription, Orb::Internal::AnyHash)),
-          thresholds: T.nilable(T::Array[T.any(Orb::Models::Alert::Threshold, Orb::Internal::AnyHash)]),
-          type: Orb::Models::Alert::Type::OrSymbol
-        )
-          .returns(T.attached_class)
+          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]),
+          type: Orb::Alert::Type::OrSymbol
+        ).returns(T.attached_class)
       end
       def self.new(
         # Also referred to as alert_id in this documentation.
@@ -98,27 +101,31 @@ module Orb
         thresholds:,
         # The type of alert. This must be a valid alert type.
         type:
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              id: String,
-              created_at: Time,
-              currency: T.nilable(String),
-              customer: T.nilable(Orb::Models::Alert::Customer),
-              enabled: T::Boolean,
-              metric: T.nilable(Orb::Models::Alert::Metric),
-              plan: T.nilable(Orb::Models::Alert::Plan),
-              subscription: T.nilable(Orb::Models::Alert::Subscription),
-              thresholds: T.nilable(T::Array[Orb::Models::Alert::Threshold]),
-              type: Orb::Models::Alert::Type::TaggedSymbol
-            }
-          )
+        override.returns(
+          {
+            id: String,
+            created_at: Time,
+            currency: T.nilable(String),
+            customer: T.nilable(Orb::Alert::Customer),
+            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]),
+            type: Orb::Alert::Type::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       class Customer < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         sig { returns(String) }
         attr_accessor :id
 
@@ -126,26 +133,42 @@ module Orb
         attr_accessor :external_customer_id
 
         # The customer the alert applies to.
-        sig { params(id: String, external_customer_id: T.nilable(String)).returns(T.attached_class) }
-        def self.new(id:, external_customer_id:); end
+        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 { override.returns({id: String, external_customer_id: T.nilable(String)}) }
-        def to_hash; 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(T.self_type, Orb::Internal::AnyHash) }
+
         sig { returns(String) }
         attr_accessor :id
 
         # The metric the alert applies to.
         sig { params(id: String).returns(T.attached_class) }
-        def self.new(id:); end
+        def self.new(id:)
+        end
 
-        sig { override.returns({id: String}) }
-        def to_hash; end
+        sig { override.returns({ id: String }) }
+        def to_hash
+        end
       end
 
       class Plan < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         sig { returns(T.nilable(String)) }
         attr_accessor :id
 
@@ -168,8 +191,7 @@ module Orb
             external_plan_id: T.nilable(String),
             name: T.nilable(String),
             plan_version: String
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           id:,
@@ -179,34 +201,42 @@ module Orb
           external_plan_id:,
           name:,
           plan_version:
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                id: T.nilable(String),
-                external_plan_id: T.nilable(String),
-                name: T.nilable(String),
-                plan_version: String
-              }
-            )
+          override.returns(
+            {
+              id: T.nilable(String),
+              external_plan_id: T.nilable(String),
+              name: T.nilable(String),
+              plan_version: String
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
 
       class Subscription < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         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
+        def self.new(id:)
+        end
 
-        sig { override.returns({id: String}) }
-        def to_hash; end
+        sig { override.returns({ id: String }) }
+        def to_hash
+        end
       end
 
       class Threshold < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, 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.
@@ -221,26 +251,33 @@ module Orb
           # 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
+
+        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
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Alert::Type) }
+        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Alert::Type) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        CREDIT_BALANCE_DEPLETED = T.let(:credit_balance_depleted, Orb::Models::Alert::Type::TaggedSymbol)
-        CREDIT_BALANCE_DROPPED = T.let(:credit_balance_dropped, Orb::Models::Alert::Type::TaggedSymbol)
-        CREDIT_BALANCE_RECOVERED = T.let(:credit_balance_recovered, Orb::Models::Alert::Type::TaggedSymbol)
-        USAGE_EXCEEDED = T.let(:usage_exceeded, Orb::Models::Alert::Type::TaggedSymbol)
-        COST_EXCEEDED = T.let(:cost_exceeded, Orb::Models::Alert::Type::TaggedSymbol)
-
-        sig { override.returns(T::Array[Orb::Models::Alert::Type::TaggedSymbol]) }
-        def self.values; end
+        CREDIT_BALANCE_DEPLETED =
+          T.let(:credit_balance_depleted, Orb::Alert::Type::TaggedSymbol)
+        CREDIT_BALANCE_DROPPED =
+          T.let(:credit_balance_dropped, Orb::Alert::Type::TaggedSymbol)
+        CREDIT_BALANCE_RECOVERED =
+          T.let(:credit_balance_recovered, Orb::Alert::Type::TaggedSymbol)
+        USAGE_EXCEEDED = T.let(:usage_exceeded, Orb::Alert::Type::TaggedSymbol)
+        COST_EXCEEDED = T.let(:cost_exceeded, Orb::Alert::Type::TaggedSymbol)
+
+        sig { override.returns(T::Array[Orb::Alert::Type::TaggedSymbol]) }
+        def self.values
+        end
       end
     end
   end

data/rbi/orb/models/alert_create_for_customer_params.rbi

@@ -6,26 +6,34 @@ module Orb
       extend Orb::Internal::Type::RequestParameters::Converter
       include Orb::Internal::Type::RequestParameters
 
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       # The case sensitive currency or custom pricing unit to use for this alert.
       sig { returns(String) }
       attr_accessor :currency
 
       # The type of alert to create. This must be a valid alert type.
-      sig { returns(Orb::Models::AlertCreateForCustomerParams::Type::OrSymbol) }
+      sig { returns(Orb::AlertCreateForCustomerParams::Type::OrSymbol) }
       attr_accessor :type
 
       # The thresholds that define the values at which the alert will be triggered.
-      sig { returns(T.nilable(T::Array[Orb::Models::AlertCreateForCustomerParams::Threshold])) }
+      sig do
+        returns(
+          T.nilable(T::Array[Orb::AlertCreateForCustomerParams::Threshold])
+        )
+      end
       attr_accessor :thresholds
 
       sig do
         params(
           currency: String,
-          type: Orb::Models::AlertCreateForCustomerParams::Type::OrSymbol,
-          thresholds: T.nilable(T::Array[T.any(Orb::Models::AlertCreateForCustomerParams::Threshold, Orb::Internal::AnyHash)]),
-          request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          type: Orb::AlertCreateForCustomerParams::Type::OrSymbol,
+          thresholds:
+            T.nilable(
+              T::Array[Orb::AlertCreateForCustomerParams::Threshold::OrHash]
+            ),
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # The case sensitive currency or custom pricing unit to use for this alert.
@@ -35,39 +43,61 @@ module Orb
         # The thresholds that define the values at which the alert will be triggered.
         thresholds: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              currency: String,
-              type: Orb::Models::AlertCreateForCustomerParams::Type::OrSymbol,
-              thresholds: T.nilable(T::Array[Orb::Models::AlertCreateForCustomerParams::Threshold]),
-              request_options: Orb::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            currency: String,
+            type: Orb::AlertCreateForCustomerParams::Type::OrSymbol,
+            thresholds:
+              T.nilable(T::Array[Orb::AlertCreateForCustomerParams::Threshold]),
+            request_options: Orb::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       # The type of alert to create. This must be a valid alert type.
       module Type
         extend Orb::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::AlertCreateForCustomerParams::Type) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Orb::AlertCreateForCustomerParams::Type)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         CREDIT_BALANCE_DEPLETED =
-          T.let(:credit_balance_depleted, Orb::Models::AlertCreateForCustomerParams::Type::TaggedSymbol)
+          T.let(
+            :credit_balance_depleted,
+            Orb::AlertCreateForCustomerParams::Type::TaggedSymbol
+          )
         CREDIT_BALANCE_DROPPED =
-          T.let(:credit_balance_dropped, Orb::Models::AlertCreateForCustomerParams::Type::TaggedSymbol)
+          T.let(
+            :credit_balance_dropped,
+            Orb::AlertCreateForCustomerParams::Type::TaggedSymbol
+          )
         CREDIT_BALANCE_RECOVERED =
-          T.let(:credit_balance_recovered, Orb::Models::AlertCreateForCustomerParams::Type::TaggedSymbol)
+          T.let(
+            :credit_balance_recovered,
+            Orb::AlertCreateForCustomerParams::Type::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Orb::Models::AlertCreateForCustomerParams::Type::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[Orb::AlertCreateForCustomerParams::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
 
       class Threshold < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, 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.
@@ -82,9 +112,12 @@ module Orb
           # 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
+
+        sig { override.returns({ value: Float }) }
+        def to_hash
+        end
       end
     end
   end

data/rbi/orb/models/alert_create_for_external_customer_params.rbi

@@ -6,28 +6,38 @@ module Orb
       extend Orb::Internal::Type::RequestParameters::Converter
       include Orb::Internal::Type::RequestParameters
 
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       # The case sensitive currency or custom pricing unit to use for this alert.
       sig { returns(String) }
       attr_accessor :currency
 
       # The type of alert to create. This must be a valid alert type.
-      sig { returns(Orb::Models::AlertCreateForExternalCustomerParams::Type::OrSymbol) }
+      sig { returns(Orb::AlertCreateForExternalCustomerParams::Type::OrSymbol) }
       attr_accessor :type
 
       # The thresholds that define the values at which the alert will be triggered.
-      sig { returns(T.nilable(T::Array[Orb::Models::AlertCreateForExternalCustomerParams::Threshold])) }
+      sig do
+        returns(
+          T.nilable(
+            T::Array[Orb::AlertCreateForExternalCustomerParams::Threshold]
+          )
+        )
+      end
       attr_accessor :thresholds
 
       sig do
         params(
           currency: String,
-          type: Orb::Models::AlertCreateForExternalCustomerParams::Type::OrSymbol,
-          thresholds: T.nilable(
-            T::Array[T.any(Orb::Models::AlertCreateForExternalCustomerParams::Threshold, Orb::Internal::AnyHash)]
-          ),
-          request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          type: Orb::AlertCreateForExternalCustomerParams::Type::OrSymbol,
+          thresholds:
+            T.nilable(
+              T::Array[
+                Orb::AlertCreateForExternalCustomerParams::Threshold::OrHash
+              ]
+            ),
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # The case sensitive currency or custom pricing unit to use for this alert.
@@ -37,39 +47,65 @@ module Orb
         # The thresholds that define the values at which the alert will be triggered.
         thresholds: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              currency: String,
-              type: Orb::Models::AlertCreateForExternalCustomerParams::Type::OrSymbol,
-              thresholds: T.nilable(T::Array[Orb::Models::AlertCreateForExternalCustomerParams::Threshold]),
-              request_options: Orb::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            currency: String,
+            type: Orb::AlertCreateForExternalCustomerParams::Type::OrSymbol,
+            thresholds:
+              T.nilable(
+                T::Array[Orb::AlertCreateForExternalCustomerParams::Threshold]
+              ),
+            request_options: Orb::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       # The type of alert to create. This must be a valid alert type.
       module Type
         extend Orb::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::AlertCreateForExternalCustomerParams::Type) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Orb::AlertCreateForExternalCustomerParams::Type)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         CREDIT_BALANCE_DEPLETED =
-          T.let(:credit_balance_depleted, Orb::Models::AlertCreateForExternalCustomerParams::Type::TaggedSymbol)
+          T.let(
+            :credit_balance_depleted,
+            Orb::AlertCreateForExternalCustomerParams::Type::TaggedSymbol
+          )
         CREDIT_BALANCE_DROPPED =
-          T.let(:credit_balance_dropped, Orb::Models::AlertCreateForExternalCustomerParams::Type::TaggedSymbol)
+          T.let(
+            :credit_balance_dropped,
+            Orb::AlertCreateForExternalCustomerParams::Type::TaggedSymbol
+          )
         CREDIT_BALANCE_RECOVERED =
-          T.let(:credit_balance_recovered, Orb::Models::AlertCreateForExternalCustomerParams::Type::TaggedSymbol)
+          T.let(
+            :credit_balance_recovered,
+            Orb::AlertCreateForExternalCustomerParams::Type::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Orb::Models::AlertCreateForExternalCustomerParams::Type::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Orb::AlertCreateForExternalCustomerParams::Type::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
       end
 
       class Threshold < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, 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.
@@ -84,9 +120,12 @@ module Orb
           # 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
+
+        sig { override.returns({ value: Float }) }
+        def to_hash
+        end
       end
     end
   end