telnyx 5.170.0 → 5.171.0

data/rbi/telnyx/models/llm_token_gateway/token_key.rbi

@@ -0,0 +1,281 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module LlmTokenGateway
+      class TokenKey < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Telnyx::LlmTokenGateway::TokenKey, Telnyx::Internal::AnyHash)
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :allowed_models
+
+        sig { returns(T::Boolean) }
+        attr_accessor :blocked
+
+        sig do
+          returns(
+            T.nilable(Telnyx::LlmTokenGateway::BudgetDuration::TaggedSymbol)
+          )
+        end
+        attr_accessor :budget_duration
+
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :budget_started_at
+
+        sig { returns(Time) }
+        attr_accessor :created_at
+
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :expires_at
+
+        # USD, decimal precision at most 6 places; parse exactly to integer micro-USD,
+        # never binary float accounting.
+        sig { returns(T.nilable(Float)) }
+        attr_accessor :max_budget
+
+        sig { returns(String) }
+        attr_accessor :name
+
+        sig { returns(Symbol) }
+        attr_accessor :record_type
+
+        # Require a nonempty caller-asserted end-user ID; not proof of identity.
+        sig { returns(T::Boolean) }
+        attr_accessor :required_end_user_id
+
+        # USD, decimal precision at most 6 places; parse exactly to integer micro-USD,
+        # never binary float accounting.
+        sig { returns(Float) }
+        attr_accessor :reserved_spend
+
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :resets_at
+
+        # Stored key limit; set to the maximum when the key was written without one (on a
+        # blocked key, null is kept until the key is unblocked).
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :rpm_limit
+
+        # USD, decimal precision at most 6 places; parse exactly to integer micro-USD,
+        # never binary float accounting.
+        sig { returns(Float) }
+        attr_accessor :spend
+
+        sig { returns(String) }
+        attr_accessor :token_group_id
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :token_user_id
+
+        # Stored key limit; set to the maximum when the key was written without one (on a
+        # blocked key, null is kept until the key is unblocked).
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :tpm_limit
+
+        sig { returns(Time) }
+        attr_accessor :updated_at
+
+        sig { returns(Integer) }
+        attr_accessor :version
+
+        # Optional maximum concurrent reserved/dispatched cache misses across replicas.
+        # Null means no concurrency cap. Cache hits do not consume slots; unknown usage
+        # retains its budget hold without a slot.
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :max_parallel_requests
+
+        # Provisioning state of the key's current policy. `pending`: retry readiness with
+        # bounded backoff (treat `unknown` the same). `inactive` and `unsupported` are
+        # terminal until the key, group, user or catalog changes. `unavailable` means
+        # provisioning is stuck and is retried slowly; surface it. Absent while the
+        # gateway runs in compatibility mode.
+        sig do
+          returns(
+            T.nilable(
+              Telnyx::LlmTokenGateway::TokenKey::Provisioning::TaggedSymbol
+            )
+          )
+        end
+        attr_reader :provisioning
+
+        sig do
+          params(
+            provisioning:
+              Telnyx::LlmTokenGateway::TokenKey::Provisioning::OrSymbol
+          ).void
+        end
+        attr_writer :provisioning
+
+        sig do
+          params(
+            id: String,
+            allowed_models: T.nilable(T::Array[String]),
+            blocked: T::Boolean,
+            budget_duration:
+              T.nilable(Telnyx::LlmTokenGateway::BudgetDuration::OrSymbol),
+            budget_started_at: T.nilable(Time),
+            created_at: Time,
+            expires_at: T.nilable(Time),
+            max_budget: T.nilable(Float),
+            name: String,
+            required_end_user_id: T::Boolean,
+            reserved_spend: Float,
+            resets_at: T.nilable(Time),
+            rpm_limit: T.nilable(Integer),
+            spend: Float,
+            token_group_id: String,
+            token_user_id: T.nilable(String),
+            tpm_limit: T.nilable(Integer),
+            updated_at: Time,
+            version: Integer,
+            max_parallel_requests: T.nilable(Integer),
+            provisioning:
+              Telnyx::LlmTokenGateway::TokenKey::Provisioning::OrSymbol,
+            record_type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id:,
+          allowed_models:,
+          blocked:,
+          budget_duration:,
+          budget_started_at:,
+          created_at:,
+          expires_at:,
+          # USD, decimal precision at most 6 places; parse exactly to integer micro-USD,
+          # never binary float accounting.
+          max_budget:,
+          name:,
+          # Require a nonempty caller-asserted end-user ID; not proof of identity.
+          required_end_user_id:,
+          # USD, decimal precision at most 6 places; parse exactly to integer micro-USD,
+          # never binary float accounting.
+          reserved_spend:,
+          resets_at:,
+          # Stored key limit; set to the maximum when the key was written without one (on a
+          # blocked key, null is kept until the key is unblocked).
+          rpm_limit:,
+          # USD, decimal precision at most 6 places; parse exactly to integer micro-USD,
+          # never binary float accounting.
+          spend:,
+          token_group_id:,
+          token_user_id:,
+          # Stored key limit; set to the maximum when the key was written without one (on a
+          # blocked key, null is kept until the key is unblocked).
+          tpm_limit:,
+          updated_at:,
+          version:,
+          # Optional maximum concurrent reserved/dispatched cache misses across replicas.
+          # Null means no concurrency cap. Cache hits do not consume slots; unknown usage
+          # retains its budget hold without a slot.
+          max_parallel_requests: nil,
+          # Provisioning state of the key's current policy. `pending`: retry readiness with
+          # bounded backoff (treat `unknown` the same). `inactive` and `unsupported` are
+          # terminal until the key, group, user or catalog changes. `unavailable` means
+          # provisioning is stuck and is retried slowly; surface it. Absent while the
+          # gateway runs in compatibility mode.
+          provisioning: nil,
+          record_type: :token_key
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              allowed_models: T.nilable(T::Array[String]),
+              blocked: T::Boolean,
+              budget_duration:
+                T.nilable(
+                  Telnyx::LlmTokenGateway::BudgetDuration::TaggedSymbol
+                ),
+              budget_started_at: T.nilable(Time),
+              created_at: Time,
+              expires_at: T.nilable(Time),
+              max_budget: T.nilable(Float),
+              name: String,
+              record_type: Symbol,
+              required_end_user_id: T::Boolean,
+              reserved_spend: Float,
+              resets_at: T.nilable(Time),
+              rpm_limit: T.nilable(Integer),
+              spend: Float,
+              token_group_id: String,
+              token_user_id: T.nilable(String),
+              tpm_limit: T.nilable(Integer),
+              updated_at: Time,
+              version: Integer,
+              max_parallel_requests: T.nilable(Integer),
+              provisioning:
+                Telnyx::LlmTokenGateway::TokenKey::Provisioning::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Provisioning state of the key's current policy. `pending`: retry readiness with
+        # bounded backoff (treat `unknown` the same). `inactive` and `unsupported` are
+        # terminal until the key, group, user or catalog changes. `unavailable` means
+        # provisioning is stuck and is retried slowly; surface it. Absent while the
+        # gateway runs in compatibility mode.
+        module Provisioning
+          extend Telnyx::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Telnyx::LlmTokenGateway::TokenKey::Provisioning)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          READY =
+            T.let(
+              :ready,
+              Telnyx::LlmTokenGateway::TokenKey::Provisioning::TaggedSymbol
+            )
+          PENDING =
+            T.let(
+              :pending,
+              Telnyx::LlmTokenGateway::TokenKey::Provisioning::TaggedSymbol
+            )
+          UNAVAILABLE =
+            T.let(
+              :unavailable,
+              Telnyx::LlmTokenGateway::TokenKey::Provisioning::TaggedSymbol
+            )
+          INACTIVE =
+            T.let(
+              :inactive,
+              Telnyx::LlmTokenGateway::TokenKey::Provisioning::TaggedSymbol
+            )
+          UNSUPPORTED =
+            T.let(
+              :unsupported,
+              Telnyx::LlmTokenGateway::TokenKey::Provisioning::TaggedSymbol
+            )
+          UNKNOWN =
+            T.let(
+              :unknown,
+              Telnyx::LlmTokenGateway::TokenKey::Provisioning::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Telnyx::LlmTokenGateway::TokenKey::Provisioning::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/llm_token_gateway/token_key_create_params.rbi

@@ -0,0 +1,160 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module LlmTokenGateway
+      class TokenKeyCreateParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::LlmTokenGateway::TokenKeyCreateParams,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :name
+
+        sig { returns(String) }
+        attr_accessor :token_group_id
+
+        sig { returns(String) }
+        attr_accessor :idempotency_key
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :allowed_models
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :blocked
+
+        sig { params(blocked: T::Boolean).void }
+        attr_writer :blocked
+
+        sig do
+          returns(T.nilable(Telnyx::LlmTokenGateway::BudgetDuration::OrSymbol))
+        end
+        attr_accessor :budget_duration
+
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :expires_at
+
+        # USD, decimal precision at most 6 places; parse exactly to integer micro-USD,
+        # never binary float accounting.
+        sig { returns(T.nilable(Float)) }
+        attr_accessor :max_budget
+
+        # Optional maximum concurrent reserved/dispatched cache misses across replicas.
+        # Null means no concurrency cap. Cache hits do not consume slots; unknown usage
+        # retains its budget hold without a slot.
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :max_parallel_requests
+
+        # Require a nonempty caller-asserted end-user ID; not proof of identity.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :required_end_user_id
+
+        sig { params(required_end_user_id: T::Boolean).void }
+        attr_writer :required_end_user_id
+
+        # Omitted or null defaults to the maximum (6000) (on a blocked key, null is kept
+        # until the key is unblocked); a value below the minimum (1) or above the maximum
+        # is rejected with 400 limit_out_of_range; a malformed value (negative, wrong type
+        # or precision) is 400 invalid_request. Block the key (blocked: true) to deny it;
+        # blocking is always accepted.
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :rpm_limit
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :token_user_id
+
+        # Omitted or null defaults to the maximum (10000000) (on a blocked key, null is
+        # kept until the key is unblocked); a value below the minimum (1) or above the
+        # maximum is rejected with 400 limit_out_of_range; a malformed value (negative,
+        # wrong type or precision) is 400 invalid_request. Block the key (blocked: true)
+        # to deny it; blocking is always accepted.
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :tpm_limit
+
+        sig do
+          params(
+            name: String,
+            token_group_id: String,
+            idempotency_key: String,
+            allowed_models: T.nilable(T::Array[String]),
+            blocked: T::Boolean,
+            budget_duration:
+              T.nilable(Telnyx::LlmTokenGateway::BudgetDuration::OrSymbol),
+            expires_at: T.nilable(Time),
+            max_budget: T.nilable(Float),
+            max_parallel_requests: T.nilable(Integer),
+            required_end_user_id: T::Boolean,
+            rpm_limit: T.nilable(Integer),
+            token_user_id: T.nilable(String),
+            tpm_limit: T.nilable(Integer),
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          name:,
+          token_group_id:,
+          idempotency_key:,
+          allowed_models: nil,
+          blocked: nil,
+          budget_duration: nil,
+          expires_at: nil,
+          # USD, decimal precision at most 6 places; parse exactly to integer micro-USD,
+          # never binary float accounting.
+          max_budget: nil,
+          # Optional maximum concurrent reserved/dispatched cache misses across replicas.
+          # Null means no concurrency cap. Cache hits do not consume slots; unknown usage
+          # retains its budget hold without a slot.
+          max_parallel_requests: nil,
+          # Require a nonempty caller-asserted end-user ID; not proof of identity.
+          required_end_user_id: nil,
+          # Omitted or null defaults to the maximum (6000) (on a blocked key, null is kept
+          # until the key is unblocked); a value below the minimum (1) or above the maximum
+          # is rejected with 400 limit_out_of_range; a malformed value (negative, wrong type
+          # or precision) is 400 invalid_request. Block the key (blocked: true) to deny it;
+          # blocking is always accepted.
+          rpm_limit: nil,
+          token_user_id: nil,
+          # Omitted or null defaults to the maximum (10000000) (on a blocked key, null is
+          # kept until the key is unblocked); a value below the minimum (1) or above the
+          # maximum is rejected with 400 limit_out_of_range; a malformed value (negative,
+          # wrong type or precision) is 400 invalid_request. Block the key (blocked: true)
+          # to deny it; blocking is always accepted.
+          tpm_limit: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              name: String,
+              token_group_id: String,
+              idempotency_key: String,
+              allowed_models: T.nilable(T::Array[String]),
+              blocked: T::Boolean,
+              budget_duration:
+                T.nilable(Telnyx::LlmTokenGateway::BudgetDuration::OrSymbol),
+              expires_at: T.nilable(Time),
+              max_budget: T.nilable(Float),
+              max_parallel_requests: T.nilable(Integer),
+              required_end_user_id: T::Boolean,
+              rpm_limit: T.nilable(Integer),
+              token_user_id: T.nilable(String),
+              tpm_limit: T.nilable(Integer),
+              request_options: Telnyx::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/llm_token_gateway/token_key_delete_params.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module LlmTokenGateway
+      class TokenKeyDeleteParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::LlmTokenGateway::TokenKeyDeleteParams,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(String) }
+        attr_accessor :idempotency_key
+
+        sig { returns(String) }
+        attr_accessor :if_match
+
+        sig do
+          params(
+            id: String,
+            idempotency_key: String,
+            if_match: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(id:, idempotency_key:, if_match:, request_options: {})
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              idempotency_key: String,
+              if_match: String,
+              request_options: Telnyx::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/llm_token_gateway/token_key_list_params.rbi

@@ -0,0 +1,89 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module LlmTokenGateway
+      class TokenKeyListParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::LlmTokenGateway::TokenKeyListParams,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :page_number
+
+        sig { params(page_number: Integer).void }
+        attr_writer :page_number
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :page_size
+
+        sig { params(page_size: Integer).void }
+        attr_writer :page_size
+
+        # Required after page 1; account/filter-bound 15-minute stable snapshot;
+        # expired/mismatch 409.
+        sig { returns(T.nilable(String)) }
+        attr_reader :page_snapshot
+
+        sig { params(page_snapshot: String).void }
+        attr_writer :page_snapshot
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :token_group_id
+
+        sig { params(token_group_id: String).void }
+        attr_writer :token_group_id
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :token_user_id
+
+        sig { params(token_user_id: String).void }
+        attr_writer :token_user_id
+
+        sig do
+          params(
+            page_number: Integer,
+            page_size: Integer,
+            page_snapshot: String,
+            token_group_id: String,
+            token_user_id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          page_number: nil,
+          page_size: nil,
+          # Required after page 1; account/filter-bound 15-minute stable snapshot;
+          # expired/mismatch 409.
+          page_snapshot: nil,
+          token_group_id: nil,
+          token_user_id: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              page_number: Integer,
+              page_size: Integer,
+              page_snapshot: String,
+              token_group_id: String,
+              token_user_id: String,
+              request_options: Telnyx::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/llm_token_gateway/token_key_response.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module LlmTokenGateway
+      class TokenKeyResponse < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::LlmTokenGateway::TokenKeyResponse,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Telnyx::LlmTokenGateway::TokenKey) }
+        attr_reader :data
+
+        sig { params(data: Telnyx::LlmTokenGateway::TokenKey::OrHash).void }
+        attr_writer :data
+
+        sig do
+          params(data: Telnyx::LlmTokenGateway::TokenKey::OrHash).returns(
+            T.attached_class
+          )
+        end
+        def self.new(data:)
+        end
+
+        sig { override.returns({ data: Telnyx::LlmTokenGateway::TokenKey }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/llm_token_gateway/token_key_retrieve_params.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module LlmTokenGateway
+      class TokenKeyRetrieveParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::LlmTokenGateway::TokenKeyRetrieveParams,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig do
+          params(
+            id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(id:, request_options: {})
+        end
+
+        sig do
+          override.returns(
+            { id: String, request_options: Telnyx::RequestOptions }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end