@lancedb/lancedb 0.14.0-beta.2 → 0.14.1-beta.0

package/dist/embedding/index.js

@@ -0,0 +1,112 @@
+"use strict";
+// Copyright 2023 Lance Developers.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextEmbeddingFunction = exports.EmbeddingFunction = void 0;
+exports.LanceSchema = LanceSchema;
+const arrow_1 = require("../arrow");
+const sanitize_1 = require("../sanitize");
+const registry_1 = require("./registry");
+var embedding_function_1 = require("./embedding_function");
+Object.defineProperty(exports, "EmbeddingFunction", { enumerable: true, get: function () { return embedding_function_1.EmbeddingFunction; } });
+Object.defineProperty(exports, "TextEmbeddingFunction", { enumerable: true, get: function () { return embedding_function_1.TextEmbeddingFunction; } });
+__exportStar(require("./registry"), exports);
+/**
+ * Create a schema with embedding functions.
+ *
+ * @param fields
+ * @returns Schema
+ * @example
+ * ```ts
+ * class MyEmbeddingFunction extends EmbeddingFunction {
+ * // ...
+ * }
+ * const func = new MyEmbeddingFunction();
+ * const schema = LanceSchema({
+ *   id: new Int32(),
+ *   text: func.sourceField(new Utf8()),
+ *   vector: func.vectorField(),
+ *   // optional: specify the datatype and/or dimensions
+ *   vector2: func.vectorField({ datatype: new Float32(), dims: 3}),
+ * });
+ *
+ * const table = await db.createTable("my_table", data, { schema });
+ * ```
+ */
+function LanceSchema(fields) {
+    const arrowFields = [];
+    const embeddingFunctions = new Map();
+    Object.entries(fields).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+            const [dtype, metadata] = value;
+            arrowFields.push(new arrow_1.Field(key, (0, sanitize_1.sanitizeType)(dtype), true));
+            parseEmbeddingFunctions(embeddingFunctions, key, metadata);
+        }
+        else {
+            arrowFields.push(new arrow_1.Field(key, (0, sanitize_1.sanitizeType)(value), true));
+        }
+    });
+    const registry = (0, registry_1.getRegistry)();
+    const metadata = registry.getTableMetadata(Array.from(embeddingFunctions.values()));
+    const schema = new arrow_1.Schema(arrowFields, metadata);
+    return schema;
+}
+function parseEmbeddingFunctions(embeddingFunctions, key, metadata) {
+    if (metadata.has("source_column_for")) {
+        const embedFunction = metadata.get("source_column_for");
+        const current = embeddingFunctions.get(embedFunction);
+        if (current !== undefined) {
+            embeddingFunctions.set(embedFunction, {
+                ...current,
+                sourceColumn: key,
+            });
+        }
+        else {
+            embeddingFunctions.set(embedFunction, {
+                sourceColumn: key,
+                function: embedFunction,
+            });
+        }
+    }
+    else if (metadata.has("vector_column_for")) {
+        const embedFunction = metadata.get("vector_column_for");
+        const current = embeddingFunctions.get(embedFunction);
+        if (current !== undefined) {
+            embeddingFunctions.set(embedFunction, {
+                ...current,
+                vectorColumn: key,
+            });
+        }
+        else {
+            embeddingFunctions.set(embedFunction, {
+                vectorColumn: key,
+                function: embedFunction,
+            });
+        }
+    }
+}

package/dist/embedding/openai.d.ts

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

package/dist/embedding/openai.js

