turbopuffer 2.2.0 → 2.4.0

data/rbi/turbopuffer/models/highlight_config_params.rbi

@@ -0,0 +1,85 @@
+# typed: strong
+
+module Turbopuffer
+  module Models
+    class HighlightConfigParams < Turbopuffer::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Turbopuffer::HighlightConfigParams,
+            Turbopuffer::Internal::AnyHash
+          )
+        end
+
+      # How to split a text attribute into fragments for highlighting.
+      sig { returns(T.nilable(Turbopuffer::HighlightFragmentBy::OrSymbol)) }
+      attr_reader :fragment_by
+
+      sig do
+        params(fragment_by: Turbopuffer::HighlightFragmentBy::OrSymbol).void
+      end
+      attr_writer :fragment_by
+
+      # The maximum number of fragments to return. Defaults to `3`.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :fragment_limit
+
+      sig { params(fragment_limit: Integer).void }
+      attr_writer :fragment_limit
+
+      # The units to report highlighted fragment offsets in.
+      sig { returns(T.nilable(Turbopuffer::HighlightOffsetUnits::OrSymbol)) }
+      attr_reader :include_offsets
+
+      sig do
+        params(
+          include_offsets: Turbopuffer::HighlightOffsetUnits::OrSymbol
+        ).void
+      end
+      attr_writer :include_offsets
+
+      # How to rank candidate fragments within the attribute before selecting the top
+      # `fragment_limit`. Defaults to the query's `rank_by`.
+      sig { returns(T.nilable(T.anything)) }
+      attr_reader :rank_fragments_by
+
+      sig { params(rank_fragments_by: T.anything).void }
+      attr_writer :rank_fragments_by
+
+      # Additional (optional) parameters for the Highlight compute expression.
+      sig do
+        params(
+          fragment_by: Turbopuffer::HighlightFragmentBy::OrSymbol,
+          fragment_limit: Integer,
+          include_offsets: Turbopuffer::HighlightOffsetUnits::OrSymbol,
+          rank_fragments_by: T.anything
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # How to split a text attribute into fragments for highlighting.
+        fragment_by: nil,
+        # The maximum number of fragments to return. Defaults to `3`.
+        fragment_limit: nil,
+        # The units to report highlighted fragment offsets in.
+        include_offsets: nil,
+        # How to rank candidate fragments within the attribute before selecting the top
+        # `fragment_limit`. Defaults to the query's `rank_by`.
+        rank_fragments_by: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            fragment_by: Turbopuffer::HighlightFragmentBy::OrSymbol,
+            fragment_limit: Integer,
+            include_offsets: Turbopuffer::HighlightOffsetUnits::OrSymbol,
+            rank_fragments_by: T.anything
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/turbopuffer/models/highlight_fragment_by.rbi

@@ -0,0 +1,36 @@
+# typed: strong
+
+module Turbopuffer
+  module Models
+    # How to split a text attribute into fragments for highlighting.
+    module HighlightFragmentBy
+      extend Turbopuffer::Internal::Type::Enum
+
+      TaggedSymbol =
+        T.type_alias { T.all(Symbol, Turbopuffer::HighlightFragmentBy) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      # Treat the whole attribute as a single fragment.
+      NONE = T.let(:none, Turbopuffer::HighlightFragmentBy::TaggedSymbol)
+
+      # Split the attribute into sentences. This is the default.
+      SENTENCE =
+        T.let(:sentence, Turbopuffer::HighlightFragmentBy::TaggedSymbol)
+
+      # Split the attribute into paragraphs.
+      PARAGRAPH =
+        T.let(:paragraph, Turbopuffer::HighlightFragmentBy::TaggedSymbol)
+
+      # Split the attribute into individual words.
+      WORD = T.let(:word, Turbopuffer::HighlightFragmentBy::TaggedSymbol)
+
+      sig do
+        override.returns(
+          T::Array[Turbopuffer::HighlightFragmentBy::TaggedSymbol]
+        )
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/turbopuffer/models/highlight_offset_units.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Turbopuffer
+  module Models
+    # The units to report highlighted fragment offsets in.
+    module HighlightOffsetUnits
+      extend Turbopuffer::Internal::Type::Enum
+
+      TaggedSymbol =
+        T.type_alias { T.all(Symbol, Turbopuffer::HighlightOffsetUnits) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      UTF_8 = T.let(:"utf-8", Turbopuffer::HighlightOffsetUnits::TaggedSymbol)
+      UTF_16 = T.let(:"utf-16", Turbopuffer::HighlightOffsetUnits::TaggedSymbol)
+      CODEPOINTS =
+        T.let(:codepoints, Turbopuffer::HighlightOffsetUnits::TaggedSymbol)
+
+      sig do
+        override.returns(
+          T::Array[Turbopuffer::HighlightOffsetUnits::TaggedSymbol]
+        )
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/turbopuffer/models/namespace_copy_from_params.rbi

@@ -24,6 +24,30 @@ module Turbopuffer
       sig { returns(String) }
       attr_accessor :source_namespace
 
+      # (Optional) The encryption configuration for the destination namespace.
+      sig do
+        returns(
+          T.nilable(
+            T.any(
+              Turbopuffer::Encryption::CustomerManaged,
+              Turbopuffer::Encryption::Default
+            )
+          )
+        )
+      end
+      attr_reader :dest_encryption
+
+      sig do
+        params(
+          dest_encryption:
+            T.any(
+              Turbopuffer::Encryption::CustomerManaged::OrHash,
+              Turbopuffer::Encryption::Default::OrHash
+            )
+        ).void
+      end
+      attr_writer :dest_encryption
+
       # (Optional) An API key for the organization containing the source namespace
       sig { returns(T.nilable(String)) }
       attr_reader :source_api_key
@@ -42,6 +66,11 @@ module Turbopuffer
         params(
           source_namespace: String,
           namespace: String,
+          dest_encryption:
+            T.any(
+              Turbopuffer::Encryption::CustomerManaged::OrHash,
+              Turbopuffer::Encryption::Default::OrHash
+            ),
           source_api_key: String,
           source_region: String,
           request_options: Turbopuffer::RequestOptions::OrHash
@@ -51,6 +80,8 @@ module Turbopuffer
         # The namespace to copy documents from.
         source_namespace:,
         namespace: nil,
+        # (Optional) The encryption configuration for the destination namespace.
+        dest_encryption: nil,
         # (Optional) An API key for the organization containing the source namespace
         source_api_key: nil,
         # (Optional) The region of the source namespace.
@@ -64,6 +95,11 @@ module Turbopuffer
           {
             namespace: String,
             source_namespace: String,
+            dest_encryption:
+              T.any(
+                Turbopuffer::Encryption::CustomerManaged,
+                Turbopuffer::Encryption::Default
+              ),
             source_api_key: String,
             source_region: String,
             request_options: Turbopuffer::RequestOptions

data/rbi/turbopuffer/models/namespace_explain_query_params.rbi

@@ -28,6 +28,15 @@ module Turbopuffer
       sig { params(aggregate_by: T::Hash[Symbol, T.anything]).void }
       attr_writer :aggregate_by
 
+      # Computes additional values on documents returned by a query. Each key is the
+      # name of the computed attribute; each value is an expression describing how to
+      # compute it.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_reader :compute_attributes
+
+      sig { params(compute_attributes: T::Hash[Symbol, T.anything]).void }
+      attr_writer :compute_attributes
+
       # The consistency level for a query.
       sig do
         returns(
@@ -122,6 +131,7 @@ module Turbopuffer
         params(
           namespace: String,
           aggregate_by: T::Hash[Symbol, T.anything],
+          compute_attributes: T::Hash[Symbol, T.anything],
           consistency:
             Turbopuffer::NamespaceExplainQueryParams::Consistency::OrHash,
           distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
@@ -141,6 +151,10 @@ module Turbopuffer
         # Aggregations to compute over all documents in the namespace that match the
         # filters.
         aggregate_by: nil,
+        # Computes additional values on documents returned by a query. Each key is the
+        # name of the computed attribute; each value is an expression describing how to
+        # compute it.
+        compute_attributes: nil,
         # The consistency level for a query.
         consistency: nil,
         # A function used to calculate vector similarity.
@@ -173,6 +187,7 @@ module Turbopuffer
           {
             namespace: String,
             aggregate_by: T::Hash[Symbol, T.anything],
+            compute_attributes: T::Hash[Symbol, T.anything],
             consistency: Turbopuffer::NamespaceExplainQueryParams::Consistency,
             distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
             exclude_attributes: T::Array[String],

data/rbi/turbopuffer/models/namespace_metadata.rbi

@@ -45,6 +45,16 @@ module Turbopuffer
       end
       attr_writer :pinning
 
+      # Configuration for namespace sharding, which partitions a namespace's documents
+      # across multiple internal shards to scale indexing and query throughput beyond a
+      # single machine. Sharding can only be configured on a namespace's inaugural
+      # write, and cannot be added to or changed on an existing namespace.
+      sig { returns(T.nilable(Turbopuffer::ShardingConfig)) }
+      attr_reader :sharding
+
+      sig { params(sharding: Turbopuffer::ShardingConfig::OrHash).void }
+      attr_writer :sharding
+
       # Metadata about a namespace.
       sig do
         params(
@@ -63,7 +73,8 @@ module Turbopuffer
             ),
           schema: T::Hash[Symbol, Turbopuffer::AttributeSchemaConfig::OrHash],
           updated_at: Time,
-          pinning: Turbopuffer::NamespaceMetadata::Pinning::OrHash
+          pinning: Turbopuffer::NamespaceMetadata::Pinning::OrHash,
+          sharding: Turbopuffer::ShardingConfig::OrHash
         ).returns(T.attached_class)
       end
       def self.new(
@@ -82,7 +93,12 @@ module Turbopuffer
         updated_at:,
         # Configuration for namespace pinning, along with the current status of the pinned
         # namespace.
-        pinning: nil
+        pinning: nil,
+        # Configuration for namespace sharding, which partitions a namespace's documents
+        # across multiple internal shards to scale indexing and query throughput beyond a
+        # single machine. Sharding can only be configured on a namespace's inaugural
+        # write, and cannot be added to or changed on an existing namespace.
+        sharding: nil
       )
       end
 
@@ -96,7 +112,8 @@ module Turbopuffer
             index: Turbopuffer::NamespaceMetadata::Index::Variants,
             schema: T::Hash[Symbol, Turbopuffer::AttributeSchemaConfig],
             updated_at: Time,
-            pinning: Turbopuffer::NamespaceMetadata::Pinning
+            pinning: Turbopuffer::NamespaceMetadata::Pinning,
+            sharding: Turbopuffer::ShardingConfig
           }
         )
       end

data/rbi/turbopuffer/models/namespace_multi_query_params.rbi

@@ -110,6 +110,15 @@ module Turbopuffer
         sig { params(aggregate_by: T::Hash[Symbol, T.anything]).void }
         attr_writer :aggregate_by
 
+        # Computes additional values on documents returned by a query. Each key is the
+        # name of the computed attribute; each value is an expression describing how to
+        # compute it.
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_reader :compute_attributes
+
+        sig { params(compute_attributes: T::Hash[Symbol, T.anything]).void }
+        attr_writer :compute_attributes
+
         # A function used to calculate vector similarity.
         sig { returns(T.nilable(Turbopuffer::DistanceMetric::OrSymbol)) }
         attr_reader :distance_metric
@@ -179,6 +188,7 @@ module Turbopuffer
         sig do
           params(
             aggregate_by: T::Hash[Symbol, T.anything],
+            compute_attributes: T::Hash[Symbol, T.anything],
             distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
             exclude_attributes: T::Array[String],
             filters: T.anything,
@@ -193,6 +203,10 @@ module Turbopuffer
           # Aggregations to compute over all documents in the namespace that match the
           # filters.
           aggregate_by: nil,
+          # Computes additional values on documents returned by a query. Each key is the
+          # name of the computed attribute; each value is an expression describing how to
+          # compute it.
+          compute_attributes: nil,
           # A function used to calculate vector similarity.
           distance_metric: nil,
           # List of attribute names to exclude from the response. All other attributes will
@@ -219,6 +233,7 @@ module Turbopuffer
           override.returns(
             {
               aggregate_by: T::Hash[Symbol, T.anything],
+              compute_attributes: T::Hash[Symbol, T.anything],
               distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
               exclude_attributes: T::Array[String],
               filters: T.anything,

data/rbi/turbopuffer/models/namespace_query_params.rbi

@@ -28,6 +28,15 @@ module Turbopuffer
       sig { params(aggregate_by: T::Hash[Symbol, T.anything]).void }
       attr_writer :aggregate_by
 
+      # Computes additional values on documents returned by a query. Each key is the
+      # name of the computed attribute; each value is an expression describing how to
+      # compute it.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_reader :compute_attributes
+
+      sig { params(compute_attributes: T::Hash[Symbol, T.anything]).void }
+      attr_writer :compute_attributes
+
       # The consistency level for a query.
       sig { returns(T.nilable(Turbopuffer::NamespaceQueryParams::Consistency)) }
       attr_reader :consistency
@@ -117,6 +126,7 @@ module Turbopuffer
         params(
           namespace: String,
           aggregate_by: T::Hash[Symbol, T.anything],
+          compute_attributes: T::Hash[Symbol, T.anything],
           consistency: Turbopuffer::NamespaceQueryParams::Consistency::OrHash,
           distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
           exclude_attributes: T::Array[String],
@@ -135,6 +145,10 @@ module Turbopuffer
         # Aggregations to compute over all documents in the namespace that match the
         # filters.
         aggregate_by: nil,
+        # Computes additional values on documents returned by a query. Each key is the
+        # name of the computed attribute; each value is an expression describing how to
+        # compute it.
+        compute_attributes: nil,
         # The consistency level for a query.
         consistency: nil,
         # A function used to calculate vector similarity.
@@ -167,6 +181,7 @@ module Turbopuffer
           {
             namespace: String,
             aggregate_by: T::Hash[Symbol, T.anything],
+            compute_attributes: T::Hash[Symbol, T.anything],
             consistency: Turbopuffer::NamespaceQueryParams::Consistency,
             distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
             exclude_attributes: T::Array[String],

data/rbi/turbopuffer/models/namespace_write_params.rbi

@@ -209,6 +209,16 @@ module Turbopuffer
       end
       attr_writer :schema
 
+      # Configuration for namespace sharding, which partitions a namespace's documents
+      # across multiple internal shards to scale indexing and query throughput beyond a
+      # single machine. Sharding can only be configured on a namespace's inaugural
+      # write, and cannot be added to or changed on an existing namespace.
+      sig { returns(T.nilable(Turbopuffer::ShardingConfig)) }
+      attr_reader :sharding
+
+      sig { params(sharding: Turbopuffer::ShardingConfig::OrHash).void }
+      attr_writer :sharding
+
       # 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)) }
@@ -267,6 +277,7 @@ module Turbopuffer
               Symbol,
               T.any(String, Turbopuffer::AttributeSchemaConfig::OrHash)
             ],
+          sharding: Turbopuffer::ShardingConfig::OrHash,
           upsert_columns: Turbopuffer::Columns::OrHash,
           upsert_condition: T.anything,
           upsert_rows: T::Array[Turbopuffer::Row::OrHash],
@@ -310,6 +321,11 @@ module Turbopuffer
         return_affected_ids: nil,
         # The schema of the attributes attached to the documents.
         schema: nil,
+        # Configuration for namespace sharding, which partitions a namespace's documents
+        # across multiple internal shards to scale indexing and query throughput beyond a
+        # single machine. Sharding can only be configured on a namespace's inaugural
+        # write, and cannot be added to or changed on an existing namespace.
+        sharding: nil,
         # A list of documents in columnar format. Each key is a column name, mapped to an
         # array of values for that column.
         upsert_columns: nil,
@@ -357,6 +373,7 @@ module Turbopuffer
                 Symbol,
                 T.any(String, Turbopuffer::AttributeSchemaConfig)
               ],
+            sharding: Turbopuffer::ShardingConfig,
             upsert_columns: Turbopuffer::Columns,
             upsert_condition: T.anything,
             upsert_rows: T::Array[Turbopuffer::Row],

data/rbi/turbopuffer/models/rrf_params.rbi

@@ -15,15 +15,34 @@ module Turbopuffer
       sig { params(rank_constant: Integer).void }
       attr_writer :rank_constant
 
+      # A positive weight for each subquery, in the same order as `queries`. The number
+      # of weights must match the number of subqueries. When omitted, every subquery has
+      # a weight of `1`.
+      sig { returns(T.nilable(T::Array[Float])) }
+      attr_reader :weights
+
+      sig { params(weights: T::Array[Float]).void }
+      attr_writer :weights
+
       # Configuration options for RRF.
-      sig { params(rank_constant: Integer).returns(T.attached_class) }
+      sig do
+        params(rank_constant: Integer, weights: T::Array[Float]).returns(
+          T.attached_class
+        )
+      end
       def self.new(
         # RRF rank constant (`k`). Must be greater than zero. Defaults to `60`.
-        rank_constant: nil
+        rank_constant: nil,
+        # A positive weight for each subquery, in the same order as `queries`. The number
+        # of weights must match the number of subqueries. When omitted, every subquery has
+        # a weight of `1`.
+        weights: nil
       )
       end
 
-      sig { override.returns({ rank_constant: Integer }) }
+      sig do
+        override.returns({ rank_constant: Integer, weights: T::Array[Float] })
+      end
       def to_hash
       end
     end

data/rbi/turbopuffer/models/sharding_config.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Turbopuffer
+  module Models
+    class ShardingConfig < Turbopuffer::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Turbopuffer::ShardingConfig, Turbopuffer::Internal::AnyHash)
+        end
+
+      # The number of shards to partition the namespace into.
+      sig { returns(Integer) }
+      attr_accessor :num_shards
+
+      # Configuration for namespace sharding, which partitions a namespace's documents
+      # across multiple internal shards to scale indexing and query throughput beyond a
+      # single machine. Sharding can only be configured on a namespace's inaugural
+      # write, and cannot be added to or changed on an existing namespace.
+      sig { params(num_shards: Integer).returns(T.attached_class) }
+      def self.new(
+        # The number of shards to partition the namespace into.
+        num_shards:
+      )
+      end
+
+      sig { override.returns({ num_shards: Integer }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/turbopuffer/models.rbi

@@ -49,6 +49,12 @@ module Turbopuffer
 
   FuzzyParams = Turbopuffer::Models::FuzzyParams
 
+  HighlightConfigParams = Turbopuffer::Models::HighlightConfigParams
+
+  HighlightFragmentBy = Turbopuffer::Models::HighlightFragmentBy
+
+  HighlightOffsetUnits = Turbopuffer::Models::HighlightOffsetUnits
+
   ID = Turbopuffer::Models::ID
 
   IncludeAttributes = Turbopuffer::Models::IncludeAttributes
@@ -103,6 +109,8 @@ module Turbopuffer
 
   SaturateParams = Turbopuffer::Models::SaturateParams
 
+  ShardingConfig = Turbopuffer::Models::ShardingConfig
+
   SparseDistanceMetric = Turbopuffer::Models::SparseDistanceMetric
 
   Tokenizer = Turbopuffer::Models::Tokenizer

data/rbi/turbopuffer/resources/namespaces.rbi

@@ -25,6 +25,11 @@ module Turbopuffer
         params(
           source_namespace: String,
           namespace: String,
+          dest_encryption:
+            T.any(
+              Turbopuffer::Encryption::CustomerManaged::OrHash,
+              Turbopuffer::Encryption::Default::OrHash
+            ),
           source_api_key: String,
           source_region: String,
           request_options: Turbopuffer::RequestOptions::OrHash
@@ -35,6 +40,9 @@ module Turbopuffer
         source_namespace:,
         # Path param: The name of the namespace.
         namespace: nil,
+        # Body param: (Optional) The encryption configuration for the destination
+        # namespace.
+        dest_encryption: nil,
         # Body param: (Optional) An API key for the organization containing the source
         # namespace
         source_api_key: nil,
@@ -63,6 +71,7 @@ module Turbopuffer
         params(
           namespace: String,
           aggregate_by: T::Hash[Symbol, T.anything],
+          compute_attributes: T::Hash[Symbol, T.anything],
           consistency:
             Turbopuffer::NamespaceExplainQueryParams::Consistency::OrHash,
           distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
@@ -83,6 +92,10 @@ module Turbopuffer
         # Body param: Aggregations to compute over all documents in the namespace that
         # match the filters.
         aggregate_by: nil,
+        # Body param: Computes additional values on documents returned by a query. Each
+        # key is the name of the computed attribute; each value is an expression
+        # describing how to compute it.
+        compute_attributes: nil,
         # Body param: The consistency level for a query.
         consistency: nil,
         # Body param: A function used to calculate vector similarity.
@@ -172,6 +185,7 @@ module Turbopuffer
         params(
           namespace: T.nilable(String),
           aggregate_by: T::Hash[Symbol, T.anything],
+          compute_attributes: T::Hash[Symbol, T.anything],
           consistency: Turbopuffer::NamespaceQueryParams::Consistency::OrHash,
           distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
           exclude_attributes: T::Array[String],
@@ -191,6 +205,10 @@ module Turbopuffer
         # Body param: Aggregations to compute over all documents in the namespace that
         # match the filters.
         aggregate_by: nil,
+        # Body param: Computes additional values on documents returned by a query. Each
+        # key is the name of the computed attribute; each value is an expression
+        # describing how to compute it.
+        compute_attributes: nil,
         # Body param: The consistency level for a query.
         consistency: nil,
         # Body param: A function used to calculate vector similarity.
@@ -344,6 +362,7 @@ module Turbopuffer
               Symbol,
               T.any(String, Turbopuffer::AttributeSchemaConfig::OrHash)
             ],
+          sharding: Turbopuffer::ShardingConfig::OrHash,
           upsert_columns: Turbopuffer::Columns::OrHash,
           upsert_condition: T.anything,
           upsert_rows: T::Array[Turbopuffer::Row::OrHash],
@@ -391,6 +410,11 @@ module Turbopuffer
         return_affected_ids: nil,
         # Body param: The schema of the attributes attached to the documents.
         schema: nil,
+        # Body param: Configuration for namespace sharding, which partitions a namespace's
+        # documents across multiple internal shards to scale indexing and query throughput
+        # beyond a single machine. Sharding can only be configured on a namespace's
+        # inaugural write, and cannot be added to or changed on an existing namespace.
+        sharding: 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.
         upsert_columns: nil,

data/sig/turbopuffer/models/attribute_schema_config.rbs

@@ -82,7 +82,10 @@ module Turbopuffer
         extend Turbopuffer::Internal::Type::Union
 
         type ann_config =
-          { distance_metric: Turbopuffer::Models::distance_metric }
+          {
+            distance_metric: Turbopuffer::Models::distance_metric,
+            late_interaction: bool
+          }
 
         class AnnConfig < Turbopuffer::Internal::Type::BaseModel
           attr_reader distance_metric: Turbopuffer::Models::distance_metric?
@@ -91,12 +94,18 @@ module Turbopuffer
             Turbopuffer::Models::distance_metric
           ) -> Turbopuffer::Models::distance_metric
 
+          attr_reader late_interaction: bool?
+
+          def late_interaction=: (bool) -> bool
+
           def initialize: (
-            ?distance_metric: Turbopuffer::Models::distance_metric
+            ?distance_metric: Turbopuffer::Models::distance_metric,
+            ?late_interaction: bool
           ) -> void
 
           def to_hash: -> {
-            distance_metric: Turbopuffer::Models::distance_metric
+            distance_metric: Turbopuffer::Models::distance_metric,
+            late_interaction: bool
           }
         end