@lancedb/lancedb 0.5.2 → 0.7.0

package/Cargo.toml

@@ -15,11 +15,11 @@ crate-type = ["cdylib"]
 arrow-ipc.workspace = true
 futures.workspace = true
 lancedb = { path = "../rust/lancedb" }
-napi = { version = "2.15", default-features = false, features = [
-    "napi7",
+napi = { version = "2.16.8", default-features = false, features = [
+    "napi9",
     "async",
 ] }
-napi-derive = "2"
+napi-derive = "2.16.4"
 
 # Prevent dynamic linking of lzma, which comes from datafusion
 lzma-sys = { version = "*", features = ["static"] }

package/biome.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/1.7.3/schema.json",
+  "$schema": "https://biomejs.dev/schemas/1.8.3/schema.json",
   "organizeImports": {
     "enabled": true
   },
@@ -77,7 +77,7 @@
         "noDuplicateObjectKeys": "error",
         "noDuplicateParameters": "error",
         "noEmptyBlockStatements": "error",
-        "noExplicitAny": "error",
+        "noExplicitAny": "warn",
         "noExtraNonNullAssertion": "error",
         "noFallthroughSwitchClause": "error",
         "noFunctionAssign": "error",
@@ -94,12 +94,28 @@
         "useValidTypeof": "error"
       }
     },
