turbopuffer 1.4.0 → 1.6.0

data/rbi/turbopuffer/models/attribute_schema_config.rbi

@@ -11,11 +11,35 @@ module Turbopuffer
           )
         end
 
-      # Whether to create an approximate nearest neighbor index for the attribute.
-      sig { returns(T.nilable(T::Boolean)) }
+      # The data type of the attribute. Valid values: string, int, uint, float, uuid,
+      # datetime, bool, []string, []int, []uint, []float, []uuid, []datetime, []bool,
+      # [DIMS]f16, [DIMS]f32.
+      sig { returns(String) }
+      attr_accessor :type
+
+      # Whether to create an approximate nearest neighbor index for the attribute. Can
+      # be a boolean or a detailed configuration object.
+      sig do
+        returns(
+          T.nilable(
+            T.any(
+              T::Boolean,
+              Turbopuffer::AttributeSchemaConfig::Ann::AnnConfig
+            )
+          )
+        )
+      end
       attr_reader :ann
 
-      sig { params(ann: T::Boolean).void }
+      sig do
+        params(
+          ann:
+            T.any(
+              T::Boolean,
+              Turbopuffer::AttributeSchemaConfig::Ann::AnnConfig::OrHash
+            )
+        ).void
+      end
       attr_writer :ann
 
       # Whether or not the attributes can be used in filters.
@@ -48,28 +72,28 @@ module Turbopuffer
       sig { params(regex: T::Boolean).void }
       attr_writer :regex
 
-      # The data type of the attribute. Valid values: string, int, uint, float, uuid,
-      # datetime, bool, []string, []int, []uint, []float, []uuid, []datetime, []bool,
-      # [DIMS]f16, [DIMS]f32.
-      sig { returns(T.nilable(String)) }
-      attr_reader :type
-
-      sig { params(type: String).void }
-      attr_writer :type
-
       # Detailed configuration for an attribute attached to a document.
       sig do
         params(
-          ann: T::Boolean,
+          type: String,
+          ann:
+            T.any(
+              T::Boolean,
+              Turbopuffer::AttributeSchemaConfig::Ann::AnnConfig::OrHash
+            ),
           filterable: T::Boolean,
           full_text_search:
             T.any(T::Boolean, Turbopuffer::FullTextSearchConfig::OrHash),
-          regex: T::Boolean,
-          type: String
+          regex: T::Boolean
         ).returns(T.attached_class)
       end
       def self.new(
-        # Whether to create an approximate nearest neighbor index for the attribute.
+        # The data type of the attribute. Valid values: string, int, uint, float, uuid,
+        # datetime, bool, []string, []int, []uint, []float, []uuid, []datetime, []bool,
+        # [DIMS]f16, [DIMS]f32.
+        type:,
+        # Whether to create an approximate nearest neighbor index for the attribute. Can
+        # be a boolean or a detailed configuration object.
         ann: nil,
         # Whether or not the attributes can be used in filters.
         filterable: nil,
@@ -78,28 +102,89 @@ module Turbopuffer
         # filterable. You can override this by setting `filterable: true`.
         full_text_search: nil,
         # Whether to enable Regex filters on this attribute.
-        regex: nil,
-        # The data type of the attribute. Valid values: string, int, uint, float, uuid,
-        # datetime, bool, []string, []int, []uint, []float, []uuid, []datetime, []bool,
-        # [DIMS]f16, [DIMS]f32.
-        type: nil
+        regex: nil
       )
       end
 
       sig do
         override.returns(
           {
-            ann: T::Boolean,
+            type: String,
+            ann:
+              T.any(
+                T::Boolean,
+                Turbopuffer::AttributeSchemaConfig::Ann::AnnConfig
+              ),
             filterable: T::Boolean,
             full_text_search:
               T.any(T::Boolean, Turbopuffer::FullTextSearchConfig),
-            regex: T::Boolean,
-            type: String
+            regex: T::Boolean
           }
         )
       end
       def to_hash
       end