@@ -0,0 +1,105 @@
+"use strict";
+// Copyright 2023 Lance Developers.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIEmbeddingFunction = void 0;
+const arrow_1 = require("../arrow");
+const embedding_function_1 = require("./embedding_function");
+const registry_1 = require("./registry");
+let OpenAIEmbeddingFunction = class OpenAIEmbeddingFunction extends embedding_function_1.EmbeddingFunction {
+    #openai;
+    #modelName;
+    constructor(options = {
+        model: "text-embedding-ada-002",
+    }) {
+        super();
+        const openAIKey = options?.apiKey ?? process.env.OPENAI_API_KEY;
+        if (!openAIKey) {
+            throw new Error("OpenAI API key is required");
+        }
+        const modelName = options?.model ?? "text-embedding-ada-002";
+        /**
+         * @type {import("openai").default}
+         */
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        let Openai;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            Openai = require("openai");
+        }
+        catch {
+            throw new Error("please install openai@^4.24.1 using npm install openai");
+        }
+        const configuration = {
+            apiKey: openAIKey,
+        };
+        this.#openai = new Openai(configuration);
+        this.#modelName = modelName;
+    }
+    toJSON() {
+        return {
+            model: this.#modelName,
+        };
+    }
+    ndims() {
+        switch (this.#modelName) {
+            case "text-embedding-ada-002":
+                return 1536;
+            case "text-embedding-3-large":
+                return 3072;
+            case "text-embedding-3-small":
+                return 1536;
+            default:
+                throw new Error(`Unknown model: ${this.#modelName}`);
+        }
+    }
+    embeddingDataType() {
+        return new arrow_1.Float32();
+    }
+    async computeSourceEmbeddings(data) {
+        const response = await this.#openai.embeddings.create({
+            model: this.#modelName,
+            input: data,
+        });
+        const embeddings = [];
+        for (let i = 0; i < response.data.length; i++) {
+            embeddings.push(response.data[i].embedding);
+        }
+        return embeddings;
+    }
+    async computeQueryEmbeddings(data) {
+        if (typeof data !== "string") {
+            throw new Error("Data must be a string");
+        }
+        const response = await this.#openai.embeddings.create({
+            model: this.#modelName,
+            input: data,
+        });
+        return response.data[0].embedding;
+    }
+};
+exports.OpenAIEmbeddingFunction = OpenAIEmbeddingFunction;
+exports.OpenAIEmbeddingFunction = OpenAIEmbeddingFunction = __decorate([
+    (0, registry_1.register)("openai"),
+    __metadata("design:paramtypes", [Object])
+], OpenAIEmbeddingFunction);

package/dist/embedding/registry.d.ts

@@ -0,0 +1,55 @@
+import { type EmbeddingFunction, type EmbeddingFunctionConstructor } from "./embedding_function";
+import "reflect-metadata";
+type CreateReturnType<T> = T extends {
+    init: () => Promise<void>;
+} ? Promise<T> : T;
+interface EmbeddingFunctionCreate<T extends EmbeddingFunction> {
+    create(options?: T["TOptions"]): CreateReturnType<T>;
+}
+/**
+ * This is a singleton class used to register embedding functions
+ * and fetch them by name. It also handles serializing and deserializing.
+ * You can implement your own embedding function by subclassing EmbeddingFunction
+ * or TextEmbeddingFunction and registering it with the registry
+ */
+export declare class EmbeddingFunctionRegistry {
+    #private;
+    /**
+     * Get the number of registered functions
+     */
+    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;
+    get<T extends EmbeddingFunction<unknown>>(name: string): EmbeddingFunctionCreate<T> | undefined;
+    /**
+     * reset the registry to the initial state
+     */
+    reset(this: EmbeddingFunctionRegistry): void;
+    /**
+     * @ignore
+     */
+    parseFunctions(this: EmbeddingFunctionRegistry, metadata: Map<string, string>): Promise<Map<string, EmbeddingFunctionConfig>>;
+    functionToMetadata(conf: EmbeddingFunctionConfig): Record<string, any>;
+    getTableMetadata(functions: EmbeddingFunctionConfig[]): Map<string, string>;
+}
+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
+ * @example
+ * ```ts
+ * const registry = getRegistry();
+ * const openai = registry.get("openai").create();
+ */
+export declare function getRegistry(): EmbeddingFunctionRegistry;
+export interface EmbeddingFunctionConfig {
+    sourceColumn: string;
+    vectorColumn?: string;
+    function: EmbeddingFunction;
+}
+export {};

package/dist/embedding/registry.js

@@ -0,0 +1,151 @@
+"use strict";
+// Copyright 2024 Lance Developers.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddingFunctionRegistry = void 0;
+exports.register = register;
+exports.getRegistry = getRegistry;
+require("reflect-metadata");
+/**
+ * This is a singleton class used to register embedding functions
+ * and fetch them by name. It also handles serializing and deserializing.
+ * You can implement your own embedding function by subclassing EmbeddingFunction
+ * or TextEmbeddingFunction and registering it with the registry
+ */
+class EmbeddingFunctionRegistry {
+    #functions = new Map();
+    /**
+     * Get the number of registered functions
+     */
+    length() {
+        return this.#functions.size;
+    }
+    /**
+     * 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) {
+        const self = this;
+        return function (ctor) {
+            if (!alias) {
+                alias = ctor.name;
+            }
+            if (self.#functions.has(alias)) {
+                throw new Error(`Embedding function with alias "${alias}" already exists`);
+            }
+            self.#functions.set(alias, ctor);
+            Reflect.defineMetadata("lancedb::embedding::name", alias, ctor);
+            return ctor;
+        };
+    }
+    /**
+     * Fetch an embedding function by name
+     * @param name The name of the function
+     */
+    get(name) {
+        const factory = this.#functions.get(name);
+        if (!factory) {
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            return undefined;
+        }
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        let create;
+        if (factory.prototype.init) {
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            create = async function (options) {
+                const instance = new factory(options);
+                await instance.init();
+                return instance;
+            };
+        }
+        else {
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            create = function (options) {
+                const instance = new factory(options);
+                return instance;
+            };
+        }
+        return {
+            create,
+        };
+    }
+    /**
+     * reset the registry to the initial state
+     */
+    reset() {
+        this.#functions.clear();
+    }
+    /**
+     * @ignore
+     */
+    async parseFunctions(metadata) {
+        if (!metadata.has("embedding_functions")) {
+            return new Map();
+        }
+        else {
+            const functions = (JSON.parse(metadata.get("embedding_functions")));
+            const items = await Promise.all(functions.map(async (f) => {
+                const fn = this.get(f.name);
+                if (!fn) {
+                    throw new Error(`Function "${f.name}" not found in registry`);
+                }
+                const func = await this.get(f.name).create(f.model);
+                return [
+                    f.name,
+                    {
+                        sourceColumn: f.sourceColumn,
+                        vectorColumn: f.vectorColumn,
+                        function: func,
+                    },
+                ];
+            }));
+            return new Map(items);
+        }
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    functionToMetadata(conf) {
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        const metadata = {};
+        const name = Reflect.getMetadata("lancedb::embedding::name", conf.function.constructor);
+        metadata["sourceColumn"] = conf.sourceColumn;
+        metadata["vectorColumn"] = conf.vectorColumn ?? "vector";
+        metadata["name"] = name ?? conf.function.constructor.name;
+        metadata["model"] = conf.function.toJSON();
+        return metadata;
+    }
+    getTableMetadata(functions) {
+        const metadata = new Map();
+        const jsonData = functions.map((conf) => this.functionToMetadata(conf));
+        metadata.set("embedding_functions", JSON.stringify(jsonData));
+        return metadata;
+    }
+}
+exports.EmbeddingFunctionRegistry = EmbeddingFunctionRegistry;
+const _REGISTRY = new EmbeddingFunctionRegistry();
+function register(name) {
+    return _REGISTRY.register(name);
+}
+/**
+ * Utility function to get the global instance of the registry
+ * @returns `EmbeddingFunctionRegistry` The global instance of the registry
+ * @example
+ * ```ts
+ * const registry = getRegistry();
+ * const openai = registry.get("openai").create();
+ */
+function getRegistry() {
+    return _REGISTRY;
+}

