chromadb 3.0.17 → 3.1.0

package/dist/chromadb.d.ts

@@ -1,3 +1,16 @@
+type BoolInvertedIndexConfig$1 = {
+    [key: string]: never;
+};
+type BoolInvertedIndexType$1 = {
+    config: BoolInvertedIndexConfig$1;
+    enabled: boolean;
+};
+/**
+ * Boolean value type index configurations
+ */
+type BoolValueType$1 = {
+    bool_inverted_index?: null | BoolInvertedIndexType$1;
+};
 type ChecklistResponse = {
     max_batch_size: number;
     supports_base64_encoding: boolean;
@@ -11,26 +24,195 @@ type EmbeddingFunctionConfiguration = {
     type: 'legacy';
 } | (EmbeddingFunctionNewConfiguration & {
     type: 'known';
-});
+}) | {
+    type: 'unknown';
+};
 type EmbeddingFunctionNewConfiguration = {
     config: unknown;
     name: string;
 };
+type FloatInvertedIndexConfig$1 = {
+    [key: string]: never;
+};
+type FloatInvertedIndexType$1 = {
+    config: FloatInvertedIndexConfig$1;
+    enabled: boolean;
+};
+/**
+ * Float list value type index configurations (for vectors)
+ */
+type FloatListValueType$1 = {
+    vector_index?: null | VectorIndexType$1;
+};
+/**
+ * Float value type index configurations
+ */
+type FloatValueType$1 = {
+    float_inverted_index?: null | FloatInvertedIndexType$1;
+};
+type FtsIndexConfig$1 = {
+    [key: string]: never;
+};
+type FtsIndexType$1 = {
+    config: FtsIndexConfig$1;
+    enabled: boolean;
+};
 type GetUserIdentityResponse = {
     databases: Array<string>;
     tenant: string;
     user_id: string;
 };
+type HashMap = {
+    [key: string]: boolean | number | string | SparseVector | null;
+};
 type HnswConfiguration = {
     ef_construction?: number | null;
     ef_search?: number | null;
     max_neighbors?: number | null;
     resize_factor?: number | null;
-    space?: null | HnswSpace;
+    space?: null | Space;
+    sync_threshold?: number | null;
+};
+/**
+ * Configuration for HNSW vector index algorithm parameters
+ */
+type HnswIndexConfig = {
+    batch_size?: number | null;
+    ef_construction?: number | null;
+    ef_search?: number | null;
+    max_neighbors?: number | null;
+    num_threads?: number | null;
+    resize_factor?: number | null;
     sync_threshold?: number | null;
 };
-type HnswSpace = 'l2' | 'cosine' | 'ip';
 type Include = 'distances' | 'documents' | 'embeddings' | 'metadatas' | 'uris';
