telnyx 5.167.0 → 5.169.0

data/rbi/telnyx/models/ai/typesafe/v1_systemone_response.rbi

@@ -0,0 +1,348 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      module Typesafe
+        class V1SystemoneResponse < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::Models::AI::Typesafe::V1SystemoneResponse,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          # Answers keyed by exactly the question IDs in the request. Each answer type
+          # matches its question.
+          sig do
+            returns(
+              T::Hash[
+                Symbol,
+                Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Answer::Variants
+              ]
+            )
+          end
+          attr_accessor :answers
+
+          # Token usage for the completed evaluation.
+          sig do
+            returns(Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Usage)
+          end
+          attr_reader :usage
+
+          sig do
+            params(
+              usage:
+                Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Usage::OrHash
+            ).void
+          end
+          attr_writer :usage
+
+          # Opaque Telnyx-controlled identifier retained for TypeSafe SDK response
+          # compatibility. It is not a selectable model name or a guarantee of a particular
+          # underlying model.
+          sig { returns(String) }
+          attr_accessor :model
+
+          # A complete synchronous evaluation. Answers are returned directly without a data
+          # wrapper.
+          sig do
+            params(
+              answers:
+                T::Hash[
+                  Symbol,
+                  T.any(
+                    Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Answer::Choice::OrHash,
+                    Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Answer::Noul::OrHash,
+                    Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Answer::Score::OrHash
+                  )
+                ],
+              model: String,
+              usage:
+                Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Usage::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Answers keyed by exactly the question IDs in the request. Each answer type
+            # matches its question.
+            answers:,
+            # Opaque Telnyx-controlled identifier retained for TypeSafe SDK response
+            # compatibility. It is not a selectable model name or a guarantee of a particular
+            # underlying model.
+            model:,
+            # Token usage for the completed evaluation.
+            usage:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                answers:
+                  T::Hash[
+                    Symbol,
+                    Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Answer::Variants
+                  ],
+                model: String,
+                usage: Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Usage
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # An answer whose type matches its question.
+          module Answer
+            extend Telnyx::Internal::Type::Union
+
+            Variants =
+              T.type_alias do
+                T.any(
+                  Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Answer::Choice,
+                  Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Answer::Noul,
+                  Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Answer::Score
+                )
+              end
+
+            class Choice < Telnyx::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Answer::Choice,
+                    Telnyx::Internal::AnyHash
+                  )
+                end
+
+              # The option key with the highest relative score. Ties favor the first option in
+              # request order.
+              sig { returns(String) }
+              attr_accessor :choice
+
+              # Normalized entropy confidence: 1 - H(p) / ln(N), where H(p) = -sum(p \* ln(p))
+              # and N is the number of options. Zero indicates a uniform distribution; one
+              # indicates concentration on one option. This is neither the winning probability
+              # nor calibrated correctness.
+              sig { returns(Float) }
+              attr_accessor :confidence
+
+              # Relative scores normalized across the supplied options, summing approximately
+              # to 1. These are not calibrated probabilities of correctness.
+              sig { returns(T::Hash[Symbol, Float]) }
+              attr_accessor :probabilities
+
+              # Answer type.
+              sig { returns(Symbol) }
+              attr_accessor :type
+
+              # A selected option and the distribution across all supplied option keys.
+              sig do
+                params(
+                  choice: String,
+                  confidence: Float,
+                  probabilities: T::Hash[Symbol, Float],
+                  type: Symbol
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # The option key with the highest relative score. Ties favor the first option in
+                # request order.
+                choice:,
+                # Normalized entropy confidence: 1 - H(p) / ln(N), where H(p) = -sum(p \* ln(p))
+                # and N is the number of options. Zero indicates a uniform distribution; one
+                # indicates concentration on one option. This is neither the winning probability
+                # nor calibrated correctness.
+                confidence:,
+                # Relative scores normalized across the supplied options, summing approximately
+                # to 1. These are not calibrated probabilities of correctness.
+                probabilities:,
+                # Answer type.
+                type: :choice
+              )
+              end
+
+              sig do
+                override.returns(
+                  {
+                    choice: String,
+                    confidence: Float,
+                    probabilities: T::Hash[Symbol, Float],
+                    type: Symbol
+                  }
+                )
+              end
+              def to_hash
+              end
+            end
+
+            class Noul < Telnyx::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Answer::Noul,
+                    Telnyx::Internal::AnyHash
+                  )
+                end
+
+              # Score of the positive outcome. Values near 1 favor yes; values near 0 favor no.
+              # This is a number, not a Boolean, and is not calibrated correctness.
+              sig { returns(Float) }
+              attr_accessor :noul
+
+              # Answer type.
+              sig { returns(Symbol) }
+              attr_accessor :type
+
+              # A yes/no score with no separate confidence or probabilities fields.
+              sig do
+                params(noul: Float, type: Symbol).returns(T.attached_class)
+              end
+              def self.new(
+                # Score of the positive outcome. Values near 1 favor yes; values near 0 favor no.
+                # This is a number, not a Boolean, and is not calibrated correctness.
+                noul:,
+                # Answer type.
+                type: :noul
+              )
+              end
+
+              sig { override.returns({ noul: Float, type: Symbol }) }
+              def to_hash
+              end
+            end
+
+            class Score < Telnyx::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Answer::Score,
+                    Telnyx::Internal::AnyHash
+                  )
+                end
+
+              # Normalized entropy confidence: 1 - H(p) / ln(N), where H(p) = -sum(p \* ln(p))
+              # and N is the number of options. Zero indicates a uniform distribution; one
+              # indicates concentration on one option. This is neither the winning probability
+              # nor calibrated correctness.
+              sig { returns(Float) }
+              attr_accessor :confidence
+
+              # Criterion descriptions keyed by stringified zero-based indices, such as "0",
+              # "1", and "2".
+              sig { returns(T::Hash[Symbol, String]) }
+              attr_accessor :legend
+
+              # Relative scores keyed by the same stringified indices as legend.
+              sig { returns(T::Hash[Symbol, Float]) }
+              attr_accessor :probabilities
+
+              # Expected zero-based criterion index: sum(index \* probability). Ranges from 0 to
+              # N-1 for N criteria; fractional values are valid.
+              sig { returns(Float) }
+              attr_accessor :score
+
+              # Answer type.
+              sig { returns(Symbol) }
+              attr_accessor :type
+
+              # An expected rating over the ordered criteria.
+              sig do
+                params(
+                  confidence: Float,
+                  legend: T::Hash[Symbol, String],
+                  probabilities: T::Hash[Symbol, Float],
+                  score: Float,
+                  type: Symbol
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # Normalized entropy confidence: 1 - H(p) / ln(N), where H(p) = -sum(p \* ln(p))
+                # and N is the number of options. Zero indicates a uniform distribution; one
+                # indicates concentration on one option. This is neither the winning probability
+                # nor calibrated correctness.
+                confidence:,
+                # Criterion descriptions keyed by stringified zero-based indices, such as "0",
+                # "1", and "2".
+                legend:,
+                # Relative scores keyed by the same stringified indices as legend.
+                probabilities:,
+                # Expected zero-based criterion index: sum(index \* probability). Ranges from 0 to
+                # N-1 for N criteria; fractional values are valid.
+                score:,
+                # Answer type.
+                type: :score
+              )
+              end
+
+              sig do
+                override.returns(
+                  {
+                    confidence: Float,
+                    legend: T::Hash[Symbol, String],
+                    probabilities: T::Hash[Symbol, Float],
+                    score: Float,
+                    type: Symbol
+                  }
+                )
+              end
+              def to_hash
+              end
+            end
+
+            sig do
+              override.returns(
+                T::Array[
+                  Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Answer::Variants
+                ]
+              )
+            end
+            def self.variants
+            end
+          end
+
+          class Usage < Telnyx::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Telnyx::Models::AI::Typesafe::V1SystemoneResponse::Usage,
+                  Telnyx::Internal::AnyHash
+                )
+              end
+
+            # Input tokens processed, including shared-context preparation and question
+            # evaluation. This can exceed the token count of the unique input text.
+            sig { returns(Integer) }
+            attr_accessor :input_tokens
+
+            # Output tokens used for the evaluation, including shared-context preparation.
+            sig { returns(Integer) }
+            attr_accessor :output_tokens
+
+            # Token usage for the completed evaluation.
+            sig do
+              params(input_tokens: Integer, output_tokens: Integer).returns(
+                T.attached_class
+              )
+            end
+            def self.new(
+              # Input tokens processed, including shared-context preparation and question
+              # evaluation. This can exceed the token count of the unique input text.
+              input_tokens:,
+              # Output tokens used for the evaluation, including shared-context preparation.
+              output_tokens:
+            )
+            end
+
+            sig do
+              override.returns(
+                { input_tokens: Integer, output_tokens: Integer }
+              )
+            end
+            def to_hash
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/bot_challenge_create_params.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    class BotChallengeCreateParams < Telnyx::Internal::Type::BaseModel
+      extend Telnyx::Internal::Type::RequestParameters::Converter
+      include Telnyx::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Telnyx::BotChallengeCreateParams, Telnyx::Internal::AnyHash)
+        end
+
+      # Name of the LLM the client is using.
+      sig { returns(T.nilable(String)) }
+      attr_reader :llm_model_name
+
+      sig { params(llm_model_name: String).void }
+      attr_writer :llm_model_name
+
+      # Parameter count of the client LLM.
+      sig { returns(T.nilable(String)) }
+      attr_reader :llm_parameter_count
+
+      sig { params(llm_parameter_count: String).void }
+      attr_writer :llm_parameter_count
+
+      # Quantization of the client LLM.
+      sig { returns(T.nilable(String)) }
+      attr_reader :llm_quantization
+
+      sig { params(llm_quantization: String).void }
+      attr_writer :llm_quantization
+
+      sig do
+        params(
+          llm_model_name: String,
+          llm_parameter_count: String,
+          llm_quantization: String,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Name of the LLM the client is using.
+        llm_model_name: nil,
+        # Parameter count of the client LLM.
+        llm_parameter_count: nil,
+        # Quantization of the client LLM.
+        llm_quantization: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            llm_model_name: String,
+            llm_parameter_count: String,
+            llm_quantization: String,
+            request_options: Telnyx::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/telnyx/models/bot_challenge_create_response.rbi

@@ -0,0 +1,169 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    class BotChallengeCreateResponse < Telnyx::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Telnyx::Models::BotChallengeCreateResponse,
+            Telnyx::Internal::AnyHash
+          )
+        end
+
+      sig { returns(Telnyx::Models::BotChallengeCreateResponse::Data) }
+      attr_reader :data
+
+      sig do
+        params(
+          data: Telnyx::Models::BotChallengeCreateResponse::Data::OrHash
+        ).void
+      end
+      attr_writer :data
+
+      sig do
+        params(
+          data: Telnyx::Models::BotChallengeCreateResponse::Data::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(data:)
+      end
+
+      sig do
+        override.returns(
+          { data: Telnyx::Models::BotChallengeCreateResponse::Data }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::Models::BotChallengeCreateResponse::Data,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        # Type of challenge.
+        sig do
+          returns(
+            Telnyx::Models::BotChallengeCreateResponse::Data::ChallengeType::TaggedSymbol
+          )
+        end
+        attr_accessor :challenge_type
+
+        # Single-use challenge identifier. Submit it as `bot_challenge_nonce` on the
+        # signup request.
+        sig { returns(String) }
+        attr_accessor :nonce
+
+        # Current privacy-policy URL. Echo this back on the signup request.
+        sig { returns(String) }
+        attr_accessor :privacy_policy_url
+
+        # Problem text to solve. Math problems are obfuscated and end with an unobfuscated
+        # rounding instruction; string and binary problems are returned as-is.
+        sig { returns(String) }
+        attr_accessor :problem
+
+        # Current terms-and-conditions URL. Echo this back on the signup request.
+        sig { returns(String) }
+        attr_accessor :terms_and_conditions_url
+
+        # Decimal places expected in the answer. Present only for math challenges.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :precision
+
+        sig { params(precision: Integer).void }
+        attr_writer :precision
+
+        sig do
+          params(
+            challenge_type:
+              Telnyx::Models::BotChallengeCreateResponse::Data::ChallengeType::OrSymbol,
+            nonce: String,
+            privacy_policy_url: String,
+            problem: String,
+            terms_and_conditions_url: String,
+            precision: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Type of challenge.
+          challenge_type:,
+          # Single-use challenge identifier. Submit it as `bot_challenge_nonce` on the
+          # signup request.
+          nonce:,
+          # Current privacy-policy URL. Echo this back on the signup request.
+          privacy_policy_url:,
+          # Problem text to solve. Math problems are obfuscated and end with an unobfuscated
+          # rounding instruction; string and binary problems are returned as-is.
+          problem:,
+          # Current terms-and-conditions URL. Echo this back on the signup request.
+          terms_and_conditions_url:,
+          # Decimal places expected in the answer. Present only for math challenges.
+          precision: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              challenge_type:
+                Telnyx::Models::BotChallengeCreateResponse::Data::ChallengeType::TaggedSymbol,
+              nonce: String,
+              privacy_policy_url: String,
+              problem: String,
+              terms_and_conditions_url: String,
+              precision: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Type of challenge.
+        module ChallengeType
+          extend Telnyx::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Telnyx::Models::BotChallengeCreateResponse::Data::ChallengeType
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          MATH =
+            T.let(
+              :math,
+              Telnyx::Models::BotChallengeCreateResponse::Data::ChallengeType::TaggedSymbol
+            )
+          STRING =
+            T.let(
+              :string,
+              Telnyx::Models::BotChallengeCreateResponse::Data::ChallengeType::TaggedSymbol
+            )
+          BINARY =
+            T.let(
+              :binary,
+              Telnyx::Models::BotChallengeCreateResponse::Data::ChallengeType::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Telnyx::Models::BotChallengeCreateResponse::Data::ChallengeType::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/bot_session_list_params.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    class BotSessionListParams < Telnyx::Internal::Type::BaseModel
+      extend Telnyx::Internal::Type::RequestParameters::Converter
+      include Telnyx::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Telnyx::BotSessionListParams, Telnyx::Internal::AnyHash)
+        end
+
+      # Email address associated with the magic link token.
+      sig { returns(String) }
+      attr_accessor :email
+
+      # Single-use portal redirect (magic link) token, a UUIDv7 sent to the account
+      # owner's email.
+      sig { returns(String) }
+      attr_accessor :portal_redirect_token
+
+      sig do
+        params(
+          email: String,
+          portal_redirect_token: String,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Email address associated with the magic link token.
+        email:,
+        # Single-use portal redirect (magic link) token, a UUIDv7 sent to the account
+        # owner's email.
+        portal_redirect_token:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            email: String,
+            portal_redirect_token: String,
+            request_options: Telnyx::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/telnyx/models/bot_session_list_response.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    class BotSessionListResponse < Telnyx::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Telnyx::Models::BotSessionListResponse,
+            Telnyx::Internal::AnyHash
+          )
+        end
+
+      sig { returns(Telnyx::Models::BotSessionListResponse::Data) }
+      attr_reader :data
+
+      sig do
+        params(data: Telnyx::Models::BotSessionListResponse::Data::OrHash).void
+      end
+      attr_writer :data
+
+      sig do
+        params(
+          data: Telnyx::Models::BotSessionListResponse::Data::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(data:)
+      end
+
+      sig do
+        override.returns({ data: Telnyx::Models::BotSessionListResponse::Data })
+      end
+      def to_hash
+      end
+
+      class Data < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::Models::BotSessionListResponse::Data,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        # API v2 session token for the signed-in user. Use it as a bearer token on
+        # authenticated endpoints.
+        sig { returns(String) }
+        attr_accessor :api_v2_token
+
+        sig { params(api_v2_token: String).returns(T.attached_class) }
+        def self.new(
+          # API v2 session token for the signed-in user. Use it as a bearer token on
+          # authenticated endpoints.
+          api_v2_token:
+        )
+        end
+
+        sig { override.returns({ api_v2_token: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end