turbopuffer 2.9.0 → 2.10.0

data/rbi/turbopuffer/models/encryption.rbi

@@ -31,17 +31,44 @@ module Turbopuffer
         sig { returns(Symbol) }
         attr_accessor :mode
 
+        # The AWS KMS encryption context to send with every request that uses the key.
+        # Only supported on AWS, and must be enabled for your organization. Keys may not
+        # start with `tpuf:` or `aws:`.
+        sig { returns(T.nilable(T::Hash[Symbol, String])) }
+        attr_reader :encryption_context
+
+        sig { params(encryption_context: T::Hash[Symbol, String]).void }
+        attr_writer :encryption_context
+
         # Encrypt the namespace with a customer-managed encryption key (CMEK).
-        sig { params(key_name: String, mode: Symbol).returns(T.attached_class) }
+        sig do
+          params(
+            key_name: String,
+            encryption_context: T::Hash[Symbol, String],
+            mode: Symbol
+          ).returns(T.attached_class)
+        end
         def self.new(
           # The identifier of the CMEK key to use for encryption. For GCP, the
           # fully-qualified resource name of the key. For AWS, the ARN of the key.
           key_name:,
+          # The AWS KMS encryption context to send with every request that uses the key.
+          # Only supported on AWS, and must be enabled for your organization. Keys may not
+          # start with `tpuf:` or `aws:`.
+          encryption_context: nil,
           mode: :"customer-managed"
         )
         end
 
-        sig { override.returns({ key_name: String, mode: Symbol }) }
+        sig do
+          override.returns(
+            {
+              key_name: String,
+              mode: Symbol,
+              encryption_context: T::Hash[Symbol, String]
+            }
+          )
+        end
         def to_hash
         end
       end

data/rbi/turbopuffer/models/namespace_explain_query_params.rbi

@@ -40,7 +40,12 @@ module Turbopuffer
       # The consistency level for a query.
       sig do
         returns(
-          T.nilable(Turbopuffer::NamespaceExplainQueryParams::Consistency)
+          T.nilable(
+            T.any(
+              Turbopuffer::NamespaceExplainQueryParams::Consistency::Strong,
+              Turbopuffer::NamespaceExplainQueryParams::Consistency::Eventual
+            )
+          )
         )
       end
       attr_reader :consistency
@@ -48,7 +53,10 @@ module Turbopuffer
       sig do
         params(
           consistency:
-            Turbopuffer::NamespaceExplainQueryParams::Consistency::OrHash
+            T.any(
+              Turbopuffer::NamespaceExplainQueryParams::Consistency::Strong::OrHash,
+              Turbopuffer::NamespaceExplainQueryParams::Consistency::Eventual::OrHash
+            )
         ).void
       end
       attr_writer :consistency
@@ -141,7 +149,10 @@ module Turbopuffer
           aggregate_by: T::Hash[Symbol, T.anything],
           compute_attributes: T::Hash[Symbol, T.anything],
           consistency:
-            Turbopuffer::NamespaceExplainQueryParams::Consistency::OrHash,
+            T.any(
+              Turbopuffer::NamespaceExplainQueryParams::Consistency::Strong::OrHash,
+              Turbopuffer::NamespaceExplainQueryParams::Consistency::Eventual::OrHash
+            ),
           distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
           exclude_attributes: T::Array[String],
           filters: T.anything,
@@ -200,7 +211,11 @@ module Turbopuffer
             namespace: String,
             aggregate_by: T::Hash[Symbol, T.anything],
             compute_attributes: T::Hash[Symbol, T.anything],
-            consistency: Turbopuffer::NamespaceExplainQueryParams::Consistency,
+            consistency:
+              T.any(
+                Turbopuffer::NamespaceExplainQueryParams::Consistency::Strong,
+                Turbopuffer::NamespaceExplainQueryParams::Consistency::Eventual
+              ),
             distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
             exclude_attributes: T::Array[String],
             filters: T.anything,
@@ -218,94 +233,92 @@ module Turbopuffer
       def to_hash
       end
 
-      class Consistency < Turbopuffer::Internal::Type::BaseModel
-        OrHash =
+      # The consistency level for a query.
+      module Consistency
+        extend Turbopuffer::Internal::Type::Union
+
+        Variants =
           T.type_alias do
             T.any(
-              Turbopuffer::NamespaceExplainQueryParams::Consistency,
-              Turbopuffer::Internal::AnyHash
+              Turbopuffer::NamespaceExplainQueryParams::Consistency::Strong,
+              Turbopuffer::NamespaceExplainQueryParams::Consistency::Eventual
             )
           end
 
