telnyx 5.159.0 → 5.161.0

data/rbi/telnyx/models/ai/collection_retrieve_documents_params.rbi

@@ -0,0 +1,195 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      class CollectionRetrieveDocumentsParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::AI::CollectionRetrieveDocumentsParams,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :slug
+
+        # Field filters applied before ranking, using `filter[field][operator]=value`.
+        # Supported operators: `eq` (default), `in`, `gte`, `gt`, `lte`, `lt`, `contains`.
+        # Known fields: `record_type`, `record_id`, `user_id`, `record_created_at`,
+        # `ingested_at`; any other name resolves to a `metadata.<field>` filter. Example:
+        # `filter[record_id][eq]=rec_123`.
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_reader :filter
+
+        sig { params(filter: T::Hash[Symbol, T.anything]).void }
+        attr_writer :filter
+
+        # Page number to return (1-based). Defaults to 1.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :page_number
+
+        sig { params(page_number: Integer).void }
+        attr_writer :page_number
+
+        # Number of results per page. Defaults to 20.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :page_size
+
+        sig { params(page_size: Integer).void }
+        attr_writer :page_size
+
+        # Natural-language search query. When provided, the text is matched against the
+        # collection's document chunks using the collection's `retrieval_type` (vector or
+        # hybrid). When omitted, documents are returned as a plain catalog listing.
+        sig { returns(T.nilable(String)) }
+        attr_reader :query
+
+        sig { params(query: String).void }
+        attr_writer :query
+
+        # Override the collection's configured retrieval strategy for this request. Echoed
+        # back in `meta.retrieval_type`.
+        sig do
+          returns(
+            T.nilable(
+              Telnyx::AI::CollectionRetrieveDocumentsParams::RetrievalType::OrSymbol
+            )
+          )
+        end
+        attr_reader :retrieval_type
+
+        sig do
+          params(
+            retrieval_type:
+              Telnyx::AI::CollectionRetrieveDocumentsParams::RetrievalType::OrSymbol
+          ).void
+        end
+        attr_writer :retrieval_type
+
+        # Comma-separated list of source types to restrict the search to. When omitted,
+        # all of the collection's sources are searched.
+        sig { returns(T.nilable(String)) }
+        attr_reader :sources
+
+        sig { params(sources: String).void }
+        attr_writer :sources
+
+        # Maximum number of ranked results to consider. When omitted, the collection's
+        # configured `top_k` setting is used.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :top_k
+
+        sig { params(top_k: Integer).void }
+        attr_writer :top_k
+
+        sig do
+          params(
+            slug: String,
+            filter: T::Hash[Symbol, T.anything],
+            page_number: Integer,
+            page_size: Integer,
+            query: String,
+            retrieval_type:
+              Telnyx::AI::CollectionRetrieveDocumentsParams::RetrievalType::OrSymbol,
+            sources: String,
+            top_k: Integer,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          slug:,
+          # Field filters applied before ranking, using `filter[field][operator]=value`.
+          # Supported operators: `eq` (default), `in`, `gte`, `gt`, `lte`, `lt`, `contains`.
+          # Known fields: `record_type`, `record_id`, `user_id`, `record_created_at`,
+          # `ingested_at`; any other name resolves to a `metadata.<field>` filter. Example:
+          # `filter[record_id][eq]=rec_123`.
+          filter: nil,
+          # Page number to return (1-based). Defaults to 1.
+          page_number: nil,
+          # Number of results per page. Defaults to 20.
+          page_size: nil,
+          # Natural-language search query. When provided, the text is matched against the
+          # collection's document chunks using the collection's `retrieval_type` (vector or
+          # hybrid). When omitted, documents are returned as a plain catalog listing.
+          query: nil,
+          # Override the collection's configured retrieval strategy for this request. Echoed
+          # back in `meta.retrieval_type`.
+          retrieval_type: nil,
+          # Comma-separated list of source types to restrict the search to. When omitted,
+          # all of the collection's sources are searched.
+          sources: nil,
+          # Maximum number of ranked results to consider. When omitted, the collection's
+          # configured `top_k` setting is used.
+          top_k: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              slug: String,
+              filter: T::Hash[Symbol, T.anything],
+              page_number: Integer,
+              page_size: Integer,
+              query: String,
+              retrieval_type:
+                Telnyx::AI::CollectionRetrieveDocumentsParams::RetrievalType::OrSymbol,
+              sources: String,
+              top_k: Integer,
+              request_options: Telnyx::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Override the collection's configured retrieval strategy for this request. Echoed
+        # back in `meta.retrieval_type`.
+        module RetrievalType
+          extend Telnyx::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Telnyx::AI::CollectionRetrieveDocumentsParams::RetrievalType
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          VECTOR =
+            T.let(
+              :vector,
+              Telnyx::AI::CollectionRetrieveDocumentsParams::RetrievalType::TaggedSymbol
+            )
+          HYBRID =
+            T.let(
+              :hybrid,
+              Telnyx::AI::CollectionRetrieveDocumentsParams::RetrievalType::TaggedSymbol
+            )
+          KEYWORD =
+            T.let(
+              :keyword,
+              Telnyx::AI::CollectionRetrieveDocumentsParams::RetrievalType::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Telnyx::AI::CollectionRetrieveDocumentsParams::RetrievalType::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/collection_retrieve_documents_response.rbi

@@ -0,0 +1,334 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      class CollectionRetrieveDocumentsResponse < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::Models::AI::CollectionRetrieveDocumentsResponse,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            T.nilable(
+              T::Array[
+                Telnyx::Models::AI::CollectionRetrieveDocumentsResponse::Data
+              ]
+            )
+          )
+        end
+        attr_reader :data
+
+        sig do
+          params(
+            data:
+              T::Array[
+                Telnyx::Models::AI::CollectionRetrieveDocumentsResponse::Data::OrHash
+              ]
+          ).void
+        end
+        attr_writer :data
+
+        sig do
+          returns(
+            T.nilable(
+              Telnyx::Models::AI::CollectionRetrieveDocumentsResponse::Meta
+            )
+          )
+        end
+        attr_reader :meta
+
+        sig do
+          params(
+            meta:
+              Telnyx::Models::AI::CollectionRetrieveDocumentsResponse::Meta::OrHash
+          ).void
+        end
+        attr_writer :meta
+
+        sig do
+          params(
+            data:
+              T::Array[
+                Telnyx::Models::AI::CollectionRetrieveDocumentsResponse::Data::OrHash
+              ],
+            meta:
+              Telnyx::Models::AI::CollectionRetrieveDocumentsResponse::Meta::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(data: nil, meta: nil)
+        end
+
+        sig do
+          override.returns(
+            {
+              data:
+                T::Array[
+                  Telnyx::Models::AI::CollectionRetrieveDocumentsResponse::Data
+                ],
+              meta:
+                Telnyx::Models::AI::CollectionRetrieveDocumentsResponse::Meta
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Data < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::Models::AI::CollectionRetrieveDocumentsResponse::Data,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :id
+
+          sig { params(id: String).void }
+          attr_writer :id
+
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :chunk_index
+
+          sig { params(chunk_index: Integer).void }
+          attr_writer :chunk_index
+
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :chunk_total
+
+          sig { params(chunk_total: Integer).void }
+          attr_writer :chunk_total
+
+          sig { returns(T.nilable(Time)) }
+          attr_reader :ingested_at
+
+          sig { params(ingested_at: Time).void }
+          attr_writer :ingested_at
+
+          sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+          attr_reader :metadata
+
+          sig { params(metadata: T::Hash[Symbol, T.anything]).void }
+          attr_writer :metadata
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :organization_id
+
+          sig { params(organization_id: String).void }
+          attr_writer :organization_id
+
+          sig { returns(T.nilable(Time)) }
+          attr_reader :record_created_at
+
+          sig { params(record_created_at: Time).void }
+          attr_writer :record_created_at
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :record_id
+
+          sig { params(record_id: String).void }
+          attr_writer :record_id
+
+          # The source record kind this chunk came from (e.g. `voice`, `meeting_bot`,
+          # `message`).
+          sig { returns(T.nilable(String)) }
+          attr_reader :record_type
+
+          sig { params(record_type: String).void }
+          attr_writer :record_type
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :region
+
+          sig { params(region: String).void }
+          attr_writer :region
+
+          # Relevance score (higher = more relevant) for ranked search. `0.0` for plain
+          # catalog listings (when `query` is omitted).
+          sig { returns(T.nilable(Float)) }
+          attr_reader :score
+
+          sig { params(score: Float).void }
+          attr_writer :score
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :text
+
+          sig { params(text: String).void }
+          attr_writer :text
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :user_id
+
+          sig { params(user_id: String).void }
+          attr_writer :user_id
+
+          sig do
+            params(
+              id: String,
+              chunk_index: Integer,
+              chunk_total: Integer,
+              ingested_at: Time,
+              metadata: T::Hash[Symbol, T.anything],
+              organization_id: String,
+              record_created_at: Time,
+              record_id: String,
+              record_type: String,
+              region: String,
+              score: Float,
+              text: String,
+              user_id: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            id: nil,
+            chunk_index: nil,
+            chunk_total: nil,
+            ingested_at: nil,
+            metadata: nil,
+            organization_id: nil,
+            record_created_at: nil,
+            record_id: nil,
+            # The source record kind this chunk came from (e.g. `voice`, `meeting_bot`,
+            # `message`).
+            record_type: nil,
+            region: nil,
+            # Relevance score (higher = more relevant) for ranked search. `0.0` for plain
+            # catalog listings (when `query` is omitted).
+            score: nil,
+            text: nil,
+            user_id: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                chunk_index: Integer,
+                chunk_total: Integer,
+                ingested_at: Time,
+                metadata: T::Hash[Symbol, T.anything],
+                organization_id: String,
+                record_created_at: Time,
+                record_id: String,
+                record_type: String,
+                region: String,
+                score: Float,
+                text: String,
+                user_id: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        class Meta < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::Models::AI::CollectionRetrieveDocumentsResponse::Meta,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :collection_slug
+
+          sig { params(collection_slug: String).void }
+          attr_writer :collection_slug
+
+          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
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :retrieval_type
+
+          sig { params(retrieval_type: String).void }
+          attr_writer :retrieval_type
+
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_reader :searched_sources
+
+          sig { params(searched_sources: T::Array[String]).void }
+          attr_writer :searched_sources
+
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :top_k
+
+          sig { params(top_k: Integer).void }
+          attr_writer :top_k
+
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :total_pages
+
+          sig { params(total_pages: Integer).void }
+          attr_writer :total_pages
+
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :total_results
+
+          sig { params(total_results: Integer).void }
+          attr_writer :total_results
+
+          sig do
+            params(
+              collection_slug: String,
+              page_number: Integer,
+              page_size: Integer,
+              retrieval_type: String,
+              searched_sources: T::Array[String],
+              top_k: Integer,
+              total_pages: Integer,
+              total_results: Integer
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            collection_slug: nil,
+            page_number: nil,
+            page_size: nil,
+            retrieval_type: nil,
+            searched_sources: nil,
+            top_k: nil,
+            total_pages: nil,
+            total_results: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                collection_slug: String,
+                page_number: Integer,
+                page_size: Integer,
+                retrieval_type: String,
+                searched_sources: T::Array[String],
+                top_k: Integer,
+                total_pages: Integer,
+                total_results: Integer
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/collection_retrieve_params.rbi

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

data/rbi/telnyx/models/ai/collection_update_params.rbi

@@ -0,0 +1,56 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      class CollectionUpdateParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Telnyx::AI::CollectionUpdateParams, Telnyx::Internal::AnyHash)
+          end
+
+        sig { returns(String) }
+        attr_accessor :uuid
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :description
+
+        sig { params(description: String).void }
+        attr_writer :description
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :name
+
+        sig { params(name: String).void }
+        attr_writer :name
+
+        sig do
+          params(
+            uuid: String,
+            description: String,
+            name: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(uuid:, description: nil, name: nil, request_options: {})
+        end
+
+        sig do
+          override.returns(
+            {
+              uuid: String,
+              description: String,
+              name: String,
+              request_options: Telnyx::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end