turbopuffer-ruby 0.2.0.pre.alpha.1

data/rbi/turbopuffer/models/query.rbi

@@ -0,0 +1,106 @@
+# typed: strong
+
+module Turbopuffer
+  module Models
+    class Query < Turbopuffer::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Turbopuffer::Query, Turbopuffer::Internal::AnyHash)
+        end
+
+      # Aggregations to compute over all documents in the namespace that match the
+      # filters.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_reader :aggregate_by
+
+      sig { params(aggregate_by: T::Hash[Symbol, T.anything]).void }
+      attr_writer :aggregate_by
+
+      # A function used to calculate vector similarity.
+      sig { returns(T.nilable(Turbopuffer::DistanceMetric::OrSymbol)) }
+      attr_reader :distance_metric
+
+      sig do
+        params(distance_metric: Turbopuffer::DistanceMetric::OrSymbol).void
+      end
+      attr_writer :distance_metric
+
+      # Exact filters for attributes to refine search results for. Think of it as a SQL
+      # WHERE clause.
+      sig { returns(T.nilable(T.anything)) }
+      attr_reader :filters
+
+      sig { params(filters: T.anything).void }
+      attr_writer :filters
+
+      # Whether to include attributes in the response.
+      sig { returns(T.nilable(Turbopuffer::IncludeAttributes::Variants)) }
+      attr_reader :include_attributes
+
+      sig do
+        params(
+          include_attributes: Turbopuffer::IncludeAttributes::Variants
+        ).void
+      end
+      attr_writer :include_attributes
+
+      # How to rank the documents in the namespace.
+      sig { returns(T.nilable(T.anything)) }
+      attr_reader :rank_by
+
+      sig { params(rank_by: T.anything).void }
+      attr_writer :rank_by
+
+      # The number of results to return.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :top_k
+
+      sig { params(top_k: Integer).void }
+      attr_writer :top_k
+
+      # Query, filter, full-text search and vector search documents.
+      sig do
+        params(
+          aggregate_by: T::Hash[Symbol, T.anything],
+          distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
+          filters: T.anything,
+          include_attributes: Turbopuffer::IncludeAttributes::Variants,
+          rank_by: T.anything,
+          top_k: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Aggregations to compute over all documents in the namespace that match the
+        # filters.
+        aggregate_by: nil,
+        # A function used to calculate vector similarity.
+        distance_metric: nil,
+        # Exact filters for attributes to refine search results for. Think of it as a SQL
+        # WHERE clause.
+        filters: nil,
+        # Whether to include attributes in the response.
+        include_attributes: nil,
+        # How to rank the documents in the namespace.
+        rank_by: nil,
+        # The number of results to return.
+        top_k: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            aggregate_by: T::Hash[Symbol, T.anything],
+            distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
+            filters: T.anything,
+            include_attributes: Turbopuffer::IncludeAttributes::Variants,
+            rank_by: T.anything,
+            top_k: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/turbopuffer/models/query_billing.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module Turbopuffer
+  module Models
+    class QueryBilling < Turbopuffer::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Turbopuffer::QueryBilling, Turbopuffer::Internal::AnyHash)
+        end
+
+      # The number of billable logical bytes queried from the namespace.
+      sig { returns(Integer) }
+      attr_accessor :billable_logical_bytes_queried
+
+      # The number of billable logical bytes returned from the query.
+      sig { returns(Integer) }
+      attr_accessor :billable_logical_bytes_returned
+
+      # The billing information for a query.
+      sig do
+        params(
+          billable_logical_bytes_queried: Integer,
+          billable_logical_bytes_returned: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The number of billable logical bytes queried from the namespace.
+        billable_logical_bytes_queried:,
+        # The number of billable logical bytes returned from the query.
+        billable_logical_bytes_returned:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            billable_logical_bytes_queried: Integer,
+            billable_logical_bytes_returned: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/turbopuffer/models/query_performance.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Turbopuffer
+  module Models
+    class QueryPerformance < Turbopuffer::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Turbopuffer::QueryPerformance, Turbopuffer::Internal::AnyHash)
+        end
+
+      # the approximate number of documents in the namespace.
+      sig { returns(Integer) }
+      attr_accessor :approx_namespace_size
+
+      # The ratio of cache hits to total cache lookups.
+      sig { returns(Float) }
+      attr_accessor :cache_hit_ratio
+
+      # A qualitative description of the cache hit ratio (`hot`, `warm`, or `cold`).
+      sig { returns(String) }
+      attr_accessor :cache_temperature
+
+      # The number of unindexed documents processed by the query.
+      sig { returns(Integer) }
+      attr_accessor :exhaustive_search_count
+
+      # Request time measured on the server, excluding time spent waiting due to the
+      # namespace concurrency limit.
+      sig { returns(Integer) }
+      attr_accessor :query_execution_ms
+
+      # Request time measured on the server, including time spent waiting for other
+      # queries to complete if the namespace was at its concurrency limit.
+      sig { returns(Integer) }
+      attr_accessor :server_total_ms
+
+      # The performance information for a query.
+      sig do
+        params(
+          approx_namespace_size: Integer,
+          cache_hit_ratio: Float,
+          cache_temperature: String,
+          exhaustive_search_count: Integer,
+          query_execution_ms: Integer,
+          server_total_ms: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # the approximate number of documents in the namespace.
+        approx_namespace_size:,
+        # The ratio of cache hits to total cache lookups.
+        cache_hit_ratio:,
+        # A qualitative description of the cache hit ratio (`hot`, `warm`, or `cold`).
+        cache_temperature:,
+        # The number of unindexed documents processed by the query.
+        exhaustive_search_count:,
+        # Request time measured on the server, excluding time spent waiting due to the
+        # namespace concurrency limit.
+        query_execution_ms:,
+        # Request time measured on the server, including time spent waiting for other
+        # queries to complete if the namespace was at its concurrency limit.
+        server_total_ms:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            approx_namespace_size: Integer,
+            cache_hit_ratio: Float,
+            cache_temperature: String,
+            exhaustive_search_count: Integer,
+            query_execution_ms: Integer,
+            server_total_ms: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/turbopuffer/models/row.rbi

@@ -0,0 +1,47 @@
+# typed: strong
+
+module Turbopuffer
+  module Models
+    class Row < Turbopuffer::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Turbopuffer::Row, Turbopuffer::Internal::AnyHash) }
+
+      # An identifier for a document.
+      sig { returns(Turbopuffer::ID::Variants) }
+      attr_accessor :id
+
+      # A vector embedding associated with a document.
+      sig { returns(T.nilable(Turbopuffer::Vector::Variants)) }
+      attr_reader :vector
+
+      sig { params(vector: Turbopuffer::Vector::Variants).void }
+      attr_writer :vector
+
+      # A single document, in a row-based format.
+      sig do
+        params(
+          id: Turbopuffer::ID::Variants,
+          vector: Turbopuffer::Vector::Variants
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # An identifier for a document.
+        id:,
+        # A vector embedding associated with a document.
+        vector: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: Turbopuffer::ID::Variants,
+            vector: Turbopuffer::Vector::Variants
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/turbopuffer/models/tokenizer.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module Turbopuffer
+  module Models
+    # The tokenizer to use for full-text search on an attribute.
+    module Tokenizer
+      extend Turbopuffer::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Turbopuffer::Tokenizer) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      PRE_TOKENIZED_ARRAY =
+        T.let(:pre_tokenized_array, Turbopuffer::Tokenizer::TaggedSymbol)
+      WORD_V0 = T.let(:word_v0, Turbopuffer::Tokenizer::TaggedSymbol)
+      WORD_V1 = T.let(:word_v1, Turbopuffer::Tokenizer::TaggedSymbol)
+
+      sig { override.returns(T::Array[Turbopuffer::Tokenizer::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/turbopuffer/models/vector.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module Turbopuffer
+  module Models
+    # A vector embedding associated with a document.
+    module Vector
+      extend Turbopuffer::Internal::Type::Union
+
+      Variants = T.type_alias { T.any(T::Array[Float], String) }
+
+      sig { override.returns(T::Array[Turbopuffer::Vector::Variants]) }
+      def self.variants
+      end
+
+      FloatArray =
+        T.let(
+          Turbopuffer::Internal::Type::ArrayOf[Float],
+          Turbopuffer::Internal::Type::Converter
+        )
+    end
+  end
+end

data/rbi/turbopuffer/models/vector_encoding.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module Turbopuffer
+  module Models
+    # The encoding to use for vectors in the response.
+    module VectorEncoding
+      extend Turbopuffer::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Turbopuffer::VectorEncoding) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      FLOAT = T.let(:float, Turbopuffer::VectorEncoding::TaggedSymbol)
+      BASE64 = T.let(:base64, Turbopuffer::VectorEncoding::TaggedSymbol)
+
+      sig do
+        override.returns(T::Array[Turbopuffer::VectorEncoding::TaggedSymbol])
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/turbopuffer/models/write_billing.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Turbopuffer
+  module Models
+    class WriteBilling < Turbopuffer::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Turbopuffer::WriteBilling, Turbopuffer::Internal::AnyHash)
+        end
+
+      # The number of billable logical bytes written to the namespace.
+      sig { returns(Integer) }
+      attr_accessor :billable_logical_bytes_written
+
+      # The billing information for a query.
+      sig { returns(T.nilable(Turbopuffer::QueryBilling)) }
+      attr_reader :query
+
+      sig { params(query: Turbopuffer::QueryBilling::OrHash).void }
+      attr_writer :query
+
+      # The billing information for a write request.
+      sig do
+        params(
+          billable_logical_bytes_written: Integer,
+          query: Turbopuffer::QueryBilling::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The number of billable logical bytes written to the namespace.
+        billable_logical_bytes_written:,
+        # The billing information for a query.
+        query: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            billable_logical_bytes_written: Integer,
+            query: Turbopuffer::QueryBilling
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/turbopuffer/models.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Turbopuffer
+  AttributeSchema = Turbopuffer::Models::AttributeSchema
+
+  AttributeSchemaConfig = Turbopuffer::Models::AttributeSchemaConfig
+
+  AttributeType = Turbopuffer::Models::AttributeType
+
+  ClientNamespacesParams = Turbopuffer::Models::ClientNamespacesParams
+
+  Columns = Turbopuffer::Models::Columns
+
+  DistanceMetric = Turbopuffer::Models::DistanceMetric
+
+  FullTextSearch = Turbopuffer::Models::FullTextSearch
+
+  FullTextSearchConfig = Turbopuffer::Models::FullTextSearchConfig
+
+  ID = Turbopuffer::Models::ID
+
+  IncludeAttributes = Turbopuffer::Models::IncludeAttributes
+
+  Language = Turbopuffer::Models::Language
+
+  NamespaceDeleteAllParams = Turbopuffer::Models::NamespaceDeleteAllParams
+
+  NamespaceHintCacheWarmParams =
+    Turbopuffer::Models::NamespaceHintCacheWarmParams
+
+  NamespaceMetadata = Turbopuffer::Models::NamespaceMetadata
+
+  NamespaceMetadataParams = Turbopuffer::Models::NamespaceMetadataParams
+
+  NamespaceMultiQueryParams = Turbopuffer::Models::NamespaceMultiQueryParams
+
+  NamespaceQueryParams = Turbopuffer::Models::NamespaceQueryParams
+
+  NamespaceRecallParams = Turbopuffer::Models::NamespaceRecallParams
+
+  NamespaceSchemaParams = Turbopuffer::Models::NamespaceSchemaParams
+
+  NamespaceSummary = Turbopuffer::Models::NamespaceSummary
+
+  NamespaceUpdateSchemaParams = Turbopuffer::Models::NamespaceUpdateSchemaParams
+
+  NamespaceWriteParams = Turbopuffer::Models::NamespaceWriteParams
+
+  Query = Turbopuffer::Models::Query
+
+  QueryBilling = Turbopuffer::Models::QueryBilling
+
+  QueryPerformance = Turbopuffer::Models::QueryPerformance
+
+  Row = Turbopuffer::Models::Row
+
+  Tokenizer = Turbopuffer::Models::Tokenizer
+
+  Vector = Turbopuffer::Models::Vector
+
+  VectorEncoding = Turbopuffer::Models::VectorEncoding
+
+  WriteBilling = Turbopuffer::Models::WriteBilling
+end

data/rbi/turbopuffer/namespace.rbi

@@ -0,0 +1,8 @@
+# typed: strong
+
+module Turbopuffer
+  class Namespace < Turbopuffer::Resources::Namespaces
+    sig { returns(String) }
+    attr_reader :id
+  end
+end

data/rbi/turbopuffer/request_options.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Turbopuffer
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < Turbopuffer::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias do
+        T.any(Turbopuffer::RequestOptions, Turbopuffer::Internal::AnyHash)
+      end
+
+    # @api private
+    sig { params(opts: Turbopuffer::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig do
+      params(values: Turbopuffer::Internal::AnyHash).returns(T.attached_class)
+    end
+    def self.new(values = {})
+    end
+  end
+end