-        # The query's consistency level.
-        sig do
-          returns(
-            T.nilable(
-              Turbopuffer::NamespaceExplainQueryParams::Consistency::Level::OrSymbol
-            )
-          )
-        end
-        attr_reader :level
+        class Strong < Turbopuffer::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Turbopuffer::NamespaceExplainQueryParams::Consistency::Strong,
+                Turbopuffer::Internal::AnyHash
+              )
+            end
 
-        sig do
-          params(
-            level:
-              Turbopuffer::NamespaceExplainQueryParams::Consistency::Level::OrSymbol
-          ).void
-        end
-        attr_writer :level
+          sig { returns(Symbol) }
+          attr_accessor :level
 
-        # The consistency level for a query.
-        sig do
-          params(
-            level:
-              Turbopuffer::NamespaceExplainQueryParams::Consistency::Level::OrSymbol
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The query's consistency level.
-          level: nil
-        )
-        end
+          # Strong consistency. Requires a round-trip to object storage to fetch the latest
+          # writes.
+          sig { params(level: Symbol).returns(T.attached_class) }
+          def self.new(level: :strong)
+          end
 
-        sig do
-          override.returns(
-            {
-              level:
-                Turbopuffer::NamespaceExplainQueryParams::Consistency::Level::OrSymbol
-            }
-          )
-        end
-        def to_hash
+          sig { override.returns({ level: Symbol }) }
+          def to_hash
+          end
         end
 
-        # The query's consistency level.
-        module Level
-          extend Turbopuffer::Internal::Type::Enum
-
-          TaggedSymbol =
+        class Eventual < Turbopuffer::Internal::Type::BaseModel
+          OrHash =
             T.type_alias do
