telnyx 5.171.0 → 5.173.0

data/rbi/telnyx/models/spend_limit.rbi

@@ -7,14 +7,15 @@ module Telnyx
         T.type_alias { T.any(Telnyx::SpendLimit, Telnyx::Internal::AnyHash) }
 
       # The active block of the period. `null` when the period is not blocked.
-      sig { returns(T.nilable(Telnyx::SpendLimit::Block)) }
+      sig { returns(T.nilable(Telnyx::SpendLimitBlock)) }
       attr_reader :block
 
-      sig { params(block: T.nilable(Telnyx::SpendLimit::Block::OrHash)).void }
+      sig { params(block: T.nilable(Telnyx::SpendLimitBlock::OrHash)).void }
       attr_writer :block
 
-      # The product is blocked for this period. Always `false` in write responses; list
-      # the limits to read the block state.
+      # The product is blocked for the whole account in this period (total limit). An
+      # API key's own block appears only in `credential_limits`. Always `false` in write
+      # responses; list the limits to read the block state.
       sig { returns(T::Boolean) }
       attr_accessor :blocked
 
@@ -63,6 +64,25 @@ module Telnyx
       sig { returns(T.nilable(String)) }
       attr_accessor :spend_usd
 
+      # In write responses, the API key the write was about; `null` for the total limit.
+      # Always `null` in list entries, which describe the total limit.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :credential_id
+
+      # List responses only. One item per API key limit of the product and period,
+      # sorted by `credential_id`, plus every API key that is still blocked. `[]` when
+      # there are none.
+      sig { returns(T.nilable(T::Array[Telnyx::SpendLimit::CredentialLimit])) }
+      attr_reader :credential_limits
+
+      sig do
+        params(
+          credential_limits:
+            T::Array[Telnyx::SpendLimit::CredentialLimit::OrHash]
+        ).void
+      end
+      attr_writer :credential_limits
+
       # What a create, update or delete did to the period at once. Only present in write
       # responses.
       sig { returns(T.nilable(Telnyx::SpendLimit::Evaluation)) }
@@ -71,10 +91,12 @@ module Telnyx
       sig { params(evaluation: Telnyx::SpendLimit::Evaluation::OrHash).void }
       attr_writer :evaluation
 
