@lancedb/lancedb 0.4.3 → 0.4.13

package/nodejs-artifacts/sanitize.js

@@ -0,0 +1,369 @@
+"use strict";
+// Copyright 2023 LanceDB 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.sanitizeSchema = void 0;
+// The utilities in this file help sanitize data from the user's arrow
+// library into the types expected by vectordb's arrow library.  Node
+// generally allows for mulitple versions of the same library (and sometimes
+// even multiple copies of the same version) to be installed at the same
+// time.  However, arrow-js uses instanceof which expected that the input
+// comes from the exact same library instance.  This is not always the case
+// and so we must sanitize the input to ensure that it is compatible.
+const apache_arrow_1 = require("apache-arrow");
+function sanitizeMetadata(metadataLike) {
+    if (metadataLike === undefined || metadataLike === null) {
+        return undefined;
+    }
+    if (!(metadataLike instanceof Map)) {
+        throw Error("Expected metadata, if present, to be a Map<string, string>");
+    }
+    for (const item of metadataLike) {
+        if (!(typeof item[0] === "string" || !(typeof item[1] === "string"))) {
+            throw Error("Expected metadata, if present, to be a Map<string, string> but it had non-string keys or values");
+        }
+    }
+    return metadataLike;
+}
+function sanitizeInt(typeLike) {
+    if (!("bitWidth" in typeLike) ||
+        typeof typeLike.bitWidth !== "number" ||
+        !("isSigned" in typeLike) ||
+        typeof typeLike.isSigned !== "boolean") {
+        throw Error("Expected an Int Type to have a `bitWidth` and `isSigned` property");
+    }
+    return new apache_arrow_1.Int(typeLike.isSigned, typeLike.bitWidth);
+}
+function sanitizeFloat(typeLike) {
+    if (!("precision" in typeLike) || typeof typeLike.precision !== "number") {
+        throw Error("Expected a Float Type to have a `precision` property");
+    }
+    return new apache_arrow_1.Float(typeLike.precision);
+}
+function sanitizeDecimal(typeLike) {
+    if (!("scale" in typeLike) ||
+        typeof typeLike.scale !== "number" ||
+        !("precision" in typeLike) ||
+        typeof typeLike.precision !== "number" ||
+        !("bitWidth" in typeLike) ||
+        typeof typeLike.bitWidth !== "number") {
+        throw Error("Expected a Decimal Type to have `scale`, `precision`, and `bitWidth` properties");
+    }
+    return new apache_arrow_1.Decimal(typeLike.scale, typeLike.precision, typeLike.bitWidth);
+}
+function sanitizeDate(typeLike) {
+    if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
+        throw Error("Expected a Date type to have a `unit` property");
+    }
+    return new apache_arrow_1.Date_(typeLike.unit);
+}
+function sanitizeTime(typeLike) {
+    if (!("unit" in typeLike) ||
+        typeof typeLike.unit !== "number" ||
+        !("bitWidth" in typeLike) ||
+        typeof typeLike.bitWidth !== "number") {
+        throw Error("Expected a Time type to have `unit` and `bitWidth` properties");
+    }
+    return new apache_arrow_1.Time(typeLike.unit, typeLike.bitWidth);
+}
+function sanitizeTimestamp(typeLike) {
+    if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
+        throw Error("Expected a Timestamp type to have a `unit` property");
+    }
+    let timezone = null;
+    if ("timezone" in typeLike && typeof typeLike.timezone === "string") {
+        timezone = typeLike.timezone;
+    }
+    return new apache_arrow_1.Timestamp(typeLike.unit, timezone);
+}
+function sanitizeTypedTimestamp(typeLike, 
+// eslint-disable-next-line @typescript-eslint/naming-convention
+Datatype) {
+    let timezone = null;
+    if ("timezone" in typeLike && typeof typeLike.timezone === "string") {
+        timezone = typeLike.timezone;
+    }
+    return new Datatype(timezone);
+}
+function sanitizeInterval(typeLike) {
+    if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
+        throw Error("Expected an Interval type to have a `unit` property");
+    }
+    return new apache_arrow_1.Interval(typeLike.unit);
+}
+function sanitizeList(typeLike) {
+    if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
+        throw Error("Expected a List type to have an array-like `children` property");
+    }
+    if (typeLike.children.length !== 1) {
+        throw Error("Expected a List type to have exactly one child");
+    }
+    return new apache_arrow_1.List(sanitizeField(typeLike.children[0]));
+}
+function sanitizeStruct(typeLike) {
+    if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
+        throw Error("Expected a Struct type to have an array-like `children` property");
+    }
+    return new apache_arrow_1.Struct(typeLike.children.map((child) => sanitizeField(child)));
+}
+function sanitizeUnion(typeLike) {
+    if (!("typeIds" in typeLike) ||
+        !("mode" in typeLike) ||
+        typeof typeLike.mode !== "number") {
+        throw Error("Expected a Union type to have `typeIds` and `mode` properties");
+    }
+    if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
+        throw Error("Expected a Union type to have an array-like `children` property");
+    }
+    return new apache_arrow_1.Union(typeLike.mode, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    typeLike.typeIds, typeLike.children.map((child) => sanitizeField(child)));
+}
+function sanitizeTypedUnion(typeLike, 
+// eslint-disable-next-line @typescript-eslint/naming-convention
+UnionType) {
+    if (!("typeIds" in typeLike)) {
+        throw Error("Expected a DenseUnion/SparseUnion type to have a `typeIds` property");
+    }
+    if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
+        throw Error("Expected a DenseUnion/SparseUnion type to have an array-like `children` property");
+    }
+    return new UnionType(typeLike.typeIds, typeLike.children.map((child) => sanitizeField(child)));
+}
+function sanitizeFixedSizeBinary(typeLike) {
+    if (!("byteWidth" in typeLike) || typeof typeLike.byteWidth !== "number") {
+        throw Error("Expected a FixedSizeBinary type to have a `byteWidth` property");
+    }
+    return new apache_arrow_1.FixedSizeBinary(typeLike.byteWidth);
+}
+function sanitizeFixedSizeList(typeLike) {
+    if (!("listSize" in typeLike) || typeof typeLike.listSize !== "number") {
+        throw Error("Expected a FixedSizeList type to have a `listSize` property");
+    }
+    if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
+        throw Error("Expected a FixedSizeList type to have an array-like `children` property");
+    }
+    if (typeLike.children.length !== 1) {
+        throw Error("Expected a FixedSizeList type to have exactly one child");
+    }
+    return new apache_arrow_1.FixedSizeList(typeLike.listSize, sanitizeField(typeLike.children[0]));
+}
+function sanitizeMap(typeLike) {
+    if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
+        throw Error("Expected a Map type to have an array-like `children` property");
+    }
+    if (!("keysSorted" in typeLike) || typeof typeLike.keysSorted !== "boolean") {
+        throw Error("Expected a Map type to have a `keysSorted` property");
+    }
+    return new apache_arrow_1.Map_(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    typeLike.children.map((field) => sanitizeField(field)), typeLike.keysSorted);
+}
+function sanitizeDuration(typeLike) {
+    if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
+        throw Error("Expected a Duration type to have a `unit` property");
+    }
+    return new apache_arrow_1.Duration(typeLike.unit);
+}
+function sanitizeDictionary(typeLike) {
+    if (!("id" in typeLike) || typeof typeLike.id !== "number") {
+        throw Error("Expected a Dictionary type to have an `id` property");
+    }
+    if (!("indices" in typeLike) || typeof typeLike.indices !== "object") {
+        throw Error("Expected a Dictionary type to have an `indices` property");
+    }
+    if (!("dictionary" in typeLike) || typeof typeLike.dictionary !== "object") {
+        throw Error("Expected a Dictionary type to have an `dictionary` property");
+    }
+    if (!("isOrdered" in typeLike) || typeof typeLike.isOrdered !== "boolean") {
+        throw Error("Expected a Dictionary type to have an `isOrdered` property");
+    }
+    return new apache_arrow_1.Dictionary(sanitizeType(typeLike.dictionary), sanitizeType(typeLike.indices), typeLike.id, typeLike.isOrdered);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function sanitizeType(typeLike) {
+    if (typeof typeLike !== "object" || typeLike === null) {
+        throw Error("Expected a Type but object was null/undefined");
+    }
+    if (!("typeId" in typeLike) || !(typeof typeLike.typeId !== "function")) {
+        throw Error("Expected a Type to have a typeId function");
+    }
+    let typeId;
+    if (typeof typeLike.typeId === "function") {
+        typeId = typeLike.typeId();
+    }
+    else if (typeof typeLike.typeId === "number") {
+        typeId = typeLike.typeId;
+    }
+    else {
+        throw Error("Type's typeId property was not a function or number");
+    }
+    switch (typeId) {
+        case apache_arrow_1.Type.NONE:
+            throw Error("Received a Type with a typeId of NONE");
+        case apache_arrow_1.Type.Null:
+            return new apache_arrow_1.Null();
+        case apache_arrow_1.Type.Int:
+            return sanitizeInt(typeLike);
+        case apache_arrow_1.Type.Float:
+            return sanitizeFloat(typeLike);
+        case apache_arrow_1.Type.Binary:
+            return new apache_arrow_1.Binary();
+        case apache_arrow_1.Type.Utf8:
+            return new apache_arrow_1.Utf8();
+        case apache_arrow_1.Type.Bool:
+            return new apache_arrow_1.Bool();
+        case apache_arrow_1.Type.Decimal:
+            return sanitizeDecimal(typeLike);
+        case apache_arrow_1.Type.Date:
+            return sanitizeDate(typeLike);
+        case apache_arrow_1.Type.Time:
+            return sanitizeTime(typeLike);
+        case apache_arrow_1.Type.Timestamp:
+            return sanitizeTimestamp(typeLike);
+        case apache_arrow_1.Type.Interval:
+            return sanitizeInterval(typeLike);
+        case apache_arrow_1.Type.List:
+            return sanitizeList(typeLike);
+        case apache_arrow_1.Type.Struct:
+            return sanitizeStruct(typeLike);
+        case apache_arrow_1.Type.Union:
+            return sanitizeUnion(typeLike);
+        case apache_arrow_1.Type.FixedSizeBinary:
+            return sanitizeFixedSizeBinary(typeLike);
+        case apache_arrow_1.Type.FixedSizeList:
+            return sanitizeFixedSizeList(typeLike);
+        case apache_arrow_1.Type.Map:
+            return sanitizeMap(typeLike);
+        case apache_arrow_1.Type.Duration:
+            return sanitizeDuration(typeLike);
+        case apache_arrow_1.Type.Dictionary:
+            return sanitizeDictionary(typeLike);
+        case apache_arrow_1.Type.Int8:
+            return new apache_arrow_1.Int8();
+        case apache_arrow_1.Type.Int16:
+            return new apache_arrow_1.Int16();
+        case apache_arrow_1.Type.Int32:
+            return new apache_arrow_1.Int32();
+        case apache_arrow_1.Type.Int64:
+            return new apache_arrow_1.Int64();
+        case apache_arrow_1.Type.Uint8:
+            return new apache_arrow_1.Uint8();
+        case apache_arrow_1.Type.Uint16:
+            return new apache_arrow_1.Uint16();
+        case apache_arrow_1.Type.Uint32:
+            return new apache_arrow_1.Uint32();
+        case apache_arrow_1.Type.Uint64:
+            return new apache_arrow_1.Uint64();
+        case apache_arrow_1.Type.Float16:
+            return new apache_arrow_1.Float16();
+        case apache_arrow_1.Type.Float32:
+            return new apache_arrow_1.Float32();
+        case apache_arrow_1.Type.Float64:
+            return new apache_arrow_1.Float64();
+        case apache_arrow_1.Type.DateMillisecond:
+            return new apache_arrow_1.DateMillisecond();
+        case apache_arrow_1.Type.DateDay:
+            return new apache_arrow_1.DateDay();
+        case apache_arrow_1.Type.TimeNanosecond:
+            return new apache_arrow_1.TimeNanosecond();
+        case apache_arrow_1.Type.TimeMicrosecond:
+            return new apache_arrow_1.TimeMicrosecond();
+        case apache_arrow_1.Type.TimeMillisecond:
+            return new apache_arrow_1.TimeMillisecond();
+        case apache_arrow_1.Type.TimeSecond:
+            return new apache_arrow_1.TimeSecond();
+        case apache_arrow_1.Type.TimestampNanosecond:
+            return sanitizeTypedTimestamp(typeLike, apache_arrow_1.TimestampNanosecond);
+        case apache_arrow_1.Type.TimestampMicrosecond:
+            return sanitizeTypedTimestamp(typeLike, apache_arrow_1.TimestampMicrosecond);
+        case apache_arrow_1.Type.TimestampMillisecond:
+            return sanitizeTypedTimestamp(typeLike, apache_arrow_1.TimestampMillisecond);
+        case apache_arrow_1.Type.TimestampSecond:
+            return sanitizeTypedTimestamp(typeLike, apache_arrow_1.TimestampSecond);
+        case apache_arrow_1.Type.DenseUnion:
+            return sanitizeTypedUnion(typeLike, apache_arrow_1.DenseUnion);
+        case apache_arrow_1.Type.SparseUnion:
+            return sanitizeTypedUnion(typeLike, apache_arrow_1.SparseUnion);
+        case apache_arrow_1.Type.IntervalDayTime:
+            return new apache_arrow_1.IntervalDayTime();
+        case apache_arrow_1.Type.IntervalYearMonth:
+            return new apache_arrow_1.IntervalYearMonth();
+        case apache_arrow_1.Type.DurationNanosecond:
+            return new apache_arrow_1.DurationNanosecond();
+        case apache_arrow_1.Type.DurationMicrosecond:
+            return new apache_arrow_1.DurationMicrosecond();
+        case apache_arrow_1.Type.DurationMillisecond:
+            return new apache_arrow_1.DurationMillisecond();
+        case apache_arrow_1.Type.DurationSecond:
+            return new apache_arrow_1.DurationSecond();
+        default:
+            throw new Error("Unrecoginized type id in schema: " + typeId);
+    }
+}
+function sanitizeField(fieldLike) {
+    if (fieldLike instanceof apache_arrow_1.Field) {
+        return fieldLike;
+    }
+    if (typeof fieldLike !== "object" || fieldLike === null) {
+        throw Error("Expected a Field but object was null/undefined");
+    }
+    if (!("type" in fieldLike) ||
+        !("name" in fieldLike) ||
+        !("nullable" in fieldLike)) {
+        throw Error("The field passed in is missing a `type`/`name`/`nullable` property");
+    }
+    const type = sanitizeType(fieldLike.type);
+    const name = fieldLike.name;
+    if (!(typeof name === "string")) {
+        throw Error("The field passed in had a non-string `name` property");
+    }
+    const nullable = fieldLike.nullable;
+    if (!(typeof nullable === "boolean")) {
+        throw Error("The field passed in had a non-boolean `nullable` property");
+    }
+    let metadata;
+    if ("metadata" in fieldLike) {
+        metadata = sanitizeMetadata(fieldLike.metadata);
+    }
+    return new apache_arrow_1.Field(name, type, nullable, metadata);
+}
+/**
+ * Convert something schemaLike into a Schema instance
+ *
+ * This method is often needed even when the caller is using a Schema
+ * instance because they might be using a different instance of apache-arrow
+ * than lancedb is using.
+ */
+function sanitizeSchema(schemaLike) {
+    if (schemaLike instanceof apache_arrow_1.Schema) {
+        return schemaLike;
+    }
+    if (typeof schemaLike !== "object" || schemaLike === null) {
+        throw Error("Expected a Schema but object was null/undefined");
+    }
+    if (!("fields" in schemaLike)) {
+        throw Error("The schema passed in does not appear to be a schema (no 'fields' property)");
+    }
+    let metadata;
+    if ("metadata" in schemaLike) {
+        metadata = sanitizeMetadata(schemaLike.metadata);
+    }
+    if (!Array.isArray(schemaLike.fields)) {
+        throw Error("The schema passed in had a 'fields' property but it was not an array");
+    }
+    const sanitizedFields = schemaLike.fields.map((field) => sanitizeField(field));
+    return new apache_arrow_1.Schema(sanitizedFields, metadata);
+}
+exports.sanitizeSchema = sanitizeSchema;

package/nodejs-artifacts/table.d.ts

@@ -0,0 +1,252 @@
+import { Schema } from "apache-arrow";
+import { AddColumnsSql, ColumnAlteration, IndexConfig, Table as _NativeTable } from "./native";
+import { Query, VectorQuery } from "./query";
+import { IndexOptions } from "./indices";
+import { Data } from "./arrow";
+export { IndexConfig } from "./native";
+/**
+ * Options for adding data to a table.
+ */
+export interface AddDataOptions {
+    /**
+     * If "append" (the default) then the new data will be added to the table
+     *
+     * If "overwrite" then the new data will replace the existing data in the table.
+     */
+    mode: "append" | "overwrite";
+}
+export interface UpdateOptions {
+    /**
+     * A filter that limits the scope of the update.
+     *
+     * This should be an SQL filter expression.
+     *
+     * Only rows that satisfy the expression will be updated.
+     *
+     * For example, this could be 'my_col == 0' to replace all instances
+     * of 0 in a column with some other default value.
+     */
+    where: string;
+}
+/**
+ * A Table is a collection of Records in a LanceDB Database.
+ *
+ * A Table object is expected to be long lived and reused for multiple operations.
+ * Table objects will cache a certain amount of index data in memory.  This cache
+ * will be freed when the Table is garbage collected.  To eagerly free the cache you
+ * can call the `close` method.  Once the Table is closed, it cannot be used for any
+ * further operations.
+ *
+ * Closing a table is optional.  It not closed, it will be closed when it is garbage
+ * collected.
+ */
+export declare class Table {
+    private readonly inner;
+    /** Construct a Table. Internal use only. */
+    constructor(inner: _NativeTable);
+    /** Return true if the table has not been closed */
+    isOpen(): boolean;
+    /**
+     * Close the table, releasing any underlying resources.
+     *
+     * It is safe to call this method multiple times.
+     *
+     * Any attempt to use the table after it is closed will result in an error.
+     */
+    close(): void;
+    /** Return a brief description of the table */
+    display(): string;
+    /** Get the schema of the table. */
+    schema(): Promise<Schema>;
+    /**
+     * Insert records into this Table.
+     * @param {Data} data Records to be inserted into the Table
+     */
+    add(data: Data, options?: Partial<AddDataOptions>): Promise<void>;
+    /**
+     * Update existing records in the Table
+     *
+     * An update operation can be used to adjust existing values.  Use the
+     * returned builder to specify which columns to update.  The new value
+     * can be a literal value (e.g. replacing nulls with some default value)
+     * or an expression applied to the old value (e.g. incrementing a value)
+     *
+     * An optional condition can be specified (e.g. "only update if the old
+     * value is 0")
+     *
+     * Note: if your condition is something like "some_id_column == 7" and
+     * you are updating many rows (with different ids) then you will get
+     * better performance with a single [`merge_insert`] call instead of
+     * repeatedly calilng this method.
+     * @param {Map<string, string> | Record<string, string>} updates - the
+     * columns to update
+     *
+     * Keys in the map should specify the name of the column to update.
+     * Values in the map provide the new value of the column.  These can
+     * be SQL literal strings (e.g. "7" or "'foo'") or they can be expressions
+     * based on the row being updated (e.g. "my_col + 1")
+     * @param {Partial<UpdateOptions>} options - additional options to control
+     * the update behavior
+     */
+    update(updates: Map<string, string> | Record<string, string>, options?: Partial<UpdateOptions>): Promise<void>;
+    /** Count the total number of rows in the dataset. */
+    countRows(filter?: string): Promise<number>;
+    /** Delete the rows that satisfy the predicate. */
+    delete(predicate: string): Promise<void>;
+    /**
+     * Create an index to speed up queries.
+     *
+     * Indices can be created on vector columns or scalar columns.
+     * Indices on vector columns will speed up vector searches.
+     * Indices on scalar columns will speed up filtering (in both
+     * vector and non-vector searches)
+     * @example
+     * // If the column has a vector (fixed size list) data type then
+     * // an IvfPq vector index will be created.
+     * const table = await conn.openTable("my_table");
+     * await table.createIndex(["vector"]);
+     * @example
+     * // For advanced control over vector index creation you can specify
+     * // the index type and options.
+     * const table = await conn.openTable("my_table");
+     * await table.createIndex(["vector"], I)
+     *   .ivf_pq({ num_partitions: 128, num_sub_vectors: 16 })
+     *   .build();
+     * @example
+     * // Or create a Scalar index
+     * await table.createIndex("my_float_col").build();
+     */
+    createIndex(column: string, options?: Partial<IndexOptions>): Promise<void>;
+    /**
+     * Create a {@link Query} Builder.
+     *
+     * Queries allow you to search your existing data.  By default the query will
+     * return all the data in the table in no particular order.  The builder
+     * returned by this method can be used to control the query using filtering,
+     * vector similarity, sorting, and more.
+     *
+     * Note: By default, all columns are returned.  For best performance, you should
+     * only fetch the columns you need.  See [`Query::select_with_projection`] for
+     * more details.
+     *
+     * When appropriate, various indices and statistics based pruning will be used to
+     * accelerate the query.
+     * @example
+     * // SQL-style filtering
+     * //
+     * // This query will return up to 1000 rows whose value in the `id` column
+     * // is greater than 5.  LanceDb supports a broad set of filtering functions.
+     * for await (const batch of table.query()
+     *                          .filter("id > 1").select(["id"]).limit(20)) {
+     *  console.log(batch);
+     * }
+     * @example
+     * // Vector Similarity Search
+     * //
+     * // This example will find the 10 rows whose value in the "vector" column are
+     * // closest to the query vector [1.0, 2.0, 3.0].  If an index has been created
+     * // on the "vector" column then this will perform an ANN search.
+     * //
+     * // The `refine_factor` and `nprobes` methods are used to control the recall /
+     * // latency tradeoff of the search.
+     * for await (const batch of table.query()
+     *                    .nearestTo([1, 2, 3])
+     *                    .refineFactor(5).nprobe(10)
+     *                    .limit(10)) {
+     *  console.log(batch);
+     * }
+     * @example
+     * // Scan the full dataset
+     * //
+     * // This query will return everything in the table in no particular order.
+     * for await (const batch of table.query()) {
+     *   console.log(batch);
+     * }
+     * @returns {Query} A builder that can be used to parameterize the query
+     */
+    query(): Query;
+    /**
+     * Search the table with a given query vector.
+     *
+     * This is a convenience method for preparing a vector query and
+     * is the same thing as calling `nearestTo` on the builder returned
+     * by `query`.  @see {@link Query#nearestTo} for more details.
+     */
+    vectorSearch(vector: unknown): VectorQuery;
+    /**
+     * Add new columns with defined values.
+     * @param {AddColumnsSql[]} newColumnTransforms pairs of column names and
+     * the SQL expression to use to calculate the value of the new column. These
+     * expressions will be evaluated for each row in the table, and can
+     * reference existing columns in the table.
+     */
+    addColumns(newColumnTransforms: AddColumnsSql[]): Promise<void>;
+    /**
+     * Alter the name or nullability of columns.
+     * @param {ColumnAlteration[]} columnAlterations One or more alterations to
+     * apply to columns.
+     */
+    alterColumns(columnAlterations: ColumnAlteration[]): Promise<void>;
+    /**
+     * Drop one or more columns from the dataset
+     *
+     * This is a metadata-only operation and does not remove the data from the
+     * underlying storage. In order to remove the data, you must subsequently
+     * call ``compact_files`` to rewrite the data without the removed columns and
+     * then call ``cleanup_files`` to remove the old files.
+     * @param {string[]} columnNames The names of the columns to drop. These can
+     * be nested column references (e.g. "a.b.c") or top-level column names
+     * (e.g. "a").
+     */
+    dropColumns(columnNames: string[]): Promise<void>;
+    /**
+     * Retrieve the version of the table
+     *
+     * LanceDb supports versioning.  Every operation that modifies the table increases
+     * version.  As long as a version hasn't been deleted you can `[Self::checkout]` that
+     * version to view the data at that point.  In addition, you can `[Self::restore]` the
+     * version to replace the current table with a previous version.
+     */
+    version(): Promise<number>;
+    /**
+     * Checks out a specific version of the Table
+     *
+     * Any read operation on the table will now access the data at the checked out version.
+     * As a consequence, calling this method will disable any read consistency interval
+     * that was previously set.
+     *
+     * This is a read-only operation that turns the table into a sort of "view"
+     * or "detached head".  Other table instances will not be affected.  To make the change
+     * permanent you can use the `[Self::restore]` method.
+     *
+     * Any operation that modifies the table will fail while the table is in a checked
+     * out state.
+     *
+     * To return the table to a normal state use `[Self::checkout_latest]`
+     */
+    checkout(version: number): Promise<void>;
+    /**
+     * Ensures the table is pointing at the latest version
+     *
+     * This can be used to manually update a table when the read_consistency_interval is None
+     * It can also be used to undo a `[Self::checkout]` operation
+     */
+    checkoutLatest(): Promise<void>;
+    /**
+     * Restore the table to the currently checked out version
+     *
+     * This operation will fail if checkout has not been called previously
+     *
+     * This operation will overwrite the latest version of the table with a
+     * previous version.  Any changes made since the checked out version will
+     * no longer be visible.
+     *
+     * Once the operation concludes the table will no longer be in a checked
+     * out state and the read_consistency_interval, if any, will apply.
+     */
+    restore(): Promise<void>;
+    /**
+     * List all indices that have been created with Self::create_index
+     */
+    listIndices(): Promise<IndexConfig[]>;
+}