+
+      # Whether to create an approximate nearest neighbor index for the attribute. Can
+      # be a boolean or a detailed configuration object.
+      module Ann
+        extend Turbopuffer::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              T::Boolean,
+              Turbopuffer::AttributeSchemaConfig::Ann::AnnConfig
+            )
+          end
+
+        class AnnConfig < Turbopuffer::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Turbopuffer::AttributeSchemaConfig::Ann::AnnConfig,
+                Turbopuffer::Internal::AnyHash
+              )
+            end
+
+          # 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
+
+          # Configuration options for ANN (Approximate Nearest Neighbor) indexing.
+          sig do
+            params(
+              distance_metric: Turbopuffer::DistanceMetric::OrSymbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # A function used to calculate vector similarity.
+            distance_metric: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              { distance_metric: Turbopuffer::DistanceMetric::OrSymbol }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        sig do
+          override.returns(
+            T::Array[Turbopuffer::AttributeSchemaConfig::Ann::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
     end
   end
 end

data/rbi/turbopuffer/models/namespace_metadata.rbi

@@ -20,17 +20,40 @@ module Turbopuffer
       sig { returns(Time) }
       attr_accessor :created_at
 
+      # Indicates that the namespace is encrypted with a customer-managed encryption key
+      # (CMEK).
+      sig { returns(Turbopuffer::NamespaceMetadata::Encryption::Variants) }
+      attr_accessor :encryption
+
+      sig { returns(Turbopuffer::NamespaceMetadata::Index::Variants) }
+      attr_accessor :index
+
       # The schema of the namespace.
       sig { returns(T::Hash[Symbol, Turbopuffer::AttributeSchemaConfig]) }
       attr_accessor :schema
 
+      # The timestamp when the namespace was last modified by a write operation.
+      sig { returns(Time) }
+      attr_accessor :updated_at
+
       # Metadata about a namespace.
       sig do
         params(
           approx_logical_bytes: Integer,
           approx_row_count: Integer,
           created_at: Time,
-          schema: T::Hash[Symbol, Turbopuffer::AttributeSchemaConfig::OrHash]
+          encryption:
+            T.any(
+              Turbopuffer::NamespaceMetadata::Encryption::Sse::OrHash,
+              Turbopuffer::NamespaceMetadata::Encryption::Cmek::OrHash
+            ),
+          index:
+            T.any(
+              Turbopuffer::NamespaceMetadata::Index::IndexUpToDate::OrHash,
+              Turbopuffer::NamespaceMetadata::Index::IndexUpdating::OrHash
+            ),
+          schema: T::Hash[Symbol, Turbopuffer::AttributeSchemaConfig::OrHash],
+          updated_at: Time
         ).returns(T.attached_class)
       end
       def self.new(
@@ -40,8 +63,14 @@ module Turbopuffer
         approx_row_count:,
         # The timestamp when the namespace was created.
         created_at:,
+        # Indicates that the namespace is encrypted with a customer-managed encryption key
+        # (CMEK).
+        encryption:,
+        index:,
         # The schema of the namespace.
-        schema:
+        schema:,
+        # The timestamp when the namespace was last modified by a write operation.
+        updated_at:
       )
       end
 
@@ -51,12 +80,205 @@ module Turbopuffer
             approx_logical_bytes: Integer,
             approx_row_count: Integer,
             created_at: Time,
-            schema: T::Hash[Symbol, Turbopuffer::AttributeSchemaConfig]
+            encryption: Turbopuffer::NamespaceMetadata::Encryption::Variants,
+            index: Turbopuffer::NamespaceMetadata::Index::Variants,
+            schema: T::Hash[Symbol, Turbopuffer::AttributeSchemaConfig],
+            updated_at: Time
           }
         )
       end
       def to_hash
       end
+
+      # Indicates that the namespace is encrypted with a customer-managed encryption key
+      # (CMEK).
+      module Encryption
+        extend Turbopuffer::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              Turbopuffer::NamespaceMetadata::Encryption::Sse,
+              Turbopuffer::NamespaceMetadata::Encryption::Cmek
+            )
+          end
+
+        class Sse < Turbopuffer::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Turbopuffer::NamespaceMetadata::Encryption::Sse,
+                Turbopuffer::Internal::AnyHash
+              )
+            end
+
+          # Always true. Indicates that the namespace is encrypted with SSE.
+          sig { returns(T::Boolean) }
+          attr_accessor :sse
+
+          sig { params(sse: T::Boolean).returns(T.attached_class) }
+          def self.new(
+            # Always true. Indicates that the namespace is encrypted with SSE.
+            sse:
+          )
+          end
+
+          sig { override.returns({ sse: T::Boolean }) }
+          def to_hash
+          end
+        end
+
+        class Cmek < Turbopuffer::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Turbopuffer::NamespaceMetadata::Encryption::Cmek,
+                Turbopuffer::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(Turbopuffer::NamespaceMetadata::Encryption::Cmek::Cmek)
+          end
+          attr_reader :cmek
+
+          sig do
+            params(
+              cmek:
+                Turbopuffer::NamespaceMetadata::Encryption::Cmek::Cmek::OrHash
+            ).void
+          end
+          attr_writer :cmek
+
+          # Indicates that the namespace is encrypted with a customer-managed encryption key
+          # (CMEK).
+          sig do
+            params(
+              cmek:
+                Turbopuffer::NamespaceMetadata::Encryption::Cmek::Cmek::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(cmek:)
+          end
+
+          sig do
+            override.returns(
+              { cmek: Turbopuffer::NamespaceMetadata::Encryption::Cmek::Cmek }
+            )
+          end
+          def to_hash
+          end
+
+          class Cmek < Turbopuffer::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Turbopuffer::NamespaceMetadata::Encryption::Cmek::Cmek,
+                  Turbopuffer::Internal::AnyHash
+                )
+              end
+
+            # The name of the CMEK key in use.
+            sig { returns(String) }
+            attr_accessor :key_name
+
+            sig { params(key_name: String).returns(T.attached_class) }
+            def self.new(
+              # The name of the CMEK key in use.
+              key_name:
+            )
+            end
+
+            sig { override.returns({ key_name: String }) }
+            def to_hash
+            end
+          end
+        end
+
+        sig do
+          override.returns(
+            T::Array[Turbopuffer::NamespaceMetadata::Encryption::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+
+      module Index
+        extend Turbopuffer::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              Turbopuffer::NamespaceMetadata::Index::IndexUpToDate,
+              Turbopuffer::NamespaceMetadata::Index::IndexUpdating
+            )
+          end
+
+        class IndexUpToDate < Turbopuffer::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Turbopuffer::NamespaceMetadata::Index::IndexUpToDate,
+                Turbopuffer::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Symbol) }
+          attr_accessor :status
+
+          sig { params(status: Symbol).returns(T.attached_class) }
+          def self.new(status: :"up-to-date")
+          end
+
+          sig { override.returns({ status: Symbol }) }
+          def to_hash
+          end
+        end
+
+        class IndexUpdating < Turbopuffer::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Turbopuffer::NamespaceMetadata::Index::IndexUpdating,
+                Turbopuffer::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Symbol) }
+          attr_accessor :status
+
+          # The number of bytes in the namespace that are in the write-ahead log but have
+          # not yet been indexed.
+          sig { returns(Integer) }
+          attr_accessor :unindexed_bytes
+
+          sig do
+            params(unindexed_bytes: Integer, status: Symbol).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # The number of bytes in the namespace that are in the write-ahead log but have
+            # not yet been indexed.
+            unindexed_bytes:,
+            status: :updating
+          )
+          end
+
+          sig { override.returns({ status: Symbol, unindexed_bytes: Integer }) }
+          def to_hash
+          end
+        end
+
+        sig do
+          override.returns(
+            T::Array[Turbopuffer::NamespaceMetadata::Index::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
     end
   end
 end

data/rbi/turbopuffer/models/namespace_write_params.rbi

@@ -75,6 +75,20 @@ module Turbopuffer
       end
       attr_writer :encryption
 
+      # The patch and filter specifying which documents to patch.
+      sig do
+        returns(T.nilable(Turbopuffer::NamespaceWriteParams::PatchByFilter))
+      end
+      attr_reader :patch_by_filter
+
+      sig do
+        params(
+          patch_by_filter:
+            Turbopuffer::NamespaceWriteParams::PatchByFilter::OrHash
+        ).void
+      end
+      attr_writer :patch_by_filter
+
       # A list of documents in columnar format. Each key is a column name, mapped to an
       # array of values for that column.
       sig { returns(T.nilable(Turbopuffer::Columns)) }
@@ -150,6 +164,8 @@ module Turbopuffer
           disable_backpressure: T::Boolean,
           distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
           encryption: Turbopuffer::NamespaceWriteParams::Encryption::OrHash,
+          patch_by_filter:
+            Turbopuffer::NamespaceWriteParams::PatchByFilter::OrHash,
           patch_columns: Turbopuffer::Columns::OrHash,
           patch_condition: T.anything,
           patch_rows: T::Array[Turbopuffer::Row::OrHash],
@@ -180,6 +196,8 @@ module Turbopuffer
         distance_metric: nil,
         # The encryption configuration for a namespace.
         encryption: nil,
+        # The patch and filter specifying which documents to patch.
+        patch_by_filter: nil,
         # A list of documents in columnar format. Each key is a column name, mapped to an
         # array of values for that column.
         patch_columns: nil,
@@ -211,6 +229,7 @@ module Turbopuffer
             disable_backpressure: T::Boolean,
             distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
             encryption: Turbopuffer::NamespaceWriteParams::Encryption,
+            patch_by_filter: Turbopuffer::NamespaceWriteParams::PatchByFilter,
             patch_columns: Turbopuffer::Columns,
             patch_condition: T.anything,
             patch_rows: T::Array[Turbopuffer::Row],
@@ -296,6 +315,45 @@ module Turbopuffer
           end
         end
       end
+
+      class PatchByFilter < Turbopuffer::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Turbopuffer::NamespaceWriteParams::PatchByFilter,
+              Turbopuffer::Internal::AnyHash
+            )
+          end
+
+        # Filter by attributes. Same syntax as the query endpoint.
+        sig { returns(T.anything) }
+        attr_accessor :filters
+
+        sig { returns(T::Hash[Symbol, T.anything]) }
+        attr_accessor :patch
+
+        # The patch and filter specifying which documents to patch.
+        sig do
+          params(
+            filters: T.anything,
+            patch: T::Hash[Symbol, T.anything]
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Filter by attributes. Same syntax as the query endpoint.
+          filters:,
+          patch:
+        )
+        end
+
+        sig do
+          override.returns(
+            { filters: T.anything, patch: T::Hash[Symbol, T.anything] }
+          )
+        end
+        def to_hash
+        end
+      end
     end
   end
 end

data/rbi/turbopuffer/resources/namespaces.rbi

@@ -243,6 +243,8 @@ module Turbopuffer
           disable_backpressure: T::Boolean,
           distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
           encryption: Turbopuffer::NamespaceWriteParams::Encryption::OrHash,
+          patch_by_filter:
+            Turbopuffer::NamespaceWriteParams::PatchByFilter::OrHash,
           patch_columns: Turbopuffer::Columns::OrHash,
           patch_condition: T.anything,
           patch_rows: T::Array[Turbopuffer::Row::OrHash],
@@ -276,6 +278,8 @@ module Turbopuffer
         distance_metric: nil,
         # Body param: The encryption configuration for a namespace.
         encryption: nil,
+        # Body param: The patch and filter specifying which documents to patch.
+        patch_by_filter: nil,
         # Body param: A list of documents in columnar format. Each key is a column name,
         # mapped to an array of values for that column.
         patch_columns: nil,

data/sig/turbopuffer/internal/transport/base_client.rbs

@@ -87,6 +87,8 @@ module Turbopuffer
 
         private def auth_headers: -> ::Hash[String, String]
 
+        private def user_agent: -> String
+
         private def generate_idempotency_key: -> String
 
         private def build_request: (

data/sig/turbopuffer/internal/transport/pooled_net_requester.rbs

@@ -17,7 +17,10 @@ module Turbopuffer
 
         DEFAULT_MAX_CONNECTIONS: Integer
 
-        def self.connect: (URI::Generic url) -> top
+        def self.connect: (
+          cert_store: OpenSSL::X509::Store,
+          url: URI::Generic
+        ) -> top
 
         def self.calibrate_socket_timeout: (top conn, Float deadline) -> void
 

data/sig/turbopuffer/models/attribute_schema_config.rbs

@@ -2,17 +2,21 @@ module Turbopuffer
   module Models
     type attribute_schema_config =
       {
-        ann: bool,
+        type: String,
+        ann: Turbopuffer::Models::AttributeSchemaConfig::ann,
         filterable: bool,
         full_text_search: Turbopuffer::Models::full_text_search,
-        regex: bool,
-        type: String
+        regex: bool
       }
 
     class AttributeSchemaConfig < Turbopuffer::Internal::Type::BaseModel
-      attr_reader ann: bool?
+      attr_accessor type: String
 
-      def ann=: (bool) -> bool
+      attr_reader ann: Turbopuffer::Models::AttributeSchemaConfig::ann?
+
+      def ann=: (
+        Turbopuffer::Models::AttributeSchemaConfig::ann
+      ) -> Turbopuffer::Models::AttributeSchemaConfig::ann
 
       attr_reader filterable: bool?
 
@@ -28,25 +32,48 @@ module Turbopuffer
 
       def regex=: (bool) -> bool
 
-      attr_reader type: String?
-
-      def type=: (String) -> String
-
       def initialize: (
-        ?ann: bool,
+        type: String,
+        ?ann: Turbopuffer::Models::AttributeSchemaConfig::ann,
         ?filterable: bool,
         ?full_text_search: Turbopuffer::Models::full_text_search,
-        ?regex: bool,
-        ?type: String
+        ?regex: bool
       ) -> void
 
       def to_hash: -> {
-        ann: bool,
+        type: String,
+        ann: Turbopuffer::Models::AttributeSchemaConfig::ann,
         filterable: bool,
         full_text_search: Turbopuffer::Models::full_text_search,
-        regex: bool,
-        type: String
+        regex: bool
       }
+
+      type ann = bool | Turbopuffer::AttributeSchemaConfig::Ann::AnnConfig
+
+      module Ann
+        extend Turbopuffer::Internal::Type::Union
+
+        type ann_config =
+          { distance_metric: Turbopuffer::Models::distance_metric }
+
+        class AnnConfig < Turbopuffer::Internal::Type::BaseModel
+          attr_reader distance_metric: Turbopuffer::Models::distance_metric?
+
+          def distance_metric=: (
+            Turbopuffer::Models::distance_metric
+          ) -> Turbopuffer::Models::distance_metric
+
+          def initialize: (
+            ?distance_metric: Turbopuffer::Models::distance_metric
+          ) -> void
+
+          def to_hash: -> {
+            distance_metric: Turbopuffer::Models::distance_metric
+          }
+        end
+
+        def self?.variants: -> ::Array[Turbopuffer::Models::AttributeSchemaConfig::ann]
+      end
     end
   end
 end