package/dist/embedding/transformers.d.ts

@@ -0,0 +1,37 @@
+import { Float } from "../arrow";
+import { EmbeddingFunction } from "./embedding_function";
+export type XenovaTransformerOptions = {
+    /** The wasm compatible model to use */
+    model: string;
+    /**
+     * The wasm compatible tokenizer to use
+     * If not provided, it will use the default tokenizer for the model
+     */
+    tokenizer?: string;
+    /**
+     * The number of dimensions of the embeddings
+     *
+     * We will attempt to infer this from the model config if not provided.
+     * Since there isn't a standard way to get this information from the model,
+     * you may need to manually specify this if using a model that doesn't have a 'hidden_size' in the config.
+     * */
+    ndims?: number;
+    /** Options for the tokenizer */
+    tokenizerOptions?: {
+        textPair?: string | string[];
+        padding?: boolean | "max_length";
+        addSpecialTokens?: boolean;
+        truncation?: boolean;
+        maxLength?: number;
+    };
+};
+export declare class TransformersEmbeddingFunction extends EmbeddingFunction<string, Partial<XenovaTransformerOptions>> {
+    #private;
+    constructor(options?: Partial<XenovaTransformerOptions>);
+    toJSON(): Record<string, any>;
+    init(): Promise<void>;
+    ndims(): number;
+    embeddingDataType(): Float;
+    computeSourceEmbeddings(data: string[]): Promise<number[][]>;
+    computeQueryEmbeddings(data: string): Promise<number[]>;
+}

package/dist/embedding/transformers.js