-      # The spend limit, spend and block state of one product and period.
+      # The spend limit, spend and block state of one product and period. The top-level
+      # fields describe the total limit of the account; API key limits are nested in
+      # `credential_limits`.
       sig do
         params(
-          block: T.nilable(Telnyx::SpendLimit::Block::OrHash),
+          block: T.nilable(Telnyx::SpendLimitBlock::OrHash),
           blocked: T::Boolean,
           effective_limit_usd: T.nilable(String),
           limit: T.nilable(Telnyx::SpendLimit::Limit::OrHash),
@@ -86,14 +108,18 @@ module Telnyx
           record_type: String,
           spend_error: T.nilable(String),
           spend_usd: T.nilable(String),
+          credential_id: T.nilable(String),
+          credential_limits:
+            T::Array[Telnyx::SpendLimit::CredentialLimit::OrHash],
           evaluation: Telnyx::SpendLimit::Evaluation::OrHash
         ).returns(T.attached_class)
       end
       def self.new(
         # The active block of the period. `null` when the period is not blocked.
         block:,
-        # The product is blocked for this period. Always `false` in write responses; list
-        # the limits to read the block state.
+        # The product is blocked for the whole account in this period (total limit). An
+        # API key's own block appears only in `credential_limits`. Always `false` in write
+        # responses; list the limits to read the block state.
         blocked:,
         # The limit in USD that is enforced, as a decimal string. `null` means unlimited.
         effective_limit_usd:,
@@ -117,6 +143,13 @@ module Telnyx
         # Spend in USD so far in the period, as a decimal string. It can lag actual usage
         # by about a minute. `null` when it could not be read.
         spend_usd:,
+        # In write responses, the API key the write was about; `null` for the total limit.
+        # Always `null` in list entries, which describe the total limit.
+        credential_id: nil,
+        # List responses only. One item per API key limit of the product and period,
+        # sorted by `credential_id`, plus every API key that is still blocked. `[]` when
+        # there are none.
+        credential_limits: nil,
         # What a create, update or delete did to the period at once. Only present in write
         # responses.
         evaluation: nil
@@ -126,7 +159,7 @@ module Telnyx
       sig do
         override.returns(
           {
-            block: T.nilable(Telnyx::SpendLimit::Block),
+            block: T.nilable(Telnyx::SpendLimitBlock),
             blocked: T::Boolean,
             effective_limit_usd: T.nilable(String),
             limit: T.nilable(Telnyx::SpendLimit::Limit),
@@ -138,6 +171,8 @@ module Telnyx
             record_type: String,
             spend_error: T.nilable(String),
             spend_usd: T.nilable(String),
+            credential_id: T.nilable(String),
+            credential_limits: T::Array[Telnyx::SpendLimit::CredentialLimit],
             evaluation: Telnyx::SpendLimit::Evaluation
           }
         )
@@ -145,65 +180,6 @@ module Telnyx
       def to_hash
       end
 
-      class Block < Telnyx::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Telnyx::SpendLimit::Block, Telnyx::Internal::AnyHash)
-          end
-
-        # Exclusive end of the block: it is lifted at 00:00 UTC on this date at the
-        # latest.
-        sig { returns(Date) }
-        attr_accessor :blocked_until
-
-        # When the block started.
-        sig { returns(Time) }
-        attr_accessor :detected_at
-
-        # The limit in USD that the spend went above, as a decimal string.
-        sig { returns(String) }
-        attr_accessor :limit_usd
-
-        # Spend in USD when the block started, as a decimal string.
-        sig { returns(String) }
-        attr_accessor :spend_usd
-
-        # The active block of the period. `null` when the period is not blocked.
-        sig do
-          params(
-            blocked_until: Date,
-            detected_at: Time,
-            limit_usd: String,
-            spend_usd: String
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # Exclusive end of the block: it is lifted at 00:00 UTC on this date at the
-          # latest.
-          blocked_until:,
-          # When the block started.
-          detected_at:,
-          # The limit in USD that the spend went above, as a decimal string.
-          limit_usd:,
-          # Spend in USD when the block started, as a decimal string.
-          spend_usd:
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              blocked_until: Date,
-              detected_at: Time,
-              limit_usd: String,
-              spend_usd: String
-            }
-          )
-        end
-        def to_hash
-        end
-      end
-
       class Limit < Telnyx::Internal::Type::BaseModel
         OrHash =
           T.type_alias do
@@ -290,6 +266,211 @@ module Telnyx
         end
       end
 