-              T.all(
-                Symbol,
-                Turbopuffer::NamespaceExplainQueryParams::Consistency::Level
+              T.any(
+                Turbopuffer::NamespaceExplainQueryParams::Consistency::Eventual,
+                Turbopuffer::Internal::AnyHash
               )
             end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          # Strong consistency. Requires a round-trip to object storage to fetch the latest writes.
-          STRONG =
-            T.let(
-              :strong,
-              Turbopuffer::NamespaceExplainQueryParams::Consistency::Level::TaggedSymbol
-            )
+          sig { returns(Symbol) }
+          attr_accessor :level
 
-          # Eventual consistency. Does not require a round-trip to object storage, but may not see the latest writes.
-          EVENTUAL =
-            T.let(
-              :eventual,
-              Turbopuffer::NamespaceExplainQueryParams::Consistency::Level::TaggedSymbol
-            )
+          # How long the query may reuse the node's cached view of the namespace before
+          # refreshing it from object storage. Defaults to 60.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :max_staleness_seconds
 
+          sig { params(max_staleness_seconds: Integer).void }
+          attr_writer :max_staleness_seconds
+
+          # Eventual consistency. Does not require a round-trip to object storage, but may
+          # not see the latest writes.
           sig do
-            override.returns(
-              T::Array[
-                Turbopuffer::NamespaceExplainQueryParams::Consistency::Level::TaggedSymbol
-              ]
+            params(max_staleness_seconds: Integer, level: Symbol).returns(
+              T.attached_class
             )
           end
-          def self.values
+          def self.new(
+            # How long the query may reuse the node's cached view of the namespace before
+            # refreshing it from object storage. Defaults to 60.
+            max_staleness_seconds: nil,
+            level: :eventual
+          )
+          end
+
+          sig do
+            override.returns({ level: Symbol, max_staleness_seconds: Integer })
+          end
+          def to_hash
           end
         end
+
+        sig do
+          override.returns(
+            T::Array[
+              Turbopuffer::NamespaceExplainQueryParams::Consistency::Variants
+            ]
+          )
+        end
+        def self.variants
+        end
       end
 
       # Limits the documents returned by a query.

data/rbi/turbopuffer/models/namespace_multi_query_params.rbi

@@ -25,14 +25,24 @@ module Turbopuffer
 
       # The consistency level for a query.
       sig do
-        returns(T.nilable(Turbopuffer::NamespaceMultiQueryParams::Consistency))
+        returns(
+          T.nilable(
+            T.any(
+              Turbopuffer::NamespaceMultiQueryParams::Consistency::Strong,
+              Turbopuffer::NamespaceMultiQueryParams::Consistency::Eventual
+            )
+          )
+        )
       end
       attr_reader :consistency
 
       sig do
         params(
           consistency:
-            Turbopuffer::NamespaceMultiQueryParams::Consistency::OrHash
+            T.any(
+              Turbopuffer::NamespaceMultiQueryParams::Consistency::Strong::OrHash,
+              Turbopuffer::NamespaceMultiQueryParams::Consistency::Eventual::OrHash
+            )
         ).void
       end
       attr_writer :consistency
@@ -76,7 +86,10 @@ module Turbopuffer
             T::Array[Turbopuffer::NamespaceMultiQueryParams::Query::OrHash],
           namespace: String,
           consistency:
-            Turbopuffer::NamespaceMultiQueryParams::Consistency::OrHash,
+            T.any(
+              Turbopuffer::NamespaceMultiQueryParams::Consistency::Strong::OrHash,
+              Turbopuffer::NamespaceMultiQueryParams::Consistency::Eventual::OrHash
+            ),
           limit: T.any(Integer, Turbopuffer::RerankLimit::OrHash),
           offset: Integer,
           rerank_by: T.anything,
@@ -107,7 +120,11 @@ module Turbopuffer
           {
             namespace: String,
             queries: T::Array[Turbopuffer::NamespaceMultiQueryParams::Query],
-            consistency: Turbopuffer::NamespaceMultiQueryParams::Consistency,
+            consistency:
+              T.any(
+                Turbopuffer::NamespaceMultiQueryParams::Consistency::Strong,
+                Turbopuffer::NamespaceMultiQueryParams::Consistency::Eventual
+              ),
             limit: T.any(Integer, Turbopuffer::RerankLimit),
             offset: Integer,
             rerank_by: T.anything,
@@ -305,94 +322,92 @@ module Turbopuffer
         end
       end
 
-      class Consistency < Turbopuffer::Internal::Type::BaseModel
-        OrHash =
+      # The consistency level for a query.
+      module Consistency
+        extend Turbopuffer::Internal::Type::Union
+
+        Variants =
           T.type_alias do
             T.any(
-              Turbopuffer::NamespaceMultiQueryParams::Consistency,
-              Turbopuffer::Internal::AnyHash
+              Turbopuffer::NamespaceMultiQueryParams::Consistency::Strong,
+              Turbopuffer::NamespaceMultiQueryParams::Consistency::Eventual
             )
           end
 
-        # The query's consistency level.
-        sig do
-          returns(
-            T.nilable(
-              Turbopuffer::NamespaceMultiQueryParams::Consistency::Level::OrSymbol
-            )
-          )
-        end
-        attr_reader :level
+        class Strong < Turbopuffer::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Turbopuffer::NamespaceMultiQueryParams::Consistency::Strong,
+                Turbopuffer::Internal::AnyHash
+              )
+            end
 
-        sig do
-          params(
-            level:
-              Turbopuffer::NamespaceMultiQueryParams::Consistency::Level::OrSymbol
-          ).void
-        end
-        attr_writer :level
+          sig { returns(Symbol) }
+          attr_accessor :level
 
-        # The consistency level for a query.
-        sig do
-          params(
-            level:
-              Turbopuffer::NamespaceMultiQueryParams::Consistency::Level::OrSymbol
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The query's consistency level.
-          level: nil
-        )
-        end
+          # Strong consistency. Requires a round-trip to object storage to fetch the latest
+          # writes.
+          sig { params(level: Symbol).returns(T.attached_class) }
+          def self.new(level: :strong)
+          end
 
-        sig do
-          override.returns(
-            {
-              level:
-                Turbopuffer::NamespaceMultiQueryParams::Consistency::Level::OrSymbol
-            }
-          )
-        end
-        def to_hash
+          sig { override.returns({ level: Symbol }) }
+          def to_hash
+          end
         end
 
-        # The query's consistency level.
-        module Level
-          extend Turbopuffer::Internal::Type::Enum
-
-          TaggedSymbol =
+        class Eventual < Turbopuffer::Internal::Type::BaseModel
+          OrHash =
             T.type_alias do
-              T.all(
-                Symbol,
-                Turbopuffer::NamespaceMultiQueryParams::Consistency::Level
+              T.any(
+                Turbopuffer::NamespaceMultiQueryParams::Consistency::Eventual,
+                Turbopuffer::Internal::AnyHash
               )
             end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          # Strong consistency. Requires a round-trip to object storage to fetch the latest writes.
-          STRONG =
-            T.let(
-              :strong,
-              Turbopuffer::NamespaceMultiQueryParams::Consistency::Level::TaggedSymbol
-            )
+          sig { returns(Symbol) }
+          attr_accessor :level
 
-          # Eventual consistency. Does not require a round-trip to object storage, but may not see the latest writes.
-          EVENTUAL =
-            T.let(
-              :eventual,
-              Turbopuffer::NamespaceMultiQueryParams::Consistency::Level::TaggedSymbol
-            )
+          # How long the query may reuse the node's cached view of the namespace before
+          # refreshing it from object storage. Defaults to 60.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :max_staleness_seconds
+
+          sig { params(max_staleness_seconds: Integer).void }
+          attr_writer :max_staleness_seconds
 
+          # Eventual consistency. Does not require a round-trip to object storage, but may
+          # not see the latest writes.
           sig do
-            override.returns(
-              T::Array[
-                Turbopuffer::NamespaceMultiQueryParams::Consistency::Level::TaggedSymbol
-              ]
+            params(max_staleness_seconds: Integer, level: Symbol).returns(
+              T.attached_class
             )
           end
-          def self.values
+          def self.new(
+            # How long the query may reuse the node's cached view of the namespace before
+            # refreshing it from object storage. Defaults to 60.
+            max_staleness_seconds: nil,
+            level: :eventual
+          )
+          end
+
+          sig do
+            override.returns({ level: Symbol, max_staleness_seconds: Integer })
+          end
+          def to_hash
           end
         end
+
+        sig do
+          override.returns(
+            T::Array[
+              Turbopuffer::NamespaceMultiQueryParams::Consistency::Variants
+            ]
+          )
+        end
+        def self.variants
+        end
       end
 
       # Limits the total number of reranked documents returned.

data/rbi/turbopuffer/models/namespace_query_params.rbi

@@ -38,12 +38,25 @@ module Turbopuffer
       attr_writer :compute_attributes
 
       # The consistency level for a query.
-      sig { returns(T.nilable(Turbopuffer::NamespaceQueryParams::Consistency)) }
+      sig do
+        returns(
+          T.nilable(
+            T.any(
+              Turbopuffer::NamespaceQueryParams::Consistency::Strong,
+              Turbopuffer::NamespaceQueryParams::Consistency::Eventual
+            )
+          )
+        )
+      end
       attr_reader :consistency
 
       sig do
         params(
-          consistency: Turbopuffer::NamespaceQueryParams::Consistency::OrHash
+          consistency:
+            T.any(
+              Turbopuffer::NamespaceQueryParams::Consistency::Strong::OrHash,
+              Turbopuffer::NamespaceQueryParams::Consistency::Eventual::OrHash
+            )
         ).void
       end
       attr_writer :consistency
@@ -142,7 +155,11 @@ module Turbopuffer
           namespace: String,
           aggregate_by: T::Hash[Symbol, T.anything],
           compute_attributes: T::Hash[Symbol, T.anything],
-          consistency: Turbopuffer::NamespaceQueryParams::Consistency::OrHash,
+          consistency:
+            T.any(
+              Turbopuffer::NamespaceQueryParams::Consistency::Strong::OrHash,
+              Turbopuffer::NamespaceQueryParams::Consistency::Eventual::OrHash
+            ),
           distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
           exclude_attributes: T::Array[String],
           filters: T.anything,
@@ -204,7 +221,11 @@ module Turbopuffer
             namespace: String,
             aggregate_by: T::Hash[Symbol, T.anything],
             compute_attributes: T::Hash[Symbol, T.anything],
-            consistency: Turbopuffer::NamespaceQueryParams::Consistency,
+            consistency:
+              T.any(
+                Turbopuffer::NamespaceQueryParams::Consistency::Strong,
+                Turbopuffer::NamespaceQueryParams::Consistency::Eventual
+              ),
             distance_metric: Turbopuffer::DistanceMetric::OrSymbol,
             exclude_attributes: T::Array[String],
             filters: T.anything,
@@ -223,94 +244,90 @@ module Turbopuffer
       def to_hash
       end
 
-      class Consistency < Turbopuffer::Internal::Type::BaseModel
-        OrHash =
+      # The consistency level for a query.
+      module Consistency
+        extend Turbopuffer::Internal::Type::Union
+
+        Variants =
           T.type_alias do
             T.any(
-              Turbopuffer::NamespaceQueryParams::Consistency,
-              Turbopuffer::Internal::AnyHash
+              Turbopuffer::NamespaceQueryParams::Consistency::Strong,
+              Turbopuffer::NamespaceQueryParams::Consistency::Eventual
             )
           end
 
-        # The query's consistency level.
-        sig do
-          returns(
-            T.nilable(
-              Turbopuffer::NamespaceQueryParams::Consistency::Level::OrSymbol
-            )
-          )
-        end
-        attr_reader :level
+        class Strong < Turbopuffer::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Turbopuffer::NamespaceQueryParams::Consistency::Strong,
+                Turbopuffer::Internal::AnyHash
+              )
+            end
 
-        sig do
-          params(
-            level:
-              Turbopuffer::NamespaceQueryParams::Consistency::Level::OrSymbol
-          ).void
-        end
-        attr_writer :level
+          sig { returns(Symbol) }
+          attr_accessor :level
 
-        # The consistency level for a query.
-        sig do
-          params(
-            level:
-              Turbopuffer::NamespaceQueryParams::Consistency::Level::OrSymbol
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The query's consistency level.
-          level: nil
-        )
-        end
+          # Strong consistency. Requires a round-trip to object storage to fetch the latest
+          # writes.
+          sig { params(level: Symbol).returns(T.attached_class) }
+          def self.new(level: :strong)
+          end
 
-        sig do
-          override.returns(
-            {
-              level:
-                Turbopuffer::NamespaceQueryParams::Consistency::Level::OrSymbol
-            }
-          )
-        end
-        def to_hash
+          sig { override.returns({ level: Symbol }) }
+          def to_hash
+          end
         end
 
-        # The query's consistency level.
-        module Level
-          extend Turbopuffer::Internal::Type::Enum
-
-          TaggedSymbol =
+        class Eventual < Turbopuffer::Internal::Type::BaseModel
+          OrHash =
             T.type_alias do
-              T.all(
-                Symbol,
-                Turbopuffer::NamespaceQueryParams::Consistency::Level
+              T.any(
+                Turbopuffer::NamespaceQueryParams::Consistency::Eventual,
+                Turbopuffer::Internal::AnyHash
               )
             end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          # Strong consistency. Requires a round-trip to object storage to fetch the latest writes.
-          STRONG =
-            T.let(
-              :strong,
-              Turbopuffer::NamespaceQueryParams::Consistency::Level::TaggedSymbol
-            )
+          sig { returns(Symbol) }
+          attr_accessor :level
 
-          # Eventual consistency. Does not require a round-trip to object storage, but may not see the latest writes.
-          EVENTUAL =
-            T.let(
-              :eventual,
-              Turbopuffer::NamespaceQueryParams::Consistency::Level::TaggedSymbol
-            )
+          # How long the query may reuse the node's cached view of the namespace before
+          # refreshing it from object storage. Defaults to 60.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :max_staleness_seconds
+
+          sig { params(max_staleness_seconds: Integer).void }
+          attr_writer :max_staleness_seconds
 
+          # Eventual consistency. Does not require a round-trip to object storage, but may
+          # not see the latest writes.
           sig do
-            override.returns(
-              T::Array[
-                Turbopuffer::NamespaceQueryParams::Consistency::Level::TaggedSymbol
-              ]
+            params(max_staleness_seconds: Integer, level: Symbol).returns(
+              T.attached_class
             )
           end
-          def self.values
+          def self.new(
+            # How long the query may reuse the node's cached view of the namespace before
+            # refreshing it from object storage. Defaults to 60.
+            max_staleness_seconds: nil,
+            level: :eventual
+          )
+          end
+
+          sig do
+            override.returns({ level: Symbol, max_staleness_seconds: Integer })
+          end
+          def to_hash
           end
         end
+
+        sig do
+          override.returns(
+            T::Array[Turbopuffer::NamespaceQueryParams::Consistency::Variants]
+          )
+        end
+        def self.variants
+        end
       end
 
       # Limits the documents returned by a query.