@@ -0,0 +1,148 @@
+"use strict";
+// Copyright 2023 Lance Developers.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformersEmbeddingFunction = void 0;
+const arrow_1 = require("../arrow");
+const embedding_function_1 = require("./embedding_function");
+const registry_1 = require("./registry");
+let TransformersEmbeddingFunction = class TransformersEmbeddingFunction extends embedding_function_1.EmbeddingFunction {
+    #model;
+    #tokenizer;
+    #modelName;
+    #initialized = false;
+    #tokenizerOptions;
+    #ndims;
+    constructor(options = {
+        model: "Xenova/all-MiniLM-L6-v2",
+    }) {
+        super();
+        const modelName = options?.model ?? "Xenova/all-MiniLM-L6-v2";
+        this.#tokenizerOptions = {
+            padding: true,
+            ...options.tokenizerOptions,
+        };
+        this.#ndims = options.ndims;
+        this.#modelName = modelName;
+    }
+    toJSON() {
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        const obj = {
+            model: this.#modelName,
+        };
+        if (this.#ndims) {
+            obj["ndims"] = this.#ndims;
+        }
+        if (this.#tokenizerOptions) {
+            obj["tokenizerOptions"] = this.#tokenizerOptions;
+        }
+        if (this.#tokenizer) {
+            obj["tokenizer"] = this.#tokenizer.name;
+        }
+        return obj;
+    }
+    async init() {
+        let transformers;
+        try {
+            // SAFETY:
+            // since typescript transpiles `import` to `require`, we need to do this in an unsafe way
+            // We can't use `require` because `@huggingface/transformers` is an ESM module
+            // and we can't use `import` directly because typescript will transpile it to `require`.
+            // and we want to remain compatible with both ESM and CJS modules
+            // so we use `eval` to bypass typescript for this specific import.
+            transformers = await eval('import("@huggingface/transformers")');
+        }
+        catch (e) {
+            throw new Error(`error loading @huggingface/transformers\nReason: ${e}`);
+        }
+        try {
+            this.#model = await transformers.AutoModel.from_pretrained(this.#modelName, { dtype: "fp32" });
+        }
+        catch (e) {
+            throw new Error(`error loading model ${this.#modelName}. Make sure you are using a wasm compatible model.\nReason: ${e}`);
+        }
+        try {
+            this.#tokenizer = await transformers.AutoTokenizer.from_pretrained(this.#modelName);
+        }
+        catch (e) {
+            throw new Error(`error loading tokenizer for ${this.#modelName}. Make sure you are using a wasm compatible model:\nReason: ${e}`);
+        }
+        this.#initialized = true;
+    }
+    ndims() {
+        if (this.#ndims) {
+            return this.#ndims;
+        }
+        else {
+            const config = this.#model.config;
+            // biome-ignore lint/style/useNamingConvention: we don't control this name.
+            const ndims = config.hidden_size;
+            if (!ndims) {
+                throw new Error("hidden_size not found in model config, you may need to manually specify the embedding dimensions. ");
+            }
+            return ndims;
+        }
+    }
+    embeddingDataType() {
+        return new arrow_1.Float32();
+    }
+    async computeSourceEmbeddings(data) {
+        // this should only happen if the user is trying to use the function directly.
+        // Anything going through the registry should already be initialized.
+        if (!this.#initialized) {
+            return Promise.reject(new Error("something went wrong: embedding function not initialized. Please call init()"));
+        }
+        const tokenizer = this.#tokenizer;
+        const model = this.#model;
+        const inputs = await tokenizer(data, this.#tokenizerOptions);
+        let tokens = await model.forward(inputs);
+        tokens = tokens[Object.keys(tokens)[0]];
+        const [nItems, nTokens] = tokens.dims;
+        tokens = tensorDiv(tokens.sum(1), nTokens);
+        // TODO: support other data types
+        const tokenData = tokens.data;
+        const stride = this.ndims();
+        const embeddings = [];
+        for (let i = 0; i < nItems; i++) {
+            const start = i * stride;
+            const end = start + stride;
+            const slice = tokenData.slice(start, end);
+            embeddings.push(Array.from(slice)); // TODO: Avoid copy here
+        }
+        return embeddings;
+    }
+    async computeQueryEmbeddings(data) {
+        return (await this.computeSourceEmbeddings([data]))[0];
+    }
+};
+exports.TransformersEmbeddingFunction = TransformersEmbeddingFunction;
+exports.TransformersEmbeddingFunction = TransformersEmbeddingFunction = __decorate([
+    (0, registry_1.register)("huggingface"),
+    __metadata("design:paramtypes", [Object])
+], TransformersEmbeddingFunction);
+const tensorDiv = (src, divBy) => {
+    for (let i = 0; i < src.data.length; ++i) {
+        src.data[i] /= divBy;
+    }
+    return src;
+};

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import { Connection } from "./connection";
+import { ConnectionOptions } from "./native.js";
+export { WriteOptions, WriteMode, AddColumnsSql, ColumnAlteration, ConnectionOptions, IndexStatistics, IndexConfig, ClientConfig, TimeoutConfig, RetryConfig, } 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 * 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>): 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<ConnectionOptions> & {
+    uri: string;
+}): Promise<Connection>;