+      class CredentialLimit < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::SpendLimit::CredentialLimit,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        # The active block of the period. `null` when the period is not blocked.
+        sig { returns(T.nilable(Telnyx::SpendLimitBlock)) }
+        attr_reader :block
+
+        sig { params(block: T.nilable(Telnyx::SpendLimitBlock::OrHash)).void }
+        attr_writer :block
+
+        # This API key is blocked for the period.
+        sig { returns(T::Boolean) }
+        attr_accessor :blocked
+
+        # Identifier of the API key as recorded on usage. Never the key's secret.
+        sig { returns(String) }
+        attr_accessor :credential_id
+
+        # The limit of one API key. It always has an amount. `null` for an API key that is
+        # still blocked after its limit was removed.
+        sig { returns(T.nilable(Telnyx::SpendLimit::CredentialLimit::Limit)) }
+        attr_reader :limit
+
+        sig do
+          params(
+            limit: T.nilable(Telnyx::SpendLimit::CredentialLimit::Limit::OrHash)
+          ).void
+        end
+        attr_writer :limit
+
+        # Set when `spend_usd` is `null`.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :spend_error
+
+        # Spend in USD in the period made with exactly this API key, as a decimal string.
+        # Usage without an API key identifier, or with another one, counts only toward the
+        # total. `null` when it could not be read.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :spend_usd
+
+        # The API key's limit is above the period's total limit. Only a change by Telnyx
+        # support can cause it; the total limit still applies to the whole account. Lower
+        # the API key limit or raise the total.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :exceeds_total
+
+        sig { params(exceeds_total: T::Boolean).void }
+        attr_writer :exceeds_total
+
+        # The limit, spend and block state of one API key in the product and period.
+        sig do
+          params(
+            block: T.nilable(Telnyx::SpendLimitBlock::OrHash),
+            blocked: T::Boolean,
+            credential_id: String,
+            limit:
+              T.nilable(Telnyx::SpendLimit::CredentialLimit::Limit::OrHash),
+            spend_error: T.nilable(String),
+            spend_usd: T.nilable(String),
+            exceeds_total: T::Boolean
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The active block of the period. `null` when the period is not blocked.
+          block:,
+          # This API key is blocked for the period.
+          blocked:,
+          # Identifier of the API key as recorded on usage. Never the key's secret.
+          credential_id:,
+          # The limit of one API key. It always has an amount. `null` for an API key that is
+          # still blocked after its limit was removed.
+          limit:,
+          # Set when `spend_usd` is `null`.
+          spend_error:,
+          # Spend in USD in the period made with exactly this API key, as a decimal string.
+          # Usage without an API key identifier, or with another one, counts only toward the
+          # total. `null` when it could not be read.
+          spend_usd:,
+          # The API key's limit is above the period's total limit. Only a change by Telnyx
+          # support can cause it; the total limit still applies to the whole account. Lower
+          # the API key limit or raise the total.
+          exceeds_total: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              block: T.nilable(Telnyx::SpendLimitBlock),
+              blocked: T::Boolean,
+              credential_id: String,
+              limit: T.nilable(Telnyx::SpendLimit::CredentialLimit::Limit),
+              spend_error: T.nilable(String),
+              spend_usd: T.nilable(String),
+              exceeds_total: T::Boolean
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Limit < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::SpendLimit::CredentialLimit::Limit,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          # Limit in USD, as a decimal string.
+          sig { returns(String) }
+          attr_accessor :amount
+
+          # `self_service` when a user of the account set it, `operator` when Telnyx support
+          # did.
+          sig do
+            returns(
+              Telnyx::SpendLimit::CredentialLimit::Limit::Origin::TaggedSymbol
+            )
+          end
+          attr_accessor :origin
+
+          # When the limit was last set or changed.
+          sig { returns(Time) }
+          attr_accessor :updated_at
+
+          # The limit of one API key. It always has an amount. `null` for an API key that is
+          # still blocked after its limit was removed.
+          sig do
+            params(
+              amount: String,
+              origin:
+                Telnyx::SpendLimit::CredentialLimit::Limit::Origin::OrSymbol,
+              updated_at: Time
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Limit in USD, as a decimal string.
+            amount:,
+            # `self_service` when a user of the account set it, `operator` when Telnyx support
+            # did.
+            origin:,
+            # When the limit was last set or changed.
+            updated_at:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                amount: String,
+                origin:
+                  Telnyx::SpendLimit::CredentialLimit::Limit::Origin::TaggedSymbol,
+                updated_at: Time
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # `self_service` when a user of the account set it, `operator` when Telnyx support
+          # did.
+          module Origin
+            extend Telnyx::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Telnyx::SpendLimit::CredentialLimit::Limit::Origin
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            SELF_SERVICE =
+              T.let(
+                :self_service,
+                Telnyx::SpendLimit::CredentialLimit::Limit::Origin::TaggedSymbol
+              )
+            OPERATOR =
+              T.let(
+                :operator,
+                Telnyx::SpendLimit::CredentialLimit::Limit::Origin::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Telnyx::SpendLimit::CredentialLimit::Limit::Origin::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+
       class Evaluation < Telnyx::Internal::Type::BaseModel
         OrHash =
           T.type_alias do
@@ -315,7 +496,7 @@ module Telnyx
         attr_accessor :spend_usd
 
         # The other period has an active block, so the product stays blocked whatever this
-        # period's result.
+        # period's result. For an API key write, the API key's limit in the other period.
         sig { returns(T::Boolean) }
         attr_accessor :still_blocked_other_period
 
@@ -323,6 +504,14 @@ module Telnyx
         sig { returns(T::Boolean) }
         attr_accessor :still_over_limit
 
+        # API key writes only: the account itself remains blocked for the product under a
+        # total limit. Absent for total limit writes.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :account_blocked
+
+        sig { params(account_blocked: T::Boolean).void }
+        attr_writer :account_blocked
+
         # Additional information about the result, when there is any.
         sig { returns(T.nilable(String)) }
         attr_reader :note
@@ -340,6 +529,7 @@ module Telnyx
             spend_usd: T.nilable(String),
             still_blocked_other_period: T::Boolean,
             still_over_limit: T::Boolean,
+            account_blocked: T::Boolean,
             note: String
           ).returns(T.attached_class)
         end
@@ -355,10 +545,13 @@ module Telnyx
           # not checked.
           spend_usd:,
           # The other period has an active block, so the product stays blocked whatever this
-          # period's result.
+          # period's result. For an API key write, the API key's limit in the other period.
           still_blocked_other_period:,
           # A block of this period remains because the spend is still above the new limit.
           still_over_limit:,
+          # API key writes only: the account itself remains blocked for the product under a
+          # total limit. Absent for total limit writes.
+          account_blocked: nil,
           # Additional information about the result, when there is any.
           note: nil
         )
@@ -373,6 +566,7 @@ module Telnyx
               spend_usd: T.nilable(String),
               still_blocked_other_period: T::Boolean,
               still_over_limit: T::Boolean,
+              account_blocked: T::Boolean,
               note: String
             }
           )

