orb-billing 0.1.0.pre.alpha.33

data/rbi/lib/orb/models/alert.rbi

@@ -0,0 +1,239 @@
+# typed: strong
+
+module Orb
+  module Models
+    class Alert < Orb::BaseModel
+      # Also referred to as alert_id in this documentation.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The creation time of the resource in Orb.
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # The name of the currency the credit balance or invoice cost is denominated in.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :currency
+
+      # The customer the alert applies to.
+      sig { returns(T.nilable(Orb::Models::Alert::Customer)) }
+      attr_reader :customer
+
+      sig { params(customer: T.nilable(T.any(Orb::Models::Alert::Customer, Orb::Util::AnyHash))).void }
+      attr_writer :customer
+
+      # Whether the alert is enabled or disabled.
+      sig { returns(T::Boolean) }
+      attr_accessor :enabled
+
+      # The metric the alert applies to.
+      sig { returns(T.nilable(Orb::Models::Alert::Metric)) }
+      attr_reader :metric
+
+      sig { params(metric: T.nilable(T.any(Orb::Models::Alert::Metric, Orb::Util::AnyHash))).void }
+      attr_writer :metric
+
+      # The plan the alert applies to.
+      sig { returns(T.nilable(Orb::Models::Alert::Plan)) }
+      attr_reader :plan
+
+      sig { params(plan: T.nilable(T.any(Orb::Models::Alert::Plan, Orb::Util::AnyHash))).void }
+      attr_writer :plan
+
+      # The subscription the alert applies to.
+      sig { returns(T.nilable(Orb::Models::Alert::Subscription)) }
+      attr_reader :subscription
+
+      sig { params(subscription: T.nilable(T.any(Orb::Models::Alert::Subscription, Orb::Util::AnyHash))).void }
+      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])) }
+      attr_accessor :thresholds
+
+      # The type of alert. This must be a valid alert type.
+      sig { returns(Orb::Models::Alert::Type::TaggedSymbol) }
+      attr_accessor :type
+
+      # [Alerts within Orb](/product-catalog/configuring-alerts) monitor spending,
+      #   usage, or credit balance and trigger webhooks when a threshold is exceeded.
+      #
+      #   Alerts created through the API can be scoped to either customers or
+      #   subscriptions.
+      sig do
+        params(
+          id: String,
+          created_at: Time,
+          currency: T.nilable(String),
+          customer: T.nilable(T.any(Orb::Models::Alert::Customer, Orb::Util::AnyHash)),
+          enabled: T::Boolean,
+          metric: T.nilable(T.any(Orb::Models::Alert::Metric, Orb::Util::AnyHash)),
+          plan: T.nilable(T.any(Orb::Models::Alert::Plan, Orb::Util::AnyHash)),
+          subscription: T.nilable(T.any(Orb::Models::Alert::Subscription, Orb::Util::AnyHash)),
+          thresholds: T.nilable(T::Array[T.any(Orb::Models::Alert::Threshold, Orb::Util::AnyHash)]),
+          type: Orb::Models::Alert::Type::OrSymbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        created_at:,
+        currency:,
+        customer:,
+        enabled:,
+        metric:,
+        plan:,
+        subscription:,
+        thresholds:,
+        type:
+      )
+      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
+            }
+          )
+      end
+      def to_hash
+      end
+
+      class Customer < Orb::BaseModel
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(T.nilable(String)) }
+        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 { override.returns({id: String, external_customer_id: T.nilable(String)}) }
+        def to_hash
+        end
+      end
+
+      class Metric < Orb::BaseModel
+        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
+
+        sig { override.returns({id: String}) }
+        def to_hash
+        end
+      end
+
+      class Plan < Orb::BaseModel
+        sig { returns(T.nilable(String)) }
+        attr_accessor :id
+
+        # An optional user-defined ID for this plan resource, used throughout the system
+        #   as an alias for this Plan. Use this field to identify a plan by an existing
+        #   identifier in your system.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :external_plan_id
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :name
+
+        sig { returns(String) }
+        attr_accessor :plan_version
+
+        # The plan the alert applies to.
+        sig do
+          params(
+            id: T.nilable(String),
+            external_plan_id: T.nilable(String),
+            name: T.nilable(String),
+            plan_version: String
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(id:, external_plan_id:, name:, plan_version:)
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                id: T.nilable(String),
+                external_plan_id: T.nilable(String),
+                name: T.nilable(String),
+                plan_version: String
+              }
+            )
+        end
+        def to_hash
+        end
+      end
+
+      class Subscription < Orb::BaseModel
+        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::BaseModel
+        # 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(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::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Alert::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Alert::Type::TaggedSymbol) }
+
+        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
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/alert_create_for_customer_params.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module Orb
+  module Models
+    class AlertCreateForCustomerParams < Orb::BaseModel
+      extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      # 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) }
+      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])) }
+      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::Util::AnyHash)]),
+          request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(currency:, type:, thresholds: nil, request_options: {})
+      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
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # The type of alert to create. This must be a valid alert type.
+      module Type
+        extend Orb::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::AlertCreateForCustomerParams::Type) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, Orb::Models::AlertCreateForCustomerParams::Type::TaggedSymbol) }
+
+        CREDIT_BALANCE_DEPLETED =
+          T.let(:credit_balance_depleted, Orb::Models::AlertCreateForCustomerParams::Type::TaggedSymbol)
+        CREDIT_BALANCE_DROPPED =
+          T.let(:credit_balance_dropped, Orb::Models::AlertCreateForCustomerParams::Type::TaggedSymbol)
+        CREDIT_BALANCE_RECOVERED =
+          T.let(:credit_balance_recovered, Orb::Models::AlertCreateForCustomerParams::Type::TaggedSymbol)
+
+        sig { override.returns(T::Array[Orb::Models::AlertCreateForCustomerParams::Type::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      class Threshold < Orb::BaseModel
+        # 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(value:)
+        end
+
+        sig { override.returns({value: Float}) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/alert_create_for_external_customer_params.rbi

@@ -0,0 +1,88 @@
+# typed: strong
+
+module Orb
+  module Models
+    class AlertCreateForExternalCustomerParams < Orb::BaseModel
+      extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      # 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) }
+      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])) }
+      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::Util::AnyHash)]
+          ),
+          request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(currency:, type:, thresholds: nil, request_options: {})
+      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
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # The type of alert to create. This must be a valid alert type.
+      module Type
+        extend Orb::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::AlertCreateForExternalCustomerParams::Type) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, Orb::Models::AlertCreateForExternalCustomerParams::Type::TaggedSymbol) }
+
+        CREDIT_BALANCE_DEPLETED =
+          T.let(:credit_balance_depleted, Orb::Models::AlertCreateForExternalCustomerParams::Type::TaggedSymbol)
+        CREDIT_BALANCE_DROPPED =
+          T.let(:credit_balance_dropped, Orb::Models::AlertCreateForExternalCustomerParams::Type::TaggedSymbol)
+        CREDIT_BALANCE_RECOVERED =
+          T.let(:credit_balance_recovered, Orb::Models::AlertCreateForExternalCustomerParams::Type::TaggedSymbol)
+
+        sig { override.returns(T::Array[Orb::Models::AlertCreateForExternalCustomerParams::Type::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      class Threshold < Orb::BaseModel
+        # 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(value:)
+        end
+
+        sig { override.returns({value: Float}) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/alert_create_for_subscription_params.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module Orb
+  module Models
+    class AlertCreateForSubscriptionParams < Orb::BaseModel
+      extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      # The thresholds that define the values at which the alert will be triggered.
+      sig { returns(T::Array[Orb::Models::AlertCreateForSubscriptionParams::Threshold]) }
+      attr_accessor :thresholds
+
+      # The type of alert to create. This must be a valid alert type.
+      sig { returns(Orb::Models::AlertCreateForSubscriptionParams::Type::OrSymbol) }
+      attr_accessor :type
+
+      # The metric to track usage for.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :metric_id
+
+      sig do
+        params(
+          thresholds: T::Array[T.any(Orb::Models::AlertCreateForSubscriptionParams::Threshold, Orb::Util::AnyHash)],
+          type: Orb::Models::AlertCreateForSubscriptionParams::Type::OrSymbol,
+          metric_id: T.nilable(String),
+          request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(thresholds:, type:, metric_id: nil, request_options: {})
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              thresholds: T::Array[Orb::Models::AlertCreateForSubscriptionParams::Threshold],
+              type: Orb::Models::AlertCreateForSubscriptionParams::Type::OrSymbol,
+              metric_id: T.nilable(String),
+              request_options: Orb::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+
+      class Threshold < Orb::BaseModel
+        # 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(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::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::AlertCreateForSubscriptionParams::Type) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, Orb::Models::AlertCreateForSubscriptionParams::Type::TaggedSymbol) }
+
+        USAGE_EXCEEDED =
+          T.let(:usage_exceeded, Orb::Models::AlertCreateForSubscriptionParams::Type::TaggedSymbol)
+        COST_EXCEEDED = T.let(:cost_exceeded, Orb::Models::AlertCreateForSubscriptionParams::Type::TaggedSymbol)
+
+        sig { override.returns(T::Array[Orb::Models::AlertCreateForSubscriptionParams::Type::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/alert_disable_params.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+
+module Orb
+  module Models
+    class AlertDisableParams < Orb::BaseModel
+      extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      # Used to update the status of a plan alert scoped to this subscription_id
+      sig { returns(T.nilable(String)) }
+      attr_accessor :subscription_id
+
+      sig do
+        params(
+          subscription_id: T.nilable(String),
+          request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(subscription_id: nil, request_options: {})
+      end
+
+      sig { override.returns({subscription_id: T.nilable(String), request_options: Orb::RequestOptions}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/alert_enable_params.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+
+module Orb
+  module Models
+    class AlertEnableParams < Orb::BaseModel
+      extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      # Used to update the status of a plan alert scoped to this subscription_id
+      sig { returns(T.nilable(String)) }
+      attr_accessor :subscription_id
+
+      sig do
+        params(
+          subscription_id: T.nilable(String),
+          request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(subscription_id: nil, request_options: {})
+      end
+
+      sig { override.returns({subscription_id: T.nilable(String), request_options: Orb::RequestOptions}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/alert_list_params.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module Orb
+  module Models
+    class AlertListParams < Orb::BaseModel
+      extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :created_at_gt
+
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :created_at_gte
+
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :created_at_lt
+
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :created_at_lte
+
+      # Cursor for pagination. This can be populated by the `next_cursor` value returned
+      #   from the initial request.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :cursor
+
+      # Fetch alerts scoped to this customer_id
+      sig { returns(T.nilable(String)) }
+      attr_accessor :customer_id
+
+      # Fetch alerts scoped to this external_customer_id
+      sig { returns(T.nilable(String)) }
+      attr_accessor :external_customer_id
+
+      # The number of items to fetch. Defaults to 20.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      # Fetch alerts scoped to this subscription_id
+      sig { returns(T.nilable(String)) }
+      attr_accessor :subscription_id
+
+      sig do
+        params(
+          created_at_gt: T.nilable(Time),
+          created_at_gte: T.nilable(Time),
+          created_at_lt: T.nilable(Time),
+          created_at_lte: T.nilable(Time),
+          cursor: T.nilable(String),
+          customer_id: T.nilable(String),
+          external_customer_id: T.nilable(String),
+          limit: Integer,
+          subscription_id: T.nilable(String),
+          request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        created_at_gt: nil,
+        created_at_gte: nil,
+        created_at_lt: nil,
+        created_at_lte: nil,
+        cursor: nil,
+        customer_id: nil,
+        external_customer_id: nil,
+        limit: nil,
+        subscription_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              created_at_gt: T.nilable(Time),
+              created_at_gte: T.nilable(Time),
+              created_at_lt: T.nilable(Time),
+              created_at_lte: T.nilable(Time),
+              cursor: T.nilable(String),
+              customer_id: T.nilable(String),
+              external_customer_id: T.nilable(String),
+              limit: Integer,
+              subscription_id: T.nilable(String),
+              request_options: Orb::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/alert_retrieve_params.rbi

@@ -0,0 +1,20 @@
+# typed: strong
+
+module Orb
+  module Models
+    class AlertRetrieveParams < Orb::BaseModel
+      extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      sig do
+        params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class)
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({request_options: Orb::RequestOptions}) }
+      def to_hash
+      end
+    end
+  end
+end