+type IntInvertedIndexConfig$1 = {
+    [key: string]: never;
+};
+type IntInvertedIndexType$1 = {
+    config: IntInvertedIndexConfig$1;
+    enabled: boolean;
+};
+/**
+ * Integer value type index configurations
+ */
+type IntValueType$1 = {
+    int_inverted_index?: null | IntInvertedIndexType$1;
+};
+/**
+ * Represents a field key in search queries.
+ *
+ * Used for both selecting fields to return and building filter expressions.
+ * Predefined keys access special fields, while custom keys access metadata.
+ *
+ * # Predefined Keys
+ *
+ * - `Key::Document` - Document text content (`#document`)
+ * - `Key::Embedding` - Vector embeddings (`#embedding`)
+ * - `Key::Metadata` - All metadata fields (`#metadata`)
+ * - `Key::Score` - Search scores (`#score`)
+ *
+ * # Custom Keys
+ *
+ * Use `Key::field()` or `Key::from()` to reference metadata fields:
+ *
+ * ```
+ * use chroma_types::operator::Key;
+ *
+ * let key = Key::field("author");
+ * let key = Key::from("title");
+ * ```
+ *
+ * # Examples
+ *
+ * ## Building filters
+ *
+ * ```
+ * use chroma_types::operator::Key;
+ *
+ * // Equality
+ * let filter = Key::field("status").eq("published");
+ *
+ * // Comparisons
+ * let filter = Key::field("year").gte(2020);
+ * let filter = Key::field("score").lt(0.9);
+ *
+ * // Set operations
+ * let filter = Key::field("category").is_in(vec!["tech", "science"]);
+ * let filter = Key::field("status").not_in(vec!["deleted", "archived"]);
+ *
+ * // Document content
+ * let filter = Key::Document.contains("machine learning");
+ * let filter = Key::Document.regex(r"\bAPI\b");
+ *
+ * // Combining filters
+ * let filter = Key::field("status").eq("published")
+ * & Key::field("year").gte(2020);
+ * ```
+ *
+ * ## Selecting fields
+ *
+ * ```
+ * use chroma_types::plan::SearchPayload;
+ * use chroma_types::operator::Key;
+ *
+ * let search = SearchPayload::default()
+ * .select([
+ * Key::Document,
+ * Key::Score,
+ * Key::field("title"),
+ * Key::field("author"),
+ * ]);
+ * ```
+ */
+type Key$1 = 'Document' | 'Embedding' | 'Metadata' | 'Score' | {
+    MetadataField: string;
+};
+/**
+ * Schema representation for collection index configurations
+ *
+ * This represents the server-side schema structure used for index management
+ */
+type Schema$1 = {
+    /**
+     * Default index configurations for each value type
+     */
+    defaults: ValueTypes$1;
+    /**
+     * Key-specific index overrides
+     * TODO(Sanket): Needed for backwards compatibility. Should remove after deploy.
+     */
+    keys: {
+        [key: string]: ValueTypes$1;
+    };
+};
+type SearchPayload = {
+    filter?: {
+        query_ids?: Array<string>;
+        where_clause?: {
+            [key: string]: unknown;
+        };
+    };
+    limit?: {
+        limit?: number;
+        offset?: number;
+    };
+    rank?: {
+        [key: string]: unknown;
+    };
+    select?: {
+        keys?: Array<string>;
+    };
+};
+type SearchResponse = {
+    documents: Array<Array<string | null> | null>;
+    embeddings: Array<Array<Array<number> | null> | null>;
+    ids: Array<Array<string>>;
+    metadatas: Array<Array<null | HashMap> | null>;
+    scores: Array<Array<number | null> | null>;
+    select: Array<Array<Key$1>>;
+};
+type Space = 'l2' | 'cosine' | 'ip';
 type SpannConfiguration = {
     ef_construction?: number | null;
     ef_search?: number | null;
@@ -38,12 +220,38 @@ type SpannConfiguration = {
     merge_threshold?: number | null;
     reassign_neighbor_count?: number | null;
     search_nprobe?: number | null;
-    space?: null | HnswSpace;
+    space?: null | Space;
     split_threshold?: number | null;
     write_nprobe?: number | null;
 };
+/**
+ * Configuration for SPANN vector index algorithm parameters
+ */
+type SpannIndexConfig = {
+    ef_construction?: number | null;
+    ef_search?: number | null;
+    initial_lambda?: number | null;
+    max_neighbors?: number | null;
+    merge_threshold?: number | null;
+    nreplica_count?: number | null;
+    num_centers_to_merge_to?: number | null;
+    num_samples_kmeans?: number | null;
+    reassign_neighbor_count?: number | null;
+    search_nprobe?: number | null;
+    search_rng_epsilon?: number | null;
+    search_rng_factor?: number | null;
+    split_threshold?: number | null;
+    write_nprobe?: number | null;
+    write_rng_epsilon?: number | null;
+    write_rng_factor?: number | null;
+};
 /**
  * Represents a sparse vector using parallel arrays for indices and values.
+ *
+ * On deserialization: accepts both old format `{"indices": [...], "values": [...]}`
+ * and new format `{"#type": "sparse_vector", "indices": [...], "values": [...]}`.
+ *
+ * On serialization: always includes `#type` field with value `"sparse_vector"`.
  */
 type SparseVector = {
     /**
@@ -55,6 +263,41 @@ type SparseVector = {
      */
     values: Array<number>;
 };
+type SparseVectorIndexConfig$1 = {
+    /**
+     * Whether this embedding is BM25
+     */
+    bm25?: boolean | null;
+    embedding_function?: null | EmbeddingFunctionConfiguration;
+    /**
+     * Key to source the sparse vector from
+     */
+    source_key?: string | null;
+};
+type SparseVectorIndexType$1 = {
+    config: SparseVectorIndexConfig$1;
+    enabled: boolean;
+};
+/**
+ * Sparse vector value type index configurations
+ */
+type SparseVectorValueType$1 = {
+    sparse_vector_index?: null | SparseVectorIndexType$1;
+};
+type StringInvertedIndexConfig$1 = {
+    [key: string]: never;
+};
+type StringInvertedIndexType$1 = {
+    config: StringInvertedIndexConfig$1;
+    enabled: boolean;
+};
+/**
+ * String value type index configurations
+ */
+type StringValueType$1 = {
+    fts_index?: null | FtsIndexType$1;
+    string_inverted_index?: null | StringInvertedIndexType$1;
+};
 type UpdateCollectionConfiguration$1 = {
     embedding_function?: null | EmbeddingFunctionConfiguration;
     hnsw?: null | UpdateHnswConfiguration;
@@ -72,11 +315,38 @@ type UpdateSpannConfiguration = {
     ef_search?: number | null;
     search_nprobe?: number | null;
 };
+/**
+ * Strongly-typed value type configurations
+ * Contains optional configurations for each supported value type
+ */
+type ValueTypes$1 = {
+    bool?: null | BoolValueType$1;
+    float?: null | FloatValueType$1;
+    float_list?: null | FloatListValueType$1;
+    int?: null | IntValueType$1;
+    sparse_vector?: null | SparseVectorValueType$1;
+    string?: null | StringValueType$1;
+};
+type VectorIndexConfig$1 = {
+    embedding_function?: null | EmbeddingFunctionConfiguration;
+    hnsw?: null | HnswIndexConfig;
+    /**
+     * Key to source the vector from
+     */
+    source_key?: string | null;
+    space?: null | Space;
+    spann?: null | SpannIndexConfig;
+};
+type VectorIndexType$1 = {
+    config: VectorIndexConfig$1;
+    enabled: boolean;
+};
 
 /**
  * User identity information including tenant and database access.
  */
 type UserIdentity = GetUserIdentityResponse;
+
 /**
  * Metadata that can be associated with a collection.
  * Values must be boolean, number, or string types.
@@ -294,6 +564,14 @@ interface EmbeddingFunction {
      * @returns Promise resolving to array of embedding vectors
      */
     generate(texts: string[]): Promise<number[][]>;
+    /**
+     * Generates embeddings specifically for query texts.
+     * The client will fall back to using the implementation of `generate`
+     * if this function is not provided.
+     * @param texts - Array of query text strings to embed
+     * @returns Promise resolving to array of embedding vectors
+     */
+    generateForQueries?(texts: string[]): Promise<number[][]>;
     /** Optional name identifier for the embedding function */
     name?: string;
     /** Returns the default vector space for this embedding function */
@@ -315,6 +593,43 @@ interface EmbeddingFunction {
      */
     validateConfig?(config: Record<string, any>): void;
 }
+/**
+ * Interface for sparse embedding functions.
+ * Sparse embedding functions transform text documents into sparse numerical representations
+ * where only non-zero values are stored, making them efficient for high-dimensional spaces.
+ */
+interface SparseEmbeddingFunction {
+    /**
+     * Generates sparse embeddings for the given texts.
+     * @param texts - Array of text strings to embed
+     * @returns Promise resolving to array of sparse vectors
+     */
+    generate(texts: string[]): Promise<SparseVector[]>;
+    /**
+     * Generates sparse embeddings specifically for query texts.
+     * The client will fall back to using the implementation of `generate`
+     * if this function is not provided.
+     * @param texts - Array of query text strings to embed
+     * @returns Promise resolving to array of sparse vectors
+     */
+    generateForQueries?(texts: string[]): Promise<SparseVector[]>;
+    /** Optional name identifier for the embedding function */
+    name?: string;
+    /** Creates an instance from configuration object */
+    buildFromConfig?(config: Record<string, any>): SparseEmbeddingFunction;
+    /** Returns the current configuration as an object */
+    getConfig?(): Record<string, any>;
+    /**
+     * Validates that a configuration update is allowed.
+     * @param newConfig - New configuration to validate
+     */
+    validateConfigUpdate?(newConfig: Record<string, any>): void;
+    /**
+     * Validates that a configuration object is valid.
+     * @param config - Configuration to validate
+     */
+    validateConfig?(config: Record<string, any>): void;
+}
 /**
  * Interface for embedding function constructor classes.
  * Used for registering and instantiating embedding functions.
@@ -327,11 +642,32 @@ interface EmbeddingFunctionClass {
     /** Static method to build instance from configuration */
     buildFromConfig(config: Record<string, any>): EmbeddingFunction;
 }
+/**
+ * Interface for sparse embedding function constructor classes.
+ * Used for registering and instantiating sparse embedding functions.
+ */
+interface SparseEmbeddingFunctionClass {
+    /** Constructor for creating new instances */
+    new (...args: any[]): SparseEmbeddingFunction;
+    /** Name identifier for the embedding function */
+    name: string;
+    /** Static method to build instance from configuration */
+    buildFromConfig(config: Record<string, any>): SparseEmbeddingFunction;
+}
 /**
  * Registry of available embedding functions.
  * Maps function names to their constructor classes.
  */
 declare const knownEmbeddingFunctions: Map<string, EmbeddingFunctionClass>;
+/**
+ * Registry of available sparse embedding functions.
+ * Maps function names to their constructor classes.
+ */
+declare const knownSparseEmbeddingFunctions: Map<string, SparseEmbeddingFunctionClass>;
+/**
+ * Union type covering both dense and sparse embedding functions.
+ */
+type AnyEmbeddingFunction = EmbeddingFunction | SparseEmbeddingFunction;
 /**
  * Registers an embedding function in the global registry.
  * @param name - Unique name for the embedding function
@@ -339,13 +675,27 @@ declare const knownEmbeddingFunctions: Map<string, EmbeddingFunctionClass>;
  * @throws ChromaValueError if name is already registered
  */
 declare const registerEmbeddingFunction: (name: string, fn: EmbeddingFunctionClass) => void;
+/**
+ * Registers a sparse embedding function in the global registry.
+ * @param name - Unique name for the sparse embedding function
+ * @param fn - Sparse embedding function class to register
+ * @throws ChromaValueError if name is already registered
+ */
+declare const registerSparseEmbeddingFunction: (name: string, fn: SparseEmbeddingFunctionClass) => void;
 /**
  * Retrieves and instantiates an embedding function from configuration.
  * @param collectionName - Name of the collection (for error messages)
  * @param efConfig - Configuration for the embedding function
- * @returns Promise resolving to an EmbeddingFunction instance
+ * @returns EmbeddingFunction instance or undefined if it cannot be constructed
+ */
+declare const getEmbeddingFunction: (collectionName: string, efConfig?: EmbeddingFunctionConfiguration) => EmbeddingFunction | undefined;
+/**
+ * Retrieves and instantiates a sparse embedding function from configuration.
+ * @param collectionName - Name of the collection (for error messages)
+ * @param efConfig - Configuration for the sparse embedding function
+ * @returns SparseEmbeddingFunction instance or undefined if it cannot be constructed
  */
-declare const getEmbeddingFunction: (collectionName: string, efConfig?: EmbeddingFunctionConfiguration) => Promise<EmbeddingFunction | undefined>;
+declare const getSparseEmbeddingFunction: (collectionName: string, efConfig?: EmbeddingFunctionConfiguration) => SparseEmbeddingFunction | undefined;
 /**
  * Serializes an embedding function to configuration format.
  * @param embeddingFunction - User provided embedding function
@@ -414,6 +764,159 @@ declare const processUpdateCollectionConfig: ({ collectionName, currentConfigura
     updateEmbeddingFunction?: EmbeddingFunction;
 }>;
 
+declare const DOCUMENT_KEY = "#document";
+declare const EMBEDDING_KEY = "#embedding";
+declare class FtsIndexConfig {
+    readonly type = "FtsIndexConfig";
+}
+declare class StringInvertedIndexConfig {
+    readonly type = "StringInvertedIndexConfig";
+}
+declare class IntInvertedIndexConfig {
+    readonly type = "IntInvertedIndexConfig";
+}
+declare class FloatInvertedIndexConfig {
+    readonly type = "FloatInvertedIndexConfig";
+}
+declare class BoolInvertedIndexConfig {
+    readonly type = "BoolInvertedIndexConfig";
+}
+interface VectorIndexConfigOptions {
+    space?: Space | null;
+    embeddingFunction?: EmbeddingFunction | null;
+    sourceKey?: string | null;
+    hnsw?: HnswIndexConfig | null;
+    spann?: SpannIndexConfig | null;
+}
+declare class VectorIndexConfig {
+    readonly type = "VectorIndexConfig";
+    space: Space | null;
+    embeddingFunction: EmbeddingFunction | null;
+    sourceKey: string | null;
+    hnsw: HnswIndexConfig | null;
+    spann: SpannIndexConfig | null;
+    constructor(options?: VectorIndexConfigOptions);
+}
+interface SparseVectorIndexConfigOptions {
+    embeddingFunction?: SparseEmbeddingFunction | null;
+    sourceKey?: string | null;
+    bm25?: boolean | null;
+}
+declare class SparseVectorIndexConfig {
+    readonly type = "SparseVectorIndexConfig";
+    embeddingFunction: SparseEmbeddingFunction | null;
+    sourceKey: string | null;
+    bm25: boolean | null;
+    constructor(options?: SparseVectorIndexConfigOptions);
+}
+declare class FtsIndexType {
+    enabled: boolean;
+    config: FtsIndexConfig;
+    constructor(enabled: boolean, config: FtsIndexConfig);
+}
+declare class StringInvertedIndexType {
+    enabled: boolean;
+    config: StringInvertedIndexConfig;
+    constructor(enabled: boolean, config: StringInvertedIndexConfig);
+}
+declare class VectorIndexType {
+    enabled: boolean;
+    config: VectorIndexConfig;
+    constructor(enabled: boolean, config: VectorIndexConfig);
+}
+declare class SparseVectorIndexType {
+    enabled: boolean;
+    config: SparseVectorIndexConfig;
+    constructor(enabled: boolean, config: SparseVectorIndexConfig);
+}
+declare class IntInvertedIndexType {
+    enabled: boolean;
+    config: IntInvertedIndexConfig;
+    constructor(enabled: boolean, config: IntInvertedIndexConfig);
+}
+declare class FloatInvertedIndexType {
+    enabled: boolean;
+    config: FloatInvertedIndexConfig;
+    constructor(enabled: boolean, config: FloatInvertedIndexConfig);
+}
+declare class BoolInvertedIndexType {
+    enabled: boolean;
+    config: BoolInvertedIndexConfig;
+    constructor(enabled: boolean, config: BoolInvertedIndexConfig);
+}
+declare class StringValueType {
+    ftsIndex: FtsIndexType | null;
+    stringInvertedIndex: StringInvertedIndexType | null;
+    constructor(ftsIndex?: FtsIndexType | null, stringInvertedIndex?: StringInvertedIndexType | null);
+}
+declare class FloatListValueType {
+    vectorIndex: VectorIndexType | null;
+    constructor(vectorIndex?: VectorIndexType | null);
+}
+declare class SparseVectorValueType {
+    sparseVectorIndex: SparseVectorIndexType | null;
+    constructor(sparseVectorIndex?: SparseVectorIndexType | null);
+}
+declare class IntValueType {
+    intInvertedIndex: IntInvertedIndexType | null;
+    constructor(intInvertedIndex?: IntInvertedIndexType | null);
+}
+declare class FloatValueType {
+    floatInvertedIndex: FloatInvertedIndexType | null;
+    constructor(floatInvertedIndex?: FloatInvertedIndexType | null);
+}
+declare class BoolValueType {
+    boolInvertedIndex: BoolInvertedIndexType | null;
+    constructor(boolInvertedIndex?: BoolInvertedIndexType | null);
+}
+declare class ValueTypes {
+    string: StringValueType | null;
+    floatList: FloatListValueType | null;
+    sparseVector: SparseVectorValueType | null;
+    intValue: IntValueType | null;
+    floatValue: FloatValueType | null;
+    boolean: BoolValueType | null;
+}
+type IndexConfig = FtsIndexConfig | VectorIndexConfig | SparseVectorIndexConfig | StringInvertedIndexConfig | IntInvertedIndexConfig | FloatInvertedIndexConfig | BoolInvertedIndexConfig;
+type JsonDict = Record<string, any>;
+declare class Schema {
+    defaults: ValueTypes;
+    keys: Record<string, ValueTypes>;
+    constructor();
+    createIndex(config?: IndexConfig, key?: string): this;
+    deleteIndex(config?: IndexConfig, key?: string): this;
+    serializeToJSON(): Schema$1;
+    static deserializeFromJSON(json?: Schema$1 | JsonDict | null): Schema | undefined;
+    private setVectorIndexConfig;
+    private setFtsIndexConfig;
+    private setIndexInDefaults;
+    private setIndexForKey;
+    private enableAllIndexesForKey;
+    private disableAllIndexesForKey;
+    private validateSingleSparseVectorIndex;
+    private initializeDefaults;
+    private initializeKeys;
+    private serializeValueTypes;
+    private serializeStringValueType;
+    private serializeFloatListValueType;
+    private serializeSparseVectorValueType;
+    private serializeIntValueType;
+    private serializeFloatValueType;
+    private serializeBoolValueType;
+    private serializeConfig;
+    private serializeVectorConfig;
+    private serializeSparseVectorConfig;
+    private static deserializeValueTypes;
+    private static deserializeStringValueType;
+    private static deserializeFloatListValueType;
+    private static deserializeSparseVectorValueType;
+    private static deserializeIntValueType;
+    private static deserializeFloatValueType;
+    private static deserializeBoolValueType;
+    private static deserializeVectorConfig;
+    private static deserializeSparseVectorConfig;
+}
+
 /**
  * Configuration options for the ChromaClient.
  */
@@ -510,11 +1013,12 @@ declare class ChromaClient {
      * @returns Promise resolving to the created Collection instance
      * @throws Error if a collection with the same name already exists
      */
-    createCollection({ name, configuration, metadata, embeddingFunction, }: {
+    createCollection({ name, configuration, metadata, embeddingFunction, schema, }: {
         name: string;
         configuration?: CreateCollectionConfiguration;
         metadata?: CollectionMetadata;
         embeddingFunction?: EmbeddingFunction | null;
+        schema?: Schema;
     }): Promise<Collection>;
     /**
      * Retrieves an existing collection by name.
@@ -546,11 +1050,12 @@ declare class ChromaClient {
      * @param options.embeddingFunction - Optional embedding function to use
      * @returns Promise resolving to the Collection instance
      */
-    getOrCreateCollection({ name, configuration, metadata, embeddingFunction, }: {
+    getOrCreateCollection({ name, configuration, metadata, embeddingFunction, schema, }: {
         name: string;
         configuration?: CreateCollectionConfiguration;
         metadata?: CollectionMetadata;
         embeddingFunction?: EmbeddingFunction | null;
+        schema?: Schema;
     }): Promise<Collection>;
     /**
      * Deletes a collection and all its data.
@@ -588,6 +1093,171 @@ declare class ChromaClient {
     supportsBase64Encoding(): Promise<boolean>;
 }
 
+type WhereJSON = Record<string, unknown>;
+type WhereInput = WhereExpression | WhereJSON | null | undefined;
+declare abstract class WhereExpressionBase {
+    abstract toJSON(): WhereJSON;
+    and(other: WhereInput): WhereExpression;
+    or(other: WhereInput): WhereExpression;
+}
+declare abstract class WhereExpression extends WhereExpressionBase {
+    static from(input: WhereInput): WhereExpression | undefined;
+}
+
+type IterableInput<T> = Iterable<T> | ArrayLike<T>;
+
+declare class Key {
+    readonly name: string;
+    static readonly ID: Key;
+    static readonly DOCUMENT: Key;
+    static readonly EMBEDDING: Key;
+    static readonly METADATA: Key;
+    static readonly SCORE: Key;
+    constructor(name: string);
+    eq(value: unknown): WhereExpression;
+    ne(value: unknown): WhereExpression;
+    gt(value: unknown): WhereExpression;
+    gte(value: unknown): WhereExpression;
+    lt(value: unknown): WhereExpression;
+    lte(value: unknown): WhereExpression;
+    isIn(values: IterableInput<unknown>): WhereExpression;
+    notIn(values: IterableInput<unknown>): WhereExpression;
+    contains(value: string): WhereExpression;
+    notContains(value: string): WhereExpression;
+    regex(pattern: string): WhereExpression;
+    notRegex(pattern: string): WhereExpression;
+}
+interface KeyFactory {
+    (name: string): Key;
+    ID: Key;
+    DOCUMENT: Key;
+    EMBEDDING: Key;
+    METADATA: Key;
+    SCORE: Key;
+}
+declare const K: KeyFactory;
+
+interface LimitOptions {
+    offset?: number;
+    limit?: number | null | undefined;
+}
+type LimitInput = Limit | number | LimitOptions | null | undefined;
+declare class Limit {
+    readonly offset: number;
+    readonly limit?: number;
+    constructor(options?: LimitOptions);
+    static from(input: LimitInput, offsetOverride?: number): Limit;
+    toJSON(): {
+        offset: number;
+        limit?: number;
+    };
+}
+
+type SelectKeyInput = string | Key;
+type SelectInput = Select | Iterable<SelectKeyInput> | {
+    keys?: Iterable<SelectKeyInput>;
+} | null | undefined;
+declare class Select {
+    private readonly keys;
+    constructor(keys?: Iterable<SelectKeyInput>);
+    static from(input: SelectInput): Select;
+    static all(): Select;
+    get values(): string[];
+    toJSON(): {
+        keys: string[];
+    };
+}
+
+type RankLiteral = Record<string, unknown>;
+type RankInput = RankExpression | RankLiteral | number | null | undefined;
+declare abstract class RankExpressionBase {
+    abstract toJSON(): Record<string, unknown>;
+    add(...others: RankInput[]): RankExpression;
+    subtract(other: RankInput): RankExpression;
+    multiply(...others: RankInput[]): RankExpression;
+    divide(other: RankInput): RankExpression;
+    negate(): RankExpression;
+    abs(): RankExpression;
+    exp(): RankExpression;
+    log(): RankExpression;
+    max(...others: RankInput[]): RankExpression;
+    min(...others: RankInput[]): RankExpression;
+}
+declare abstract class RankExpression extends RankExpressionBase {
+    static from(input: RankInput): RankExpression | undefined;
+}
+interface KnnOptions {
+    query: IterableInput<number> | SparseVector | string;
+    key?: string | Key;
+    limit?: number;
+    default?: number | null;
+    returnRank?: boolean;
+}
+declare const Val: (value: number) => RankExpression;
+declare const Knn: (options: KnnOptions) => RankExpression;
+interface RrfOptions {
+    ranks: RankInput[];
+    k?: number;
+    weights?: number[];
+    normalize?: boolean;
+}
+declare const Rrf: ({ ranks, k, weights, normalize }: RrfOptions) => RankExpression;
+declare const Sum: (...inputs: RankInput[]) => RankExpression;
+declare const Sub: (left: RankInput, right: RankInput) => RankExpression;
+declare const Mul: (...inputs: RankInput[]) => RankExpression;
+declare const Div: (left: RankInput, right: RankInput) => RankExpression;
+declare const Abs: (input: RankInput) => RankExpression;
+declare const Exp: (input: RankInput) => RankExpression;
+declare const Log: (input: RankInput) => RankExpression;
+declare const Max: (...inputs: RankInput[]) => RankExpression;
+declare const Min: (...inputs: RankInput[]) => RankExpression;
+
+interface SearchInit {
+    where?: WhereInput;
+    rank?: RankInput;
+    limit?: LimitInput;
+    select?: SelectInput;
+}
+declare class Search {
+    private _where?;
+    private _rank?;
+    private _limit;
+    private _select;
+    constructor(init?: SearchInit);
+    private clone;
+    where(where?: WhereInput): Search;
+    rank(rank?: RankInput): Search;
+    limit(limit?: LimitInput, offset?: number): Search;
+    select(keys?: SelectInput): Search;
+    select(...keys: SelectKeyInput[]): Search;
+    selectAll(): Search;
+    get whereClause(): WhereExpression | undefined;
+    get rankExpression(): RankExpression | undefined;
+    get limitConfig(): Limit;
+    get selectConfig(): Select;
+    toPayload(): SearchPayload;
+}
+type SearchLike = Search | SearchInit;
+declare const toSearch: (input: SearchLike) => Search;
+
+interface SearchResultRow {
+    id: string;
+    document?: string | null;
+    embedding?: number[] | null;
+    metadata?: Metadata | null;
+    score?: number | null;
+}
+declare class SearchResult {
+    readonly ids: string[][];
+    readonly documents: Array<Array<string | null> | null>;
+    readonly embeddings: Array<Array<Array<number> | null> | null>;
+    readonly metadatas: Array<Array<Metadata | null> | null>;
+    readonly scores: Array<Array<number | null> | null>;
+    readonly select: SearchResponse["select"];
+    constructor(response: SearchResponse);
+    rows(): SearchResultRow[][];
+}
+
 /**
  * Interface for collection operations using collection ID.
  * Provides methods for adding, querying, updating, and deleting records.
@@ -603,6 +1273,8 @@ interface Collection {
     configuration: CollectionConfiguration;
     /** Optional embedding function. Must match the one used to create the collection. */
     embeddingFunction?: EmbeddingFunction;
+    /** Collection schema describing index configuration */
+    schema?: Schema;
     /** Gets the total number of records in the collection */
     count(): Promise<number>;
     /**
@@ -737,6 +1409,12 @@ interface Collection {
         /** Document content-based filtering for deletion */
         whereDocument?: WhereDocument;
     }): Promise<void>;
+    /**
+     * Performs hybrid search on the collection using expression builders.
+     * @param searches - Single search payload or array of payloads
+     * @returns Promise resolving to column-major search results
+     */
+    search(searches: SearchLike | SearchLike[]): Promise<SearchResult>;
 }
 
 declare function withChroma(userNextConfig?: any): any;
@@ -948,4 +1626,4 @@ declare class ChromaRateLimitError extends Error {
 }
 declare function createErrorByType(type: string, message: string): InvalidCollectionError | InvalidArgumentError | undefined;
 
-export { AdminClient, type AdminClientArgs, AdminCloudClient, type BaseRecordSet, ChromaClient, type ChromaClientArgs, ChromaClientError, ChromaConnectionError, ChromaError, ChromaForbiddenError, ChromaNotFoundError, ChromaQuotaExceededError, ChromaRateLimitError, ChromaServerError, ChromaUnauthorizedError, ChromaUniqueError, ChromaValueError, CloudClient, type Collection, type CollectionConfiguration, type CollectionMetadata, type CreateCollectionConfiguration, type EmbeddingFunction, type EmbeddingFunctionClass, type EmbeddingFunctionSpace, GetResult, type HNSWConfiguration, IncludeEnum, InvalidArgumentError, InvalidCollectionError, type ListDatabasesArgs, type Metadata, type PreparedInsertRecordSet, type PreparedRecordSet, type QueryRecordSet, QueryResult, type QueryRowResult, type RecordSet, type UpdateCollectionConfiguration, type UpdateHNSWConfiguration, type UpdateSPANNConfiguration, type UserIdentity, type Where, type WhereDocument, baseRecordSetFields, createErrorByType, getDefaultEFConfig, getEmbeddingFunction, knownEmbeddingFunctions, processCreateCollectionConfig, processUpdateCollectionConfig, recordSetFields, registerEmbeddingFunction, serializeEmbeddingFunction, withChroma };
+export { Abs, AdminClient, type AdminClientArgs, AdminCloudClient, type AnyEmbeddingFunction, type BaseRecordSet, BoolInvertedIndexConfig, BoolInvertedIndexType, BoolValueType, ChromaClient, type ChromaClientArgs, ChromaClientError, ChromaConnectionError, ChromaError, ChromaForbiddenError, ChromaNotFoundError, ChromaQuotaExceededError, ChromaRateLimitError, ChromaServerError, ChromaUnauthorizedError, ChromaUniqueError, ChromaValueError, CloudClient, type Collection, type CollectionConfiguration, type CollectionMetadata, type CreateCollectionConfiguration, DOCUMENT_KEY, Div, EMBEDDING_KEY, type EmbeddingFunction, type EmbeddingFunctionClass, type EmbeddingFunctionSpace, Exp, FloatInvertedIndexConfig, FloatInvertedIndexType, FloatListValueType, FloatValueType, FtsIndexConfig, FtsIndexType, GetResult, type HNSWConfiguration, IncludeEnum, type IndexConfig, IntInvertedIndexConfig, IntInvertedIndexType, IntValueType, InvalidArgumentError, InvalidCollectionError, K, Key, type KeyFactory, Knn, type KnnOptions, Limit, type LimitInput, type LimitOptions, type ListDatabasesArgs, Log, Max, type Metadata, Min, Mul, type PreparedInsertRecordSet, type PreparedRecordSet, type QueryRecordSet, QueryResult, type QueryRowResult, RankExpression, type RankInput, type RankLiteral, type RecordSet, Rrf, type RrfOptions, Schema, Search, type SearchInit, type SearchLike, SearchResult, type SearchResultRow, Select, type SelectInput, type SelectKeyInput, type SparseEmbeddingFunction, type SparseEmbeddingFunctionClass, type SparseVector, SparseVectorIndexConfig, type SparseVectorIndexConfigOptions, SparseVectorIndexType, SparseVectorValueType, StringInvertedIndexConfig, StringInvertedIndexType, StringValueType, Sub, Sum, type UpdateCollectionConfiguration, type UpdateHNSWConfiguration, type UpdateSPANNConfiguration, type UserIdentity, Val, ValueTypes, VectorIndexConfig, type VectorIndexConfigOptions, VectorIndexType, type Where, type WhereDocument, WhereExpression, type WhereInput, type WhereJSON, baseRecordSetFields, createErrorByType, getDefaultEFConfig, getEmbeddingFunction, getSparseEmbeddingFunction, knownEmbeddingFunctions, knownSparseEmbeddingFunctions, processCreateCollectionConfig, processUpdateCollectionConfig, recordSetFields, registerEmbeddingFunction, registerSparseEmbeddingFunction, serializeEmbeddingFunction, toSearch, withChroma };