data/rbi/telnyx/models/spend_limit_block.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    class SpendLimitBlock < Telnyx::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Telnyx::SpendLimitBlock, Telnyx::Internal::AnyHash)
+        end
+
+      # Exclusive end of the block: it is lifted at 00:00 UTC on this date at the
+      # latest.
+      sig { returns(Date) }
+      attr_accessor :blocked_until
+
+      # When the block started.
+      sig { returns(Time) }
+      attr_accessor :detected_at
+
+      # The limit in USD that the spend went above, as a decimal string.
+      sig { returns(String) }
+      attr_accessor :limit_usd
+
+      # Spend in USD when the block started, as a decimal string.
+      sig { returns(String) }
+      attr_accessor :spend_usd
+
+      # The active block of the period. `null` when the period is not blocked.
+      sig do
+        params(
+          blocked_until: Date,
+          detected_at: Time,
+          limit_usd: String,
+          spend_usd: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Exclusive end of the block: it is lifted at 00:00 UTC on this date at the
+        # latest.
+        blocked_until:,
+        # When the block started.
+        detected_at:,
+        # The limit in USD that the spend went above, as a decimal string.
+        limit_usd:,
+        # Spend in USD when the block started, as a decimal string.
+        spend_usd:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            blocked_until: Date,
+            detected_at: Time,
+            limit_usd: String,
+            spend_usd: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/telnyx/models/spend_limit_create_params.rbi

@@ -83,6 +83,13 @@ module Telnyx
           sig { returns(String) }
           attr_accessor :product
 
+          # Optional. Identifier of one API key as recorded on usage, never the key's
+          # secret: the limit then applies to that key only. Absent or `null` sets the total
+          # limit. A blank value, or one with control characters, is refused; it never means
+          # the total limit. An API key limit always has an `amount`.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :credential_id
+
           # `daily` is the current UTC day; `monthly` is the current UTC calendar month.
           sig { returns(T.nilable(Telnyx::SpendLimitPeriod::OrSymbol)) }
           attr_reader :period
@@ -120,6 +127,7 @@ module Telnyx
             params(
               amount: Float,
               product: String,
+              credential_id: T.nilable(String),
               period: Telnyx::SpendLimitPeriod::OrSymbol,
               reason: String,
               unlimited:
@@ -131,6 +139,11 @@ module Telnyx
             amount:,
             # Product to limit, as returned in `product` by the list operation.
             product:,
+            # Optional. Identifier of one API key as recorded on usage, never the key's
+            # secret: the limit then applies to that key only. Absent or `null` sets the total
+            # limit. A blank value, or one with control characters, is refused; it never means
+            # the total limit. An API key limit always has an `amount`.
+            credential_id: nil,
             # `daily` is the current UTC day; `monthly` is the current UTC calendar month.
             period: nil,
             # Why the limit is set or changed, kept for audit.
@@ -145,6 +158,7 @@ module Telnyx
               {
                 amount: Float,
                 product: String,
+                credential_id: T.nilable(String),
                 period: Telnyx::SpendLimitPeriod::OrSymbol,
                 reason: String,
                 unlimited:
@@ -221,7 +235,7 @@ module Telnyx
           sig { params(reason: String).void }
           attr_writer :reason
 
-          # Explicitly no cap.
+          # Explicitly no cap. Not available for API key limits.
           sig do
             params(
               product: String,

data/rbi/telnyx/models/spend_limit_delete_params.rbi

@@ -14,6 +14,15 @@ module Telnyx
       sig { returns(String) }
       attr_accessor :product
 
+      # Identifier of one API key as recorded on usage, never the key's secret,
+      # percent-encoded: the request is then about that key's limit. Absent means the
+      # total limit; present but blank is refused.
+      sig { returns(T.nilable(String)) }
+      attr_reader :credential_id
+
+      sig { params(credential_id: String).void }
+      attr_writer :credential_id
+
       # Limit period. Defaults to `daily`; send it explicitly.
       sig { returns(T.nilable(Telnyx::SpendLimitPeriod::OrSymbol)) }
       attr_reader :period
@@ -31,6 +40,7 @@ module Telnyx
       sig do
         params(
           product: String,
+          credential_id: String,
           period: Telnyx::SpendLimitPeriod::OrSymbol,
           reason: String,
           request_options: Telnyx::RequestOptions::OrHash
@@ -38,6 +48,10 @@ module Telnyx
       end
       def self.new(
         product:,
+        # Identifier of one API key as recorded on usage, never the key's secret,
+        # percent-encoded: the request is then about that key's limit. Absent means the
+        # total limit; present but blank is refused.
+        credential_id: nil,
         # Limit period. Defaults to `daily`; send it explicitly.
         period: nil,
         # Why the limit is removed, kept for audit. At most 500 characters.
@@ -50,6 +64,7 @@ module Telnyx
         override.returns(
           {
             product: String,
+            credential_id: String,
             period: Telnyx::SpendLimitPeriod::OrSymbol,
             reason: String,
             request_options: Telnyx::RequestOptions

data/rbi/telnyx/models/spend_limit_response.rbi

@@ -8,7 +8,9 @@ module Telnyx
           T.any(Telnyx::SpendLimitResponse, Telnyx::Internal::AnyHash)
         end
 
-      # The spend limit, spend and block state of one product and period.
+      # The spend limit, spend and block state of one product and period. The top-level
+      # fields describe the total limit of the account; API key limits are nested in
+      # `credential_limits`.
       sig { returns(Telnyx::SpendLimit) }
       attr_reader :data
 
@@ -17,7 +19,9 @@ module Telnyx
 
       sig { params(data: Telnyx::SpendLimit::OrHash).returns(T.attached_class) }
       def self.new(
-        # The spend limit, spend and block state of one product and period.
+        # The spend limit, spend and block state of one product and period. The top-level
+        # fields describe the total limit of the account; API key limits are nested in
+        # `credential_limits`.
         data:
       )
       end

data/rbi/telnyx/models/spend_limit_update_params.rbi

@@ -25,6 +25,15 @@ module Telnyx
       end
       attr_accessor :body
 
+      # Identifier of one API key as recorded on usage, never the key's secret,
+      # percent-encoded: the request is then about that key's limit. Absent means the
+      # total limit; present but blank is refused.
+      sig { returns(T.nilable(String)) }
+      attr_reader :credential_id
+
+      sig { params(credential_id: String).void }
+      attr_writer :credential_id
+
       # Limit period. Defaults to `daily`; send it explicitly.
       sig { returns(T.nilable(Telnyx::SpendLimitPeriod::OrSymbol)) }
       attr_reader :period
@@ -40,6 +49,7 @@ module Telnyx
               Telnyx::SpendLimitUpdateParams::Body::UpdateSpendLimitWithAmount::OrHash,
               Telnyx::SpendLimitUpdateParams::Body::UpdateSpendLimitUnlimited::OrHash
             ),
+          credential_id: String,
           period: Telnyx::SpendLimitPeriod::OrSymbol,
           request_options: Telnyx::RequestOptions::OrHash
         ).returns(T.attached_class)
@@ -48,6 +58,10 @@ module Telnyx
         product:,
         # Send exactly one of `amount` and `unlimited: true`.
         body:,
+        # Identifier of one API key as recorded on usage, never the key's secret,
+        # percent-encoded: the request is then about that key's limit. Absent means the
+        # total limit; present but blank is refused.
+        credential_id: nil,
         # Limit period. Defaults to `daily`; send it explicitly.
         period: nil,
         request_options: {}
@@ -63,6 +77,7 @@ module Telnyx
                 Telnyx::SpendLimitUpdateParams::Body::UpdateSpendLimitWithAmount,
                 Telnyx::SpendLimitUpdateParams::Body::UpdateSpendLimitUnlimited
               ),
+            credential_id: String,
             period: Telnyx::SpendLimitPeriod::OrSymbol,
             request_options: Telnyx::RequestOptions
           }