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

package/dist/embedding/index.js

@@ -1,112 +0,0 @@
-"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

@@ -1,18 +0,0 @@
-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

@@ -1,105 +0,0 @@
-"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

@@ -1,55 +0,0 @@
-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

@@ -1,151 +0,0 @@
-"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

@@ -1,37 +0,0 @@
-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

@@ -1,148 +0,0 @@
-"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

@@ -1,54 +0,0 @@
-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>;