-    "ignore": ["**/dist/**/*", "**/native.js", "**/native.d.ts"]
+    "ignore": [
+      "**/dist/**/*",
+      "**/native.js",
+      "**/native.d.ts",
+      "__test__/docs/**/*",
+      "examples/**/*"
+    ]
   },
   "javascript": {
     "globals": []
   },
   "overrides": [
+    {
+      "include": ["__test__/s3_integration.test.ts"],
+      "linter": {
+        "rules": {
+          "style": {
+            "useNamingConvention": "off"
+          }
+        }
+      }
+    },
     {
       "include": [
         "**/*.ts",

package/dist/arrow.d.ts

@@ -1,10 +1,43 @@
 /// <reference types="node" />
-import { Table as ArrowTable, Binary, DataType, FixedSizeBinary, FixedSizeList, Float, Int, LargeBinary, List, Null, Schema, Struct, Utf8 } from "apache-arrow";
+import { Table as ArrowTable, Binary, BufferType, DataType, Field, FixedSizeBinary, FixedSizeList, Float, Int, LargeBinary, List, Null, RecordBatch, Schema, Struct, Utf8 } from "apache-arrow";
+import { Buffers } from "apache-arrow/data";
 import { type EmbeddingFunction } from "./embedding/embedding_function";
 import { EmbeddingFunctionConfig } from "./embedding/registry";
 export * from "apache-arrow";
-export type IntoVector = Float32Array | Float64Array | number[];
-export declare function isArrowTable(value: object): value is ArrowTable;
+export type SchemaLike = Schema | {
+    fields: FieldLike[];
+    metadata: Map<string, string>;
+    get names(): unknown[];
+};
+export type FieldLike = Field | {
+    type: string;
+    name: string;
+    nullable?: boolean;
+    metadata?: Map<string, string>;
+};
+export type DataLike = import("apache-arrow").Data<Struct<any>> | {
+    type: any;
+    length: number;
+    offset: number;
+    stride: number;
+    nullable: boolean;
+    children: DataLike[];
+    get nullCount(): number;
+    values: Buffers<any>[BufferType.DATA];
+    typeIds: Buffers<any>[BufferType.TYPE];
+    nullBitmap: Buffers<any>[BufferType.VALIDITY];
+    valueOffsets: Buffers<any>[BufferType.OFFSET];
+};
+export type RecordBatchLike = RecordBatch | {
+    schema: SchemaLike;
+    data: DataLike;
+};
+export type TableLike = ArrowTable | {
+    schema: SchemaLike;
+    batches: RecordBatchLike[];
+};
+export type IntoVector = Float32Array | Float64Array | number[] | Promise<Float32Array | Float64Array | number[]>;
+export declare function isArrowTable(value: object): value is TableLike;
 export declare function isDataType(value: unknown): value is DataType;
 export declare function isNull(value: unknown): value is Null;
 export declare function isInt(value: unknown): value is Int;
@@ -26,7 +59,7 @@ export declare function isUnion(value: unknown): value is Struct;
 export declare function isFixedSizeBinary(value: unknown): value is FixedSizeBinary;
 export declare function isFixedSizeList(value: unknown): value is FixedSizeList;
 /** Data type accepted by NodeJS SDK */
-export type Data = Record<string, unknown>[] | ArrowTable;
+export type Data = Record<string, unknown>[] | TableLike;
 export declare class VectorColumnOptions {
     /** Vector column type. */
     type: Float;
@@ -34,7 +67,7 @@ export declare class VectorColumnOptions {
 }
 /** Options to control the makeArrowTable call. */
 export declare class MakeArrowTableOptions {
-    schema?: Schema;
+    schema?: SchemaLike;
     vectorColumns: Record<string, VectorColumnOptions>;
     embeddings?: EmbeddingFunction<unknown>;
     embeddingFunction?: EmbeddingFunctionConfig;
@@ -146,7 +179,7 @@ export declare function makeArrowTable(data: Array<Record<string, unknown>>, opt
 /**
  * Create an empty Arrow table with the provided schema
  */
-export declare function makeEmptyTable(schema: Schema, metadata?: Map<string, string>): ArrowTable;
+export declare function makeEmptyTable(schema: SchemaLike, metadata?: Map<string, string>): ArrowTable;
 /**
  * Convert an Array of records into an Arrow Table, optionally applying an
  * embeddings function to it.
@@ -192,7 +225,7 @@ export declare function fromRecordsToStreamBuffer(data: Array<Record<string, unk
  *
  * `schema` is required if the table is empty
  */
-export declare function fromTableToBuffer(table: ArrowTable, embeddings?: EmbeddingFunctionConfig, schema?: Schema): Promise<Buffer>;
+export declare function fromTableToBuffer(table: ArrowTable, embeddings?: EmbeddingFunctionConfig, schema?: SchemaLike): Promise<Buffer>;
 /**
  * Serialize an Arrow Table into a buffer using the Arrow IPC File serialization
  *
@@ -210,7 +243,7 @@ export declare function fromDataToBuffer(data: Data, embeddings?: EmbeddingFunct
  *
  * `schema` is required if the table is empty
  */
-export declare function fromTableToStreamBuffer(table: ArrowTable, embeddings?: EmbeddingFunctionConfig, schema?: Schema): Promise<Buffer>;
+export declare function fromTableToStreamBuffer(table: ArrowTable, embeddings?: EmbeddingFunctionConfig, schema?: SchemaLike): Promise<Buffer>;
 /**
  * Create an empty table with the given schema
  */

package/dist/arrow.js

@@ -505,15 +505,15 @@ async function applyEmbeddingsFromMetadata(table, schema) {
 }
 /** Helper function to apply embeddings to an input table */
 async function applyEmbeddings(table, embeddings, schema) {
+    if (schema !== undefined && schema !== null) {
+        schema = (0, sanitize_1.sanitizeSchema)(schema);
+    }
     if (schema?.metadata.has("embedding_functions")) {
         return applyEmbeddingsFromMetadata(table, schema);
     }
     else if (embeddings == null || embeddings === undefined) {
         return table;
     }
-    if (schema !== undefined && schema !== null) {
-        schema = (0, sanitize_1.sanitizeSchema)(schema);
-    }
     // Convert from ArrowTable to Record<String, Vector>
     const colEntries = [...Array(table.numCols).keys()].map((_, idx) => {
         const name = table.schema.fields[idx].name;
@@ -670,7 +670,7 @@ async function fromDataToBuffer(data, embeddings, schema) {
         schema = (0, sanitize_1.sanitizeSchema)(schema);
     }
     if (isArrowTable(data)) {
-        return fromTableToBuffer(data, embeddings, schema);
+        return fromTableToBuffer((0, sanitize_1.sanitizeTable)(data), embeddings, schema);
     }
     else {
         const table = await convertToTable(data, embeddings, { schema });

package/dist/connection.d.ts

@@ -1,20 +1,7 @@
-import { Table as ArrowTable, Schema } from "./arrow";
+import { Data, SchemaLike, TableLike } from "./arrow";
 import { EmbeddingFunctionConfig } from "./embedding/registry";
-import { ConnectionOptions, Connection as LanceDbConnection } from "./native";
+import { Connection as LanceDbConnection } from "./native";
 import { Table } from "./table";
-/**
- * Connect to a LanceDB instance at the given URI.
- *
- * Accepted formats:
- *
- * - `/path/to/database` - local database
- * - `s3://bucket/path/to/database` or `gs://bucket/path/to/database` - database on cloud storage
- * - `db://host:port` - remote database (LanceDB cloud)
- * @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.
- */
-export declare function connect(uri: string, opts?: Partial<ConnectionOptions>): Promise<Connection>;
 export interface CreateTableOptions {
     /**
      * The mode to use when creating the table.
@@ -46,7 +33,7 @@ export interface CreateTableOptions {
      * The default is true while the new format is in beta
      */
     useLegacyFormat?: boolean;
-    schema?: Schema;
+    schema?: SchemaLike;
     embeddingFunction?: EmbeddingFunctionConfig;
 }
 export interface OpenTableOptions {
@@ -102,11 +89,11 @@ export interface TableNamesOptions {
  * Any created tables are independent and will continue to work even if
  * the underlying connection has been closed.
  */
-export declare class Connection {
-    readonly inner: LanceDbConnection;
-    constructor(inner: LanceDbConnection);
-    /** Return true if the connection has not been closed */
-    isOpen(): boolean;
+export declare abstract class Connection {
+    /**
+     * Return true if the connection has not been closed
+     */
+    abstract isOpen(): boolean;
     /**
      * Close the connection, releasing any underlying resources.
      *
@@ -114,38 +101,71 @@ export declare class Connection {
      *
      * Any attempt to use the connection after it is closed will result in an error.
      */
-    close(): void;
-    /** Return a brief description of the connection */
-    display(): string;
+    abstract close(): void;
+    /**
+     * Return a brief description of the connection
+     */
+    abstract display(): string;
     /**
      * List all the table names in this database.
      *
      * Tables will be returned in lexicographical order.
      * @param {Partial<TableNamesOptions>} options - options to control the
      * paging / start point
+     *
      */
-    tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
+    abstract tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
     /**
      * Open a table in the database.
      * @param {string} name - The name of the table
      */
-    openTable(name: string, options?: Partial<OpenTableOptions>): Promise<Table>;
+    abstract openTable(name: string, options?: Partial<OpenTableOptions>): Promise<Table>;
+    /**
+     * Creates a new Table and initialize it with new data.
+     * @param {object} options - The options object.
+     * @param {string} options.name - The name of the table.
+     * @param {Data} options.data - Non-empty Array of Records to be inserted into the table
+     *
+     */
+    abstract createTable(options: {
+        name: string;
+        data: Data;
+    } & Partial<CreateTableOptions>): Promise<Table>;
     /**
      * Creates a new Table and initialize it with new data.
      * @param {string} name - The name of the table.
-     * @param {Record<string, unknown>[] | ArrowTable} data - Non-empty Array of Records
+     * @param {Record<string, unknown>[] | TableLike} data - Non-empty Array of Records
      * to be inserted into the table
      */
-    createTable(name: string, data: Record<string, unknown>[] | ArrowTable, options?: Partial<CreateTableOptions>): Promise<Table>;
+    abstract createTable(name: string, data: Record<string, unknown>[] | TableLike, options?: Partial<CreateTableOptions>): Promise<Table>;
     /**
      * Creates a new empty Table
      * @param {string} name - The name of the table.
      * @param {Schema} schema - The schema of the table
      */
-    createEmptyTable(name: string, schema: Schema, options?: Partial<CreateTableOptions>): Promise<Table>;
+    abstract createEmptyTable(name: string, schema: import("./arrow").SchemaLike, options?: Partial<CreateTableOptions>): Promise<Table>;
     /**
      * Drop an existing table.
      * @param {string} name The name of the table to drop.
      */
+    abstract dropTable(name: string): Promise<void>;
+}
+export declare class LocalConnection extends Connection {
+    readonly inner: LanceDbConnection;
+    constructor(inner: LanceDbConnection);
+    isOpen(): boolean;
+    close(): void;
+    display(): string;
+    tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
+    openTable(name: string, options?: Partial<OpenTableOptions>): Promise<Table>;
+    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>;
 }
+/**
+ * Takes storage options and makes all the keys snake case.
+ */
+export declare function cleanseStorageOptions(options?: Record<string, string>): Record<string, string> | undefined;

package/dist/connection.js

@@ -13,30 +13,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Connection = exports.connect = void 0;
+exports.cleanseStorageOptions = exports.LocalConnection = exports.Connection = void 0;
 const arrow_1 = require("./arrow");
 const registry_1 = require("./embedding/registry");
-const native_1 = require("./native");
 const table_1 = require("./table");
-/**
- * Connect to a LanceDB instance at the given URI.
- *
- * Accepted formats:
- *
- * - `/path/to/database` - local database
- * - `s3://bucket/path/to/database` or `gs://bucket/path/to/database` - database on cloud storage
- * - `db://host:port` - remote database (LanceDB cloud)
- * @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.
- */
-async function connect(uri, opts) {
-    opts = opts ?? {};
-    opts.storageOptions = cleanseStorageOptions(opts.storageOptions);
-    const nativeConn = await native_1.Connection.new(uri, opts);
-    return new Connection(nativeConn);
-}
-exports.connect = connect;
 /**
  * A LanceDB Connection that allows you to open tables and create new ones.
  *
@@ -56,74 +36,45 @@ exports.connect = connect;
  * the underlying connection has been closed.
  */
 class Connection {
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        return this.display();
+    }
+}
+exports.Connection = Connection;
+class LocalConnection extends Connection {
     inner;
     constructor(inner) {
+        super();
         this.inner = inner;
     }
-    /** Return true if the connection has not been closed */
     isOpen() {
         return this.inner.isOpen();
     }
-    /**
-     * Close the connection, releasing any underlying resources.
-     *
-     * It is safe to call this method multiple times.
-     *
-     * Any attempt to use the connection after it is closed will result in an error.
-     */
     close() {
         this.inner.close();
     }
-    /** Return a brief description of the connection */
     display() {
         return this.inner.display();
     }
-    /**
-     * List all the table names in this database.
-     *
-     * Tables will be returned in lexicographical order.
-     * @param {Partial<TableNamesOptions>} options - options to control the
-     * paging / start point
-     */
     async tableNames(options) {
         return this.inner.tableNames(options?.startAfter, options?.limit);
     }
-    /**
-     * Open a table in the database.
-     * @param {string} name - The name of the table
-     */
     async openTable(name, options) {
         const innerTable = await this.inner.openTable(name, cleanseStorageOptions(options?.storageOptions), options?.indexCacheSize);
-        return new table_1.Table(innerTable);
+        return new table_1.LocalTable(innerTable);
     }
-    /**
-     * Creates a new Table and initialize it with new data.
-     * @param {string} name - The name of the table.
-     * @param {Record<string, unknown>[] | ArrowTable} data - Non-empty Array of Records
-     * to be inserted into the table
-     */
-    async createTable(name, data, options) {
-        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 = data;
+    async createTable(nameOrOptions, data, options) {
+        if (typeof nameOrOptions !== "string" && "name" in nameOrOptions) {
+            const { name, data, ...options } = nameOrOptions;
+            return this.createTable(name, data, options);
         }
-        else {
-            table = (0, arrow_1.makeArrowTable)(data, options);
+        if (data === undefined) {
+            throw new Error("data is required");
         }
-        const buf = await (0, arrow_1.fromTableToBuffer)(table, options?.embeddingFunction, options?.schema);
-        const innerTable = await this.inner.createTable(name, buf, mode, cleanseStorageOptions(options?.storageOptions), options?.useLegacyFormat);
-        return new table_1.Table(innerTable);
+        const { buf, mode } = await table_1.Table.parseTableData(data, options);
+        const innerTable = await this.inner.createTable(nameOrOptions, buf, mode, cleanseStorageOptions(options?.storageOptions), options?.useLegacyFormat);
+        return new table_1.LocalTable(innerTable);
     }
-    /**
-     * Creates a new empty Table
-     * @param {string} name - The name of the table.
-     * @param {Schema} schema - The schema of the table
-     */
     async createEmptyTable(name, schema, options) {
         let mode = options?.mode ?? "create";
         const existOk = options?.existOk ?? false;
@@ -139,17 +90,13 @@ class Connection {
         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), options?.useLegacyFormat);
-        return new table_1.Table(innerTable);
+        return new table_1.LocalTable(innerTable);
     }
-    /**
-     * Drop an existing table.
-     * @param {string} name The name of the table to drop.
-     */
     async dropTable(name) {
         return this.inner.dropTable(name);
     }
 }
-exports.Connection = Connection;
+exports.LocalConnection = LocalConnection;
 /**
  * Takes storage options and makes all the keys snake case.
  */
@@ -166,6 +113,7 @@ function cleanseStorageOptions(options) {
     }
     return result;
 }
+exports.cleanseStorageOptions = cleanseStorageOptions;
 /**
  * Convert a string to snake case. It might already be snake case, in which case it is
  * returned unchanged.

package/dist/embedding/embedding_function.d.ts

@@ -6,10 +6,18 @@ import { DataType, Float, type IntoVector } from "../arrow";
 export interface FunctionOptions {
     [key: string]: any;
 }
+export interface EmbeddingFunctionConstructor<T extends EmbeddingFunction = EmbeddingFunction> {
+    new (modelOptions?: T["TOptions"]): T;
+}
 /**
  * An embedding function that automatically creates vector representation for a given column.
  */
 export declare abstract class EmbeddingFunction<T = any, M extends FunctionOptions = FunctionOptions> {
+    /**
+     * @ignore
+     *  This is only used for associating the options type with the class for type checking
+     */
+    readonly TOptions: M;
     /**
      * Convert the embedding function to a JSON object
      * It is used to serialize the embedding function to the schema
@@ -63,7 +71,7 @@ export declare abstract class EmbeddingFunction<T = any, M extends FunctionOptio
     /**
     Compute the embeddings for a single query
    */
-    computeQueryEmbeddings(data: T): Promise<IntoVector>;
+    computeQueryEmbeddings(data: T): Promise<Awaited<IntoVector>>;
 }
 export interface FieldOptions<T extends DataType = DataType> {
     datatype: T;

package/dist/embedding/embedding_function.js

@@ -21,6 +21,12 @@ const sanitize_1 = require("../sanitize");
  * An embedding function that automatically creates vector representation for a given column.
  */
 class EmbeddingFunction {
+    /**
+     * @ignore
+     *  This is only used for associating the options type with the class for type checking
+     */
+    // biome-ignore lint/style/useNamingConvention: we want to keep the name as it is
+    TOptions;
     /**
      * sourceField is used in combination with `LanceSchema` to provide a declarative data model
      *

package/dist/embedding/openai.d.ts

@@ -1,14 +1,15 @@
+import { type EmbeddingCreateParams } from "openai/resources";
 import { Float } from "../arrow";
 import { EmbeddingFunction } from "./embedding_function";
 export type OpenAIOptions = {
-    apiKey?: string;
-    model?: string;
+    apiKey: string;
+    model: EmbeddingCreateParams["model"];
 };
-export declare class OpenAIEmbeddingFunction extends EmbeddingFunction<string, OpenAIOptions> {
+export declare class OpenAIEmbeddingFunction extends EmbeddingFunction<string, Partial<OpenAIOptions>> {
     #private;
-    constructor(options?: OpenAIOptions);
+    constructor(options?: Partial<OpenAIOptions>);
     toJSON(): {
-        model: string;
+        model: (string & {}) | "text-embedding-ada-002" | "text-embedding-3-small" | "text-embedding-3-large";
     };
     ndims(): number;
     embeddingDataType(): Float;

package/dist/embedding/openai.js

@@ -29,7 +29,9 @@ const registry_1 = require("./registry");
 let OpenAIEmbeddingFunction = class OpenAIEmbeddingFunction extends embedding_function_1.EmbeddingFunction {
     #openai;
     #modelName;
-    constructor(options = { model: "text-embedding-ada-002" }) {
+    constructor(options = {
+        model: "text-embedding-ada-002",
+    }) {
         super();
         const openAIKey = options?.apiKey ?? process.env.OPENAI_API_KEY;
         if (!openAIKey) {
@@ -68,7 +70,7 @@ let OpenAIEmbeddingFunction = class OpenAIEmbeddingFunction extends embedding_fu
             case "text-embedding-3-small":
                 return 1536;
             default:
-                return null;
+                throw new Error(`Unknown model: ${this.#modelName}`);
         }
     }
     embeddingDataType() {

package/dist/embedding/registry.d.ts

@@ -1,13 +1,8 @@
-import type { EmbeddingFunction } from "./embedding_function";
+import { type EmbeddingFunction, type EmbeddingFunctionConstructor } from "./embedding_function";
 import "reflect-metadata";
-export interface EmbeddingFunctionOptions {
-    [key: string]: unknown;
-}
-export interface EmbeddingFunctionFactory<T extends EmbeddingFunction = EmbeddingFunction> {
-    new (modelOptions?: EmbeddingFunctionOptions): T;
-}
+import { OpenAIEmbeddingFunction } from "./openai";
 interface EmbeddingFunctionCreate<T extends EmbeddingFunction> {
-    create(options?: EmbeddingFunctionOptions): T;
+    create(options?: T["TOptions"]): T;
 }
 /**
  * This is a singleton class used to register embedding functions
@@ -23,12 +18,12 @@ export declare class EmbeddingFunctionRegistry {
      * @param func The function to register
      * @throws Error if the function is already registered
      */
-    register<T extends EmbeddingFunctionFactory = EmbeddingFunctionFactory>(this: EmbeddingFunctionRegistry, alias?: string): (ctor: T) => any;
+    register<T extends EmbeddingFunctionConstructor = EmbeddingFunctionConstructor>(this: EmbeddingFunctionRegistry, alias?: string): (ctor: T) => any;
     /**
      * Fetch an embedding function by name
      * @param name The name of the function
      */
-    get<T extends EmbeddingFunction<unknown> = EmbeddingFunction>(name: string): EmbeddingFunctionCreate<T> | undefined;
+    get<T extends EmbeddingFunction<unknown>, Name extends string = "">(name: Name extends "openai" ? "openai" : string): Name extends "openai" ? EmbeddingFunctionCreate<OpenAIEmbeddingFunction> : EmbeddingFunctionCreate<T> | undefined;
     /**
      * reset the registry to the initial state
      */
@@ -40,7 +35,7 @@ export declare class EmbeddingFunctionRegistry {
     functionToMetadata(conf: EmbeddingFunctionConfig): Record<string, any>;
     getTableMetadata(functions: EmbeddingFunctionConfig[]): Map<string, string>;
 }
-export declare function register(name?: string): (ctor: EmbeddingFunctionFactory<EmbeddingFunction<any, import("./embedding_function").FunctionOptions>>) => any;
+export declare function register(name?: string): (ctor: EmbeddingFunctionConstructor<EmbeddingFunction<any, import("./embedding_function").FunctionOptions>>) => any;
 /**
  * Utility function to get the global instance of the registry
  * @returns `EmbeddingFunctionRegistry` The global instance of the registry

package/dist/index.d.ts

@@ -1,7 +1,55 @@
-export { WriteOptions, WriteMode, AddColumnsSql, ColumnAlteration, ConnectionOptions, } from "./native.js";
+import { Connection } from "./connection";
+import { ConnectionOptions } from "./native.js";
+import { RemoteConnectionOptions } from "./remote";
+export { WriteOptions, WriteMode, AddColumnsSql, ColumnAlteration, ConnectionOptions, IndexStatistics, IndexMetadata, IndexConfig, } from "./native.js";
 export { makeArrowTable, MakeArrowTableOptions, Data, VectorColumnOptions, } from "./arrow";
-export { connect, Connection, CreateTableOptions, TableNamesOptions, } from "./connection";
+export { Connection, CreateTableOptions, TableNamesOptions, } from "./connection";
 export { ExecutableQuery, Query, QueryBase, VectorQuery, RecordBatchIterator, } from "./query";
 export { Index, IndexOptions, IvfPqOptions } from "./indices";
-export { Table, AddDataOptions, IndexConfig, UpdateOptions } from "./table";
+export { Table, AddDataOptions, UpdateOptions } from "./table";
 export * as embedding from "./embedding";
+/**
+ * Connect to a LanceDB instance at the given URI.
+ *
+ * Accepted formats:
+ *
+ * - `/path/to/database` - local database
+ * - `s3://bucket/path/to/database` or `gs://bucket/path/to/database` - database on cloud storage
+ * - `db://host:port` - remote database (LanceDB cloud)
+ * @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.
+ * @example
+ * ```ts
+ * const conn = await connect("/path/to/database");
+ * ```
+ * @example
+ * ```ts
+ * const conn = await connect(
+ *   "s3://bucket/path/to/database",
+ *   {storageOptions: {timeout: "60s"}
+ * });
+ * ```
+ */
+export declare function connect(uri: string, opts?: Partial<ConnectionOptions | RemoteConnectionOptions>): Promise<Connection>;
+/**
+ * Connect to a LanceDB instance at the given URI.
+ *
+ * Accepted formats:
+ *
+ * - `/path/to/database` - local database
+ * - `s3://bucket/path/to/database` or `gs://bucket/path/to/database` - database on cloud storage
+ * - `db://host:port` - remote database (LanceDB cloud)
+ * @param  options - The options to use when connecting to the database
+ * @see {@link ConnectionOptions} for more details on the URI format.
+ * @example
+ * ```ts
+ * const conn = await connect({
+ *   uri: "/path/to/database",
+ *   storageOptions: {timeout: "60s"}
+ * });
+ * ```
+ */
+export declare function connect(opts: Partial<RemoteConnectionOptions | ConnectionOptions> & {
+    uri: string;
+}): Promise<Connection>;