@lancedb/lancedb 0.15.1-beta.2 → 0.16.0

package/dist/connection.d.ts

@@ -32,6 +32,8 @@ export interface CreateTableOptions {
      *
      * The default is `stable`.
      * Set to "legacy" to use the old format.
+     *
+     * @deprecated Pass `new_table_data_storage_version` to storageOptions instead.
      */
     dataStorageVersion?: string;
     /**
@@ -40,16 +42,10 @@ export interface CreateTableOptions {
      * turning this on will make the dataset unreadable for older versions
      * of LanceDB (prior to 0.10.0). To migrate an existing dataset, instead
      * use the {@link LocalTable#migrateManifestPathsV2} method.
-     */
-    enableV2ManifestPaths?: boolean;
-    /**
-     * If true then data files will be written with the legacy format
      *
-     * The default is false.
-     *
-     * Deprecated. Use data storage version instead.
+     * @deprecated Pass `new_table_enable_v2_manifest_paths` to storageOptions instead.
      */
-    useLegacyFormat?: boolean;
+    enableV2ManifestPaths?: boolean;
     schema?: SchemaLike;
     embeddingFunction?: EmbeddingFunctionConfig;
 }
@@ -105,6 +101,7 @@ export interface TableNamesOptions {
  *
  * Any created tables are independent and will continue to work even if
  * the underlying connection has been closed.
+ * @hideconstructor
  */
 export declare abstract class Connection {
     /**
@@ -166,21 +163,29 @@ export declare abstract class Connection {
      * @param {string} name The name of the table to drop.
      */
     abstract dropTable(name: string): Promise<void>;
+    /**
+     * Drop all tables in the database.
+     */
+    abstract dropAllTables(): Promise<void>;
 }
+/** @hideconstructor */
 export declare class LocalConnection extends Connection {
     readonly inner: LanceDbConnection;
+    /** @hidden */
     constructor(inner: LanceDbConnection);
     isOpen(): boolean;
     close(): void;
     display(): string;
     tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
     openTable(name: string, options?: Partial<OpenTableOptions>): Promise<Table>;
+    private getStorageOptions;
     createTable(nameOrOptions: string | ({
         name: string;
         data: Data;
     } & Partial<CreateTableOptions>), data?: Record<string, unknown>[] | TableLike, options?: Partial<CreateTableOptions>): Promise<Table>;
     createEmptyTable(name: string, schema: import("./arrow").SchemaLike, options?: Partial<CreateTableOptions>): Promise<Table>;
     dropTable(name: string): Promise<void>;
+    dropAllTables(): Promise<void>;
 }
 /**
  * Takes storage options and makes all the keys snake case.

package/dist/connection.js

@@ -5,7 +5,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalConnection = exports.Connection = void 0;
 exports.cleanseStorageOptions = cleanseStorageOptions;
 const arrow_1 = require("./arrow");
+const arrow_2 = require("./arrow");
 const registry_1 = require("./embedding/registry");
+const sanitize_1 = require("./sanitize");
 const table_1 = require("./table");
 /**
  * A LanceDB Connection that allows you to open tables and create new ones.
@@ -24,6 +26,7 @@ const table_1 = require("./table");
  *
  * Any created tables are independent and will continue to work even if
  * the underlying connection has been closed.
+ * @hideconstructor
  */
 class Connection {
     [Symbol.for("nodejs.util.inspect.custom")]() {
@@ -31,8 +34,10 @@ class Connection {
     }
 }
 exports.Connection = Connection;
+/** @hideconstructor */
 class LocalConnection extends Connection {
     inner;
+    /** @hidden */
     constructor(inner) {
         super();
         this.inner = inner;
@@ -53,6 +58,23 @@ class LocalConnection extends Connection {
         const innerTable = await this.inner.openTable(name, cleanseStorageOptions(options?.storageOptions), options?.indexCacheSize);
         return new table_1.LocalTable(innerTable);
     }
+    getStorageOptions(options) {
+        if (options?.dataStorageVersion !== undefined) {
+            if (options.storageOptions === undefined) {
+                options.storageOptions = {};
+            }
+            options.storageOptions["newTableDataStorageVersion"] =
+                options.dataStorageVersion;
+        }
+        if (options?.enableV2ManifestPaths !== undefined) {
+            if (options.storageOptions === undefined) {
+                options.storageOptions = {};
+            }
+            options.storageOptions["newTableEnableV2ManifestPaths"] =
+                options.enableV2ManifestPaths ? "true" : "false";
+        }
+        return cleanseStorageOptions(options?.storageOptions);
+    }
     async createTable(nameOrOptions, data, options) {
         if (typeof nameOrOptions !== "string" && "name" in nameOrOptions) {
             const { name, data, ...options } = nameOrOptions;
@@ -61,15 +83,9 @@ class LocalConnection extends Connection {
         if (data === undefined) {
             throw new Error("data is required");
         }
-        const { buf, mode } = await table_1.Table.parseTableData(data, options);
-        let dataStorageVersion = "stable";
-        if (options?.dataStorageVersion !== undefined) {
-            dataStorageVersion = options.dataStorageVersion;
-        }
-        else if (options?.useLegacyFormat !== undefined) {
-            dataStorageVersion = options.useLegacyFormat ? "legacy" : "stable";
-        }
-        const innerTable = await this.inner.createTable(nameOrOptions, buf, mode, cleanseStorageOptions(options?.storageOptions), dataStorageVersion, options?.enableV2ManifestPaths);
+        const { buf, mode } = await parseTableData(data, options);
+        const storageOptions = this.getStorageOptions(options);
+        const innerTable = await this.inner.createTable(nameOrOptions, buf, mode, storageOptions);
         return new table_1.LocalTable(innerTable);
     }
     async createEmptyTable(name, schema, options) {
@@ -84,21 +100,18 @@ class LocalConnection extends Connection {
             const registry = (0, registry_1.getRegistry)();
             metadata = registry.getTableMetadata([embeddingFunction]);
         }
-        let dataStorageVersion = "stable";
-        if (options?.dataStorageVersion !== undefined) {
-            dataStorageVersion = options.dataStorageVersion;
-        }
-        else if (options?.useLegacyFormat !== undefined) {
-            dataStorageVersion = options.useLegacyFormat ? "legacy" : "stable";
-        }
-        const table = (0, arrow_1.makeEmptyTable)(schema, metadata);
-        const buf = await (0, arrow_1.fromTableToBuffer)(table);
-        const innerTable = await this.inner.createEmptyTable(name, buf, mode, cleanseStorageOptions(options?.storageOptions), dataStorageVersion, options?.enableV2ManifestPaths);
+        const storageOptions = this.getStorageOptions(options);
+        const table = (0, arrow_2.makeEmptyTable)(schema, metadata);
+        const buf = await (0, arrow_2.fromTableToBuffer)(table);
+        const innerTable = await this.inner.createEmptyTable(name, buf, mode, storageOptions);
         return new table_1.LocalTable(innerTable);
     }
     async dropTable(name) {
         return this.inner.dropTable(name);
     }
+    async dropAllTables() {
+        return this.inner.dropAllTables();
+    }
 }
 exports.LocalConnection = LocalConnection;
 /**
@@ -136,3 +149,25 @@ function camelToSnakeCase(camel) {
     }
     return result;
 }
+async function parseTableData(data, options, streaming = false) {
+    let mode = options?.mode ?? "create";
+    const existOk = options?.existOk ?? false;
+    if (mode === "create" && existOk) {
+        mode = "exist_ok";
+    }
+    let table;
+    if ((0, arrow_1.isArrowTable)(data)) {
+        table = (0, sanitize_1.sanitizeTable)(data);
+    }
+    else {
+        table = (0, arrow_1.makeArrowTable)(data, options);
+    }
+    if (streaming) {
+        const buf = await (0, arrow_1.fromTableToStreamBuffer)(table, options?.embeddingFunction, options?.schema);
+        return { buf, mode };
+    }
+    else {
+        const buf = await (0, arrow_2.fromTableToBuffer)(table, options?.embeddingFunction, options?.schema);
+        return { buf, mode };
+    }
+}

package/dist/embedding/embedding_function.d.ts

@@ -50,15 +50,15 @@ export declare abstract class EmbeddingFunction<T = any, M extends FunctionOptio
      *
      * @param optionsOrDatatype - The options for the field or the datatype
      *
-     * @see {@link lancedb.LanceSchema}
+     * @see {@link LanceSchema}
      */
     sourceField(optionsOrDatatype: Partial<FieldOptions> | DataType): [DataType, Map<string, EmbeddingFunction>];
     /**
      * vectorField is used in combination with `LanceSchema` to provide a declarative data model
      *
-     * @param options - The options for the field
+     * @param optionsOrDatatype - The options for the field
      *
-     * @see {@link lancedb.LanceSchema}
+     * @see {@link LanceSchema}
      */
     vectorField(optionsOrDatatype?: Partial<FieldOptions> | DataType): [DataType, Map<string, EmbeddingFunction>];
     /** The number of dimensions of the embeddings */

package/dist/embedding/embedding_function.js

@@ -21,7 +21,7 @@ class EmbeddingFunction {
      *
      * @param optionsOrDatatype - The options for the field or the datatype
      *
-     * @see {@link lancedb.LanceSchema}
+     * @see {@link LanceSchema}
      */
     sourceField(optionsOrDatatype) {
         let datatype = "datatype" in optionsOrDatatype
@@ -38,9 +38,9 @@ class EmbeddingFunction {
     /**
      * vectorField is used in combination with `LanceSchema` to provide a declarative data model
      *
-     * @param options - The options for the field
+     * @param optionsOrDatatype - The options for the field
      *
-     * @see {@link lancedb.LanceSchema}
+     * @see {@link LanceSchema}
      */
     vectorField(optionsOrDatatype) {
         let dtype;

package/dist/embedding/index.d.ts

@@ -1,6 +1,6 @@
 import { Schema } from "../arrow";
 import { EmbeddingFunction } from "./embedding_function";
-export { EmbeddingFunction, TextEmbeddingFunction } from "./embedding_function";
+export { FieldOptions, EmbeddingFunction, TextEmbeddingFunction, FunctionOptions, EmbeddingFunctionConstructor, } from "./embedding_function";
 export * from "./registry";
 /**
  * Create a schema with embedding functions.

package/dist/embedding/registry.d.ts

@@ -1,9 +1,9 @@
 import { type EmbeddingFunction, type EmbeddingFunctionConstructor } from "./embedding_function";
 import "reflect-metadata";
-type CreateReturnType<T> = T extends {
+export type CreateReturnType<T> = T extends {
     init: () => Promise<void>;
 } ? Promise<T> : T;
-interface EmbeddingFunctionCreate<T extends EmbeddingFunction> {
+export interface EmbeddingFunctionCreate<T extends EmbeddingFunction> {
     create(options?: T["TOptions"]): CreateReturnType<T>;
 }
 /**
@@ -20,8 +20,6 @@ export declare class EmbeddingFunctionRegistry {
     length(): number;
     /**
      * Register an embedding function
-     * @param name The name of the function
-     * @param func The function to register
      * @throws Error if the function is already registered
      */
     register<T extends EmbeddingFunctionConstructor = EmbeddingFunctionConstructor>(this: EmbeddingFunctionRegistry, alias?: string): (ctor: T) => any;
@@ -52,4 +50,3 @@ export interface EmbeddingFunctionConfig {
     vectorColumn?: string;
     function: EmbeddingFunction;
 }
-export {};

package/dist/embedding/registry.js

@@ -22,8 +22,6 @@ class EmbeddingFunctionRegistry {
     }
     /**
      * Register an embedding function
-     * @param name The name of the function
-     * @param func The function to register
      * @throws Error if the function is already registered
      */
     register(alias) {

package/dist/index.d.ts

@@ -1,13 +1,16 @@
 import { Connection } from "./connection";
 import { ConnectionOptions } from "./native.js";
-export { WriteOptions, WriteMode, AddColumnsSql, ColumnAlteration, ConnectionOptions, IndexStatistics, IndexConfig, ClientConfig, TimeoutConfig, RetryConfig, } from "./native.js";
+export { AddColumnsSql, ColumnAlteration, ConnectionOptions, IndexStatistics, IndexConfig, ClientConfig, TimeoutConfig, RetryConfig, OptimizeStats, CompactionStats, RemovalStats, } from "./native.js";
 export { makeArrowTable, MakeArrowTableOptions, Data, VectorColumnOptions, } from "./arrow";
-export { Connection, CreateTableOptions, TableNamesOptions, } from "./connection";
-export { ExecutableQuery, Query, QueryBase, VectorQuery, RecordBatchIterator, } from "./query";
-export { Index, IndexOptions, IvfPqOptions } from "./indices";
-export { Table, AddDataOptions, UpdateOptions, OptimizeOptions } from "./table";
+export { Connection, CreateTableOptions, TableNamesOptions, OpenTableOptions, } from "./connection";
+export { ExecutableQuery, Query, QueryBase, VectorQuery, QueryExecutionOptions, FullTextSearchOptions, RecordBatchIterator, } from "./query";
+export { Index, IndexOptions, IvfPqOptions, HnswPqOptions, HnswSqOptions, FtsOptions, } from "./indices";
+export { Table, AddDataOptions, UpdateOptions, OptimizeOptions, Version, } from "./table";
+export { MergeInsertBuilder } from "./merge";
 export * as embedding from "./embedding";
 export * as rerankers from "./rerankers";
+export { SchemaLike, TableLike, FieldLike, RecordBatchLike, DataLike, IntoVector, } from "./arrow";
+export { IntoSql } from "./util";
 /**
  * Connect to a LanceDB instance at the given URI.
  *
@@ -19,6 +22,7 @@ export * as rerankers from "./rerankers";
  * @param {string} uri - The uri of the database. If the database uri starts
  * with `db://` then it connects to a remote database.
  * @see {@link ConnectionOptions} for more details on the URI format.
+ * @param  options - The options to use when connecting to the database
  * @example
  * ```ts
  * const conn = await connect("/path/to/database");
@@ -31,7 +35,7 @@ export * as rerankers from "./rerankers";
  * });
  * ```
  */
-export declare function connect(uri: string, opts?: Partial<ConnectionOptions>): Promise<Connection>;
+export declare function connect(uri: string, options?: Partial<ConnectionOptions>): Promise<Connection>;
 /**
  * Connect to a LanceDB instance at the given URI.
  *
@@ -50,6 +54,6 @@ export declare function connect(uri: string, opts?: Partial<ConnectionOptions>):
  * });
  * ```
  */
-export declare function connect(opts: Partial<ConnectionOptions> & {
+export declare function connect(options: Partial<ConnectionOptions> & {
     uri: string;
 }): Promise<Connection>;

package/dist/index.js

@@ -2,12 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright The LanceDB Authors
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rerankers = exports.embedding = exports.Table = exports.Index = exports.RecordBatchIterator = exports.VectorQuery = exports.QueryBase = exports.Query = exports.Connection = exports.VectorColumnOptions = exports.MakeArrowTableOptions = exports.makeArrowTable = exports.WriteMode = void 0;
+exports.rerankers = exports.embedding = exports.MergeInsertBuilder = exports.Table = exports.Index = exports.RecordBatchIterator = exports.VectorQuery = exports.QueryBase = exports.Query = exports.Connection = exports.VectorColumnOptions = exports.MakeArrowTableOptions = exports.makeArrowTable = void 0;
 exports.connect = connect;
 const connection_1 = require("./connection");
 const native_js_1 = require("./native.js");
-var native_js_2 = require("./native.js");
-Object.defineProperty(exports, "WriteMode", { enumerable: true, get: function () { return native_js_2.WriteMode; } });
 var arrow_1 = require("./arrow");
 Object.defineProperty(exports, "makeArrowTable", { enumerable: true, get: function () { return arrow_1.makeArrowTable; } });
 Object.defineProperty(exports, "MakeArrowTableOptions", { enumerable: true, get: function () { return arrow_1.MakeArrowTableOptions; } });
@@ -23,14 +21,16 @@ var indices_1 = require("./indices");
 Object.defineProperty(exports, "Index", { enumerable: true, get: function () { return indices_1.Index; } });
 var table_1 = require("./table");
 Object.defineProperty(exports, "Table", { enumerable: true, get: function () { return table_1.Table; } });
+var merge_1 = require("./merge");
+Object.defineProperty(exports, "MergeInsertBuilder", { enumerable: true, get: function () { return merge_1.MergeInsertBuilder; } });
 exports.embedding = require("./embedding");
 exports.rerankers = require("./rerankers");
-async function connect(uriOrOptions, opts = {}) {
+async function connect(uriOrOptions, options = {}) {
     let uri;
     if (typeof uriOrOptions !== "string") {
-        const { uri: uri_, ...options } = uriOrOptions;
+        const { uri: uri_, ...opts } = uriOrOptions;
         uri = uri_;
-        opts = options;
+        options = opts;
     }
     else {
         uri = uriOrOptions;
@@ -38,8 +38,8 @@ async function connect(uriOrOptions, opts = {}) {
     if (!uri) {
         throw new Error("uri is required");
     }
-    opts = opts ?? {};
-    opts.storageOptions = (0, connection_1.cleanseStorageOptions)(opts.storageOptions);
-    const nativeConn = await native_js_1.Connection.new(uri, opts);
+    options = options ?? {};
+    options.storageOptions = (0, connection_1.cleanseStorageOptions)(options.storageOptions);
+    const nativeConn = await native_js_1.Connection.new(uri, options);
     return new connection_1.LocalConnection(nativeConn);
 }

package/dist/indices.d.ts

@@ -426,8 +426,6 @@ export declare class Index {
      * The results of a full text search are ordered by relevance measured by BM25.
      *
      * You can combine filters with full text search.
-     *
-     * For now, the full text search index only supports English, and doesn't support phrase search.
      */
     static fts(options?: Partial<FtsOptions>): Index;
     /**

package/dist/indices.js

@@ -86,8 +86,6 @@ class Index {
      * The results of a full text search are ordered by relevance measured by BM25.
      *
      * You can combine filters with full text search.
-     *
-     * For now, the full text search index only supports English, and doesn't support phrase search.
      */
     static fts(options) {
         return new Index(native_1.Index.fts(options?.withPosition, options?.baseTokenizer, options?.language, options?.maxTokenLength, options?.lowercase, options?.stem, options?.removeStopWords, options?.asciiFolding));

package/dist/native.d.ts

@@ -77,6 +77,7 @@ export interface ClientConfig {
   userAgent?: string
   retryConfig?: RetryConfig
   timeoutConfig?: TimeoutConfig
+  extraHeaders?: Record<string, string>
 }
 export interface RerankerCallbacks {
   rerankHybrid: (...args: any[]) => any
@@ -228,17 +229,6 @@ export interface ConnectionOptions {
    */
   hostOverride?: string
 }
-/** Write mode for writing a table. */
-export enum WriteMode {
-  Create = 'Create',
-  Append = 'Append',
-  Overwrite = 'Overwrite'
-}
-/** Write options when creating a Table. */
-export interface WriteOptions {
-  /** Write mode for writing to a table. */
-  mode?: WriteMode
-}
 export interface OpenTableOptions {
   storageOptions?: Record<string, string>
 }
@@ -258,11 +248,12 @@ export class Connection {
    * - buf: The buffer containing the IPC file.
    *
    */
-  createTable(name: string, buf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null, dataStorageOptions?: string | undefined | null, enableV2ManifestPaths?: boolean | undefined | null): Promise<Table>
-  createEmptyTable(name: string, schemaBuf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null, dataStorageOptions?: string | undefined | null, enableV2ManifestPaths?: boolean | undefined | null): Promise<Table>
+  createTable(name: string, buf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null): Promise<Table>
+  createEmptyTable(name: string, schemaBuf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null): Promise<Table>
   openTable(name: string, storageOptions?: Record<string, string> | undefined | null, indexCacheSize?: number | undefined | null): Promise<Table>
   /** Drop table with the name. Or raise an error if the table does not exist. */
   dropTable(name: string): Promise<void>
+  dropAllTables(): Promise<void>
 }
 export class Index {
   static ivfPq(distanceType?: string | undefined | null, numPartitions?: number | undefined | null, numSubVectors?: number | undefined | null, numBits?: number | undefined | null, maxIterations?: number | undefined | null, sampleRate?: number | undefined | null): Index

package/dist/native.js

@@ -319,7 +319,7 @@ if (!nativeBinding) {
     }
     throw new Error(`Failed to load native binding`);
 }
-const { Connection, Index, RecordBatchIterator, NativeMergeInsertBuilder, Query, VectorQuery, Reranker, RrfReranker, Table, WriteMode } = nativeBinding;
+const { Connection, Index, RecordBatchIterator, NativeMergeInsertBuilder, Query, VectorQuery, Reranker, RrfReranker, Table } = nativeBinding;
 module.exports.Connection = Connection;
 module.exports.Index = Index;
 module.exports.RecordBatchIterator = RecordBatchIterator;
@@ -329,4 +329,3 @@ module.exports.VectorQuery = VectorQuery;
 module.exports.Reranker = Reranker;
 module.exports.RrfReranker = RrfReranker;
 module.exports.Table = Table;
-module.exports.WriteMode = WriteMode;

package/dist/query.d.ts

@@ -32,10 +32,22 @@ export interface FullTextSearchOptions {
      */
     columns?: string | string[];
 }
-/** Common methods supported by all query types */
+/** Common methods supported by all query types
+ *
+ * @see {@link Query}
+ * @see {@link VectorQuery}
+ *
+ * @hideconstructor
+ */
 export declare class QueryBase<NativeQueryType extends NativeQuery | NativeVectorQuery> implements AsyncIterable<RecordBatch> {
     protected inner: NativeQueryType | Promise<NativeQueryType>;
+    /**
+     * @hidden
+     */
     protected constructor(inner: NativeQueryType | Promise<NativeQueryType>);
+    /**
+     * @hidden
+     */
     protected doCall(fn: (inner: NativeQueryType) => void): void;
     /**
      * A filter statement to be applied to this query.
@@ -52,7 +64,7 @@ export declare class QueryBase<NativeQueryType extends NativeQuery | NativeVecto
     where(predicate: string): this;
     /**
      * A filter statement to be applied to this query.
-     * @alias where
+     * @see where
      * @deprecated Use `where` instead
      */
     filter(predicate: string): this;
@@ -100,7 +112,7 @@ export declare class QueryBase<NativeQueryType extends NativeQuery | NativeVecto
      * Skip searching un-indexed data. This can make search faster, but will miss
      * any data that is not yet indexed.
      *
-     * Use {@link lancedb.Table#optimize} to index all un-indexed data.
+     * Use {@link Table#optimize} to index all un-indexed data.
      */
     fastSearch(): this;
     /**
@@ -111,6 +123,9 @@ export declare class QueryBase<NativeQueryType extends NativeQuery | NativeVecto
      * order to perform hybrid search.
      */
     withRowId(): this;
+    /**
+     * @hidden
+     */
     protected nativeExecute(options?: Partial<QueryExecutionOptions>): Promise<NativeBatchIterator>;
     /**
      * Execute the query and return the results as an @see {@link AsyncIterator}
@@ -124,6 +139,9 @@ export declare class QueryBase<NativeQueryType extends NativeQuery | NativeVecto
      *
      */
     protected execute(options?: Partial<QueryExecutionOptions>): RecordBatchIterator;
+    /**
+     * @hidden
+     */
     [Symbol.asyncIterator](): AsyncIterator<RecordBatch<any>>;
     /** Collect the results as an Arrow @see {@link ArrowTable}. */
     toArrow(options?: Partial<QueryExecutionOptions>): Promise<ArrowTable>;
@@ -156,8 +174,15 @@ export interface ExecutableQuery {
  * A builder used to construct a vector search
  *
  * This builder can be reused to execute the query many times.
+ *
+ * @see {@link Query#nearestTo}
+ *
+ * @hideconstructor
  */
 export declare class VectorQuery extends QueryBase<NativeVectorQuery> {
+    /**
+     * @hidden
+     */
     constructor(inner: NativeVectorQuery | Promise<NativeVectorQuery>);
     /**
      * Set the number of partitions to search (probe)
@@ -282,8 +307,16 @@ export declare class VectorQuery extends QueryBase<NativeVectorQuery> {
     addQueryVector(vector: IntoVector): VectorQuery;
     rerank(reranker: Reranker): VectorQuery;
 }
-/** A builder for LanceDB queries. */
+/** A builder for LanceDB queries.
+ *
+ * @see {@link Table#query}, {@link Table#search}
+ *
+ * @hideconstructor
+ */
 export declare class Query extends QueryBase<NativeQuery> {
+    /**
+     * @hidden
+     */
     constructor(tbl: NativeTable);
     /**
      * Find the nearest vectors to the given query vector.

package/dist/query.js

@@ -44,14 +44,26 @@ class RecordBatchIterable {
         return new RecordBatchIterator(this.inner.execute(this.options?.maxBatchLength));
     }
 }
-/** Common methods supported by all query types */
+/** Common methods supported by all query types
+ *
+ * @see {@link Query}
+ * @see {@link VectorQuery}
+ *
+ * @hideconstructor
+ */
 class QueryBase {
     inner;
+    /**
+     * @hidden
+     */
     constructor(inner) {
         this.inner = inner;
         // intentionally empty
     }
     // call a function on the inner (either a promise or the actual object)
+    /**
+     * @hidden
+     */
     doCall(fn) {
         if (this.inner instanceof Promise) {
             this.inner = this.inner.then((inner) => {
@@ -81,7 +93,7 @@ class QueryBase {
     }
     /**
      * A filter statement to be applied to this query.
-     * @alias where
+     * @see where
      * @deprecated Use `where` instead
      */
     filter(predicate) {
@@ -173,7 +185,7 @@ class QueryBase {
      * Skip searching un-indexed data. This can make search faster, but will miss
      * any data that is not yet indexed.
      *
-     * Use {@link lancedb.Table#optimize} to index all un-indexed data.
+     * Use {@link Table#optimize} to index all un-indexed data.
      */
     fastSearch() {
         this.doCall((inner) => inner.fastSearch());
@@ -190,6 +202,9 @@ class QueryBase {
         this.doCall((inner) => inner.withRowId());
         return this;
     }
+    /**
+     * @hidden
+     */
     nativeExecute(options) {
         if (this.inner instanceof Promise) {
             return this.inner.then((inner) => inner.execute(options?.maxBatchLength));
@@ -212,6 +227,9 @@ class QueryBase {
     execute(options) {
         return new RecordBatchIterator(this.nativeExecute(options));
     }
+    /**
+     * @hidden
+     */
     // biome-ignore lint/suspicious/noExplicitAny: skip
     [Symbol.asyncIterator]() {
         const promise = this.nativeExecute();
@@ -266,8 +284,15 @@ exports.QueryBase = QueryBase;
  * A builder used to construct a vector search
  *
  * This builder can be reused to execute the query many times.
+ *
+ * @see {@link Query#nearestTo}
+ *
+ * @hideconstructor
  */
 class VectorQuery extends QueryBase {
+    /**
+     * @hidden
+     */
     constructor(inner) {
         super(inner);
     }
@@ -472,8 +497,16 @@ class VectorQuery extends QueryBase {
     }
 }
 exports.VectorQuery = VectorQuery;
-/** A builder for LanceDB queries. */
+/** A builder for LanceDB queries.
+ *
+ * @see {@link Table#query}, {@link Table#search}
+ *
+ * @hideconstructor
+ */
 class Query extends QueryBase {
+    /**
+     * @hidden
+     */
     constructor(tbl) {
         super(tbl.query());
     }

package/dist/rerankers/rrf.d.ts

@@ -3,10 +3,11 @@ import { RrfReranker as NativeRRFReranker } from "../native";
 /**
  * Reranks the results using the Reciprocal Rank Fusion (RRF) algorithm.
  *
- * Internally this uses the Rust implementation
+ * @hideconstructor
  */
 export declare class RRFReranker {
     private inner;
+    /** @ignore */
     constructor(inner: NativeRRFReranker);
     static create(k?: number): Promise<RRFReranker>;
     rerankHybrid(query: string, vecResults: RecordBatch, ftsResults: RecordBatch): Promise<RecordBatch>;

package/dist/rerankers/rrf.js

@@ -8,10 +8,11 @@ const native_1 = require("../native");
 /**
  * Reranks the results using the Reciprocal Rank Fusion (RRF) algorithm.
  *
- * Internally this uses the Rust implementation
+ * @hideconstructor
  */
 class RRFReranker {
     inner;
+    /** @ignore */
     constructor(inner) {
         this.inner = inner;
     }