@lancedb/lancedb 0.5.2 → 0.7.0

package/dist/index.js

@@ -13,14 +13,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.embedding = exports.Table = exports.Index = exports.RecordBatchIterator = exports.VectorQuery = exports.QueryBase = exports.Query = exports.Connection = exports.connect = exports.VectorColumnOptions = exports.MakeArrowTableOptions = exports.makeArrowTable = void 0;
+exports.connect = exports.embedding = exports.Table = exports.Index = exports.RecordBatchIterator = exports.VectorQuery = exports.QueryBase = exports.Query = exports.Connection = exports.VectorColumnOptions = exports.MakeArrowTableOptions = exports.makeArrowTable = void 0;
+const connection_1 = require("./connection");
+const native_js_1 = require("./native.js");
+const remote_1 = require("./remote");
 var arrow_1 = require("./arrow");
 Object.defineProperty(exports, "makeArrowTable", { enumerable: true, get: function () { return arrow_1.makeArrowTable; } });
 Object.defineProperty(exports, "MakeArrowTableOptions", { enumerable: true, get: function () { return arrow_1.MakeArrowTableOptions; } });
 Object.defineProperty(exports, "VectorColumnOptions", { enumerable: true, get: function () { return arrow_1.VectorColumnOptions; } });
-var connection_1 = require("./connection");
-Object.defineProperty(exports, "connect", { enumerable: true, get: function () { return connection_1.connect; } });
-Object.defineProperty(exports, "Connection", { enumerable: true, get: function () { return connection_1.Connection; } });
+var connection_2 = require("./connection");
+Object.defineProperty(exports, "Connection", { enumerable: true, get: function () { return connection_2.Connection; } });
 var query_1 = require("./query");
 Object.defineProperty(exports, "Query", { enumerable: true, get: function () { return query_1.Query; } });
 Object.defineProperty(exports, "QueryBase", { enumerable: true, get: function () { return query_1.QueryBase; } });
@@ -31,3 +33,25 @@ Object.defineProperty(exports, "Index", { enumerable: true, get: function () { r
 var table_1 = require("./table");
 Object.defineProperty(exports, "Table", { enumerable: true, get: function () { return table_1.Table; } });
 exports.embedding = require("./embedding");
+async function connect(uriOrOptions, opts = {}) {
+    let uri;
+    if (typeof uriOrOptions !== "string") {
+        const { uri: uri_, ...options } = uriOrOptions;
+        uri = uri_;
+        opts = options;
+    }
+    else {
+        uri = uriOrOptions;
+    }
+    if (!uri) {
+        throw new Error("uri is required");
+    }
+    if (uri?.startsWith("db://")) {
+        return new remote_1.RemoteConnection(uri, opts);
+    }
+    opts = opts ?? {};
+    opts.storageOptions = (0, connection_1.cleanseStorageOptions)(opts.storageOptions);
+    const nativeConn = await native_js_1.Connection.new(uri, opts);
+    return new connection_1.LocalConnection(nativeConn);
+}
+exports.connect = connect;

package/dist/merge.d.ts

@@ -0,0 +1,54 @@
+import { Data } from "./arrow";
+import { NativeMergeInsertBuilder } from "./native";
+/** A builder used to create and run a merge insert operation */
+export declare class MergeInsertBuilder {
+    #private;
+    /** Construct a MergeInsertBuilder. __Internal use only.__ */
+    constructor(native: NativeMergeInsertBuilder);
+    /**
+     * Rows that exist in both the source table (new data) and
+     * the target table (old data) will be updated, replacing
+     * the old row with the corresponding matching row.
+     *
+     * If there are multiple matches then the behavior is undefined.
+     * Currently this causes multiple copies of the row to be created
+     * but that behavior is subject to change.
+     *
+     * An optional condition may be specified.  If it is, then only
+     * matched rows that satisfy the condtion will be updated.  Any
+     * rows that do not satisfy the condition will be left as they
+     * are.  Failing to satisfy the condition does not cause a
+     * "matched row" to become a "not matched" row.
+     *
+     * The condition should be an SQL string.  Use the prefix
+     * target. to refer to rows in the target table (old data)
+     * and the prefix source. to refer to rows in the source
+     * table (new data).
+     *
+     * For example, "target.last_update < source.last_update"
+     */
+    whenMatchedUpdateAll(options?: {
+        where: string;
+    }): MergeInsertBuilder;
+    /**
+     * Rows that exist only in the source table (new data) should
+     * be inserted into the target table.
+     */
+    whenNotMatchedInsertAll(): MergeInsertBuilder;
+    /**
+     * Rows that exist only in the target table (old data) will be
+     * deleted.  An optional condition can be provided to limit what
+     * data is deleted.
+     *
+     * @param options.where - An optional condition to limit what data is deleted
+     */
+    whenNotMatchedBySourceDelete(options?: {
+        where: string;
+    }): MergeInsertBuilder;
+    /**
+     * Executes the merge insert operation
+     *
+     * Nothing is returned but the `Table` is updated
+     */
+    execute(data: Data): Promise<void>;
+}

package/dist/merge.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergeInsertBuilder = void 0;
+const arrow_1 = require("./arrow");
+/** A builder used to create and run a merge insert operation */
+class MergeInsertBuilder {
+    #native;
+    /** Construct a MergeInsertBuilder. __Internal use only.__ */
+    constructor(native) {
+        this.#native = native;
+    }
+    /**
+     * Rows that exist in both the source table (new data) and
+     * the target table (old data) will be updated, replacing
+     * the old row with the corresponding matching row.
+     *
+     * If there are multiple matches then the behavior is undefined.
+     * Currently this causes multiple copies of the row to be created
+     * but that behavior is subject to change.
+     *
+     * An optional condition may be specified.  If it is, then only
+     * matched rows that satisfy the condtion will be updated.  Any
+     * rows that do not satisfy the condition will be left as they
+     * are.  Failing to satisfy the condition does not cause a
+     * "matched row" to become a "not matched" row.
+     *
+     * The condition should be an SQL string.  Use the prefix
+     * target. to refer to rows in the target table (old data)
+     * and the prefix source. to refer to rows in the source
+     * table (new data).
+     *
+     * For example, "target.last_update < source.last_update"
+     */
+    whenMatchedUpdateAll(options) {
+        return new MergeInsertBuilder(this.#native.whenMatchedUpdateAll(options?.where));
+    }
+    /**
+     * Rows that exist only in the source table (new data) should
+     * be inserted into the target table.
+     */
+    whenNotMatchedInsertAll() {
+        return new MergeInsertBuilder(this.#native.whenNotMatchedInsertAll());
+    }
+    /**
+     * Rows that exist only in the target table (old data) will be
+     * deleted.  An optional condition can be provided to limit what
+     * data is deleted.
+     *
+     * @param options.where - An optional condition to limit what data is deleted
+     */
+    whenNotMatchedBySourceDelete(options) {
+        return new MergeInsertBuilder(this.#native.whenNotMatchedBySourceDelete(options?.where));
+    }
+    /**
+     * Executes the merge insert operation
+     *
+     * Nothing is returned but the `Table` is updated
+     */
+    async execute(data) {
+        const buffer = await (0, arrow_1.fromDataToBuffer)(data);
+        await this.#native.execute(buffer);
+    }
+}
+exports.MergeInsertBuilder = MergeInsertBuilder;

package/dist/native.d.ts

@@ -5,12 +5,14 @@
 
 /** A description of an index currently configured on a column */
 export interface IndexConfig {
+  /** The name of the index */
+  name: string
   /** The type of the index */
   indexType: string
   /**
    * The columns in the index
    *
-   * Currently this is always an array of size 1.  In the future there may
+   * Currently this is always an array of size 1. In the future there may
    * be more columns to represent composite indices.
    */
   columns: Array<string>
@@ -72,9 +74,21 @@ export interface AddColumnsSql {
    */
   valueSql: string
 }
+export interface IndexStatistics {
+  /** The number of rows indexed by the index */
+  numIndexedRows: number
+  /** The number of rows not indexed */
+  numUnindexedRows: number
+  /** The type of the index */
+  indexType?: string
+  /** The metadata for each index */
+  indices: Array<IndexMetadata>
+}
+export interface IndexMetadata {
+  metricType?: string
+  indexType?: string
+}
 export interface ConnectionOptions {
-  apiKey?: string
-  hostOverride?: string
   /**
    * (For LanceDB OSS only): The interval, in seconds, at which to check for
    * updates to the table from other processes. If None, then consistency is not
@@ -138,12 +152,20 @@ export class Index {
 export class RecordBatchIterator {
   next(): Promise<Buffer | null>
 }
+/** A builder used to create and run a merge insert operation */
+export class NativeMergeInsertBuilder {
+  whenMatchedUpdateAll(condition?: string | undefined | null): NativeMergeInsertBuilder
+  whenNotMatchedInsertAll(): NativeMergeInsertBuilder
+  whenNotMatchedBySourceDelete(filter?: string | undefined | null): NativeMergeInsertBuilder
+  execute(buf: Buffer): Promise<void>
+}
 export class Query {
   onlyIf(predicate: string): void
   select(columns: Array<[string, string]>): void
   limit(limit: number): void
   nearestTo(vector: Float32Array): VectorQuery
   execute(maxBatchLength?: number | undefined | null): Promise<RecordBatchIterator>
+  explainPlan(verbose: boolean): Promise<string>
 }
 export class VectorQuery {
   column(column: string): void
@@ -156,8 +178,10 @@ export class VectorQuery {
   select(columns: Array<[string, string]>): void
   limit(limit: number): void
   execute(maxBatchLength?: number | undefined | null): Promise<RecordBatchIterator>
+  explainPlan(verbose: boolean): Promise<string>
 }
 export class Table {
+  name: string
   display(): string
   isOpen(): boolean
   close(): void
@@ -179,4 +203,6 @@ export class Table {
   restore(): Promise<void>
   optimize(olderThanMs?: number | undefined | null): Promise<OptimizeStats>
   listIndices(): Promise<Array<IndexConfig>>
+  indexStats(indexName: string): Promise<IndexStatistics | null>
+  mergeInsert(on: Array<string>): NativeMergeInsertBuilder
 }

package/dist/native.js

@@ -233,17 +233,33 @@ switch (platform) {
                 }
                 break;
             case 'arm':
-                localFileExisted = existsSync(join(__dirname, 'lancedb.linux-arm-gnueabihf.node'));
-                try {
-                    if (localFileExisted) {
-                        nativeBinding = require('./lancedb.linux-arm-gnueabihf.node');
+                if (isMusl()) {
+                    localFileExisted = existsSync(join(__dirname, 'lancedb.linux-arm-musleabihf.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./lancedb.linux-arm-musleabihf.node');
+                        }
+                        else {
+                            nativeBinding = require('@lancedb/lancedb-linux-arm-musleabihf');
+                        }
                     }
-                    else {
-                        nativeBinding = require('@lancedb/lancedb-linux-arm-gnueabihf');
+                    catch (e) {
+                        loadError = e;
                     }
                 }
-                catch (e) {
-                    loadError = e;
+                else {
+                    localFileExisted = existsSync(join(__dirname, 'lancedb.linux-arm-gnueabihf.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./lancedb.linux-arm-gnueabihf.node');
+                        }
+                        else {
+                            nativeBinding = require('@lancedb/lancedb-linux-arm-gnueabihf');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
                 }
                 break;
             case 'riscv64':
@@ -303,10 +319,11 @@ if (!nativeBinding) {
     }
     throw new Error(`Failed to load native binding`);
 }
-const { Connection, Index, RecordBatchIterator, Query, VectorQuery, Table, WriteMode } = nativeBinding;
+const { Connection, Index, RecordBatchIterator, NativeMergeInsertBuilder, Query, VectorQuery, Table, WriteMode } = nativeBinding;
 module.exports.Connection = Connection;
 module.exports.Index = Index;
 module.exports.RecordBatchIterator = RecordBatchIterator;
+module.exports.NativeMergeInsertBuilder = NativeMergeInsertBuilder;
 module.exports.Query = Query;
 module.exports.VectorQuery = VectorQuery;
 module.exports.Table = Table;

package/dist/query.d.ts

@@ -1,4 +1,5 @@
 import { Table as ArrowTable, type IntoVector, RecordBatch } from "./arrow";
+import { type IvfPqOptions } from "./indices";
 import { RecordBatchIterator as NativeBatchIterator, Query as NativeQuery, Table as NativeTable, VectorQuery as NativeVectorQuery } from "./native";
 export declare class RecordBatchIterator implements AsyncIterator<RecordBatch> {
     private promisedInner?;
@@ -19,9 +20,10 @@ export interface QueryExecutionOptions {
     maxBatchLength?: number;
 }
 /** Common methods supported by all query types */
-export declare class QueryBase<NativeQueryType extends NativeQuery | NativeVectorQuery, QueryType> implements AsyncIterable<RecordBatch> {
-    protected inner: NativeQueryType;
-    protected constructor(inner: NativeQueryType);
+export declare class QueryBase<NativeQueryType extends NativeQuery | NativeVectorQuery> implements AsyncIterable<RecordBatch> {
+    protected inner: NativeQueryType | Promise<NativeQueryType>;
+    protected constructor(inner: NativeQueryType | Promise<NativeQueryType>);
+    protected doCall(fn: (inner: NativeQueryType) => void): void;
     /**
      * A filter statement to be applied to this query.
      *
@@ -34,7 +36,13 @@ export declare class QueryBase<NativeQueryType extends NativeQuery | NativeVecto
      * Filtering performance can often be improved by creating a scalar index
      * on the filter column(s).
      */
-    where(predicate: string): QueryType;
+    where(predicate: string): this;
+    /**
+     * A filter statement to be applied to this query.
+     * @alias where
+     * @deprecated Use `where` instead
+     */
+    filter(predicate: string): this;
     /**
      * Return only the specified columns.
      *
@@ -65,14 +73,14 @@ export declare class QueryBase<NativeQueryType extends NativeQuery | NativeVecto
      * uses `Object.entries` which should preserve the insertion order of the object.  However,
      * object insertion order is easy to get wrong and `Map` is more foolproof.
      */
-    select(columns: string[] | Map<string, string> | Record<string, string> | string): QueryType;
+    select(columns: string[] | Map<string, string> | Record<string, string> | string): this;
     /**
      * Set the maximum number of results to return.
      *
      * By default, a plain search has no limit.  If this method is not
      * called then every valid row from the table will be returned.
      */
-    limit(limit: number): QueryType;
+    limit(limit: number): this;
     protected nativeExecute(options?: Partial<QueryExecutionOptions>): Promise<NativeBatchIterator>;
     /**
      * Execute the query and return the results as an @see {@link AsyncIterator}
@@ -91,6 +99,21 @@ export declare class QueryBase<NativeQueryType extends NativeQuery | NativeVecto
     toArrow(options?: Partial<QueryExecutionOptions>): Promise<ArrowTable>;
     /** Collect the results as an array of objects. */
     toArray(options?: Partial<QueryExecutionOptions>): Promise<any[]>;
+    /**
+     * Generates an explanation of the query execution plan.
+     *
+     * @example
+     * import * as lancedb from "@lancedb/lancedb"
+     * const db = await lancedb.connect("./.lancedb");
+     * const table = await db.createTable("my_table", [
+     *   { vector: [1.1, 0.9], id: "1" },
+     * ]);
+     * const plan = await table.query().nearestTo([0.5, 0.2]).explainPlan();
+     *
+     * @param verbose - If true, provides a more detailed explanation. Defaults to false.
+     * @returns A Promise that resolves to a string containing the query execution plan explanation.
+     */
+    explainPlan(verbose?: boolean): Promise<string>;
 }
 /**
  * An interface for a query that can be executed
@@ -104,8 +127,8 @@ export interface ExecutableQuery {
  *
  * This builder can be reused to execute the query many times.
  */
-export declare class VectorQuery extends QueryBase<NativeVectorQuery, VectorQuery> {
-    constructor(inner: NativeVectorQuery);
+export declare class VectorQuery extends QueryBase<NativeVectorQuery> {
+    constructor(inner: NativeVectorQuery | Promise<NativeVectorQuery>);
     /**
      * Set the number of partitions to search (probe)
      *
@@ -153,7 +176,7 @@ export declare class VectorQuery extends QueryBase<NativeVectorQuery, VectorQuer
      *
      * By default "l2" is used.
      */
-    distanceType(distanceType: string): VectorQuery;
+    distanceType(distanceType: Required<IvfPqOptions>["distanceType"]): VectorQuery;
     /**
      * A multiplier to control how many additional rows are taken during the refine step
      *
@@ -217,7 +240,7 @@ export declare class VectorQuery extends QueryBase<NativeVectorQuery, VectorQuer
     bypassVectorIndex(): VectorQuery;
 }
 /** A builder for LanceDB queries. */
-export declare class Query extends QueryBase<NativeQuery, Query> {
+export declare class Query extends QueryBase<NativeQuery> {
     constructor(tbl: NativeTable);
     /**
      * Find the nearest vectors to the given query vector.

package/dist/query.js

@@ -62,6 +62,18 @@ class QueryBase {
         this.inner = inner;
         // intentionally empty
     }
+    // call a function on the inner (either a promise or the actual object)
+    doCall(fn) {
+        if (this.inner instanceof Promise) {
+            this.inner = this.inner.then((inner) => {
+                fn(inner);
+                return inner;
+            });
+        }
+        else {
+            fn(this.inner);
+        }
+    }
     /**
      * A filter statement to be applied to this query.
      *
@@ -75,9 +87,17 @@ class QueryBase {
      * on the filter column(s).
      */
     where(predicate) {
-        this.inner.onlyIf(predicate);
+        this.doCall((inner) => inner.onlyIf(predicate));
         return this;
     }
+    /**
+     * A filter statement to be applied to this query.
+     * @alias where
+     * @deprecated Use `where` instead
+     */
+    filter(predicate) {
+        return this.where(predicate);
+    }
     /**
      * Return only the specified columns.
      *
@@ -122,7 +142,9 @@ class QueryBase {
         else {
             columnTuples = Object.entries(columns);
         }
-        this.inner.select(columnTuples);
+        this.doCall((inner) => {
+            inner.select(columnTuples);
+        });
         return this;
     }
     /**
@@ -132,11 +154,16 @@ class QueryBase {
      * called then every valid row from the table will be returned.
      */
     limit(limit) {
-        this.inner.limit(limit);
+        this.doCall((inner) => inner.limit(limit));
         return this;
     }
     nativeExecute(options) {
-        return this.inner.execute(options?.maxBatchLength);
+        if (this.inner instanceof Promise) {
+            return this.inner.then((inner) => inner.execute(options?.maxBatchLength));
+        }
+        else {
+            return this.inner.execute(options?.maxBatchLength);
+        }
     }
     /**
      * Execute the query and return the results as an @see {@link AsyncIterator}
@@ -160,7 +187,14 @@ class QueryBase {
     /** Collect the results as an Arrow @see {@link ArrowTable}. */
     async toArrow(options) {
         const batches = [];
-        for await (const batch of new RecordBatchIterable(this.inner, options)) {
+        let inner;
+        if (this.inner instanceof Promise) {
+            inner = await this.inner;
+        }
+        else {
+            inner = this.inner;
+        }
+        for await (const batch of new RecordBatchIterable(inner, options)) {
             batches.push(batch);
         }
         return new arrow_1.Table(batches);
@@ -171,6 +205,28 @@ class QueryBase {
         const tbl = await this.toArrow(options);
         return tbl.toArray();
     }
+    /**
+     * Generates an explanation of the query execution plan.
+     *
+     * @example
+     * import * as lancedb from "@lancedb/lancedb"
+     * const db = await lancedb.connect("./.lancedb");
+     * const table = await db.createTable("my_table", [
+     *   { vector: [1.1, 0.9], id: "1" },
+     * ]);
+     * const plan = await table.query().nearestTo([0.5, 0.2]).explainPlan();
+     *
+     * @param verbose - If true, provides a more detailed explanation. Defaults to false.
+     * @returns A Promise that resolves to a string containing the query execution plan explanation.
+     */
+    async explainPlan(verbose = false) {
+        if (this.inner instanceof Promise) {
+            return this.inner.then((inner) => inner.explainPlan(verbose));
+        }
+        else {
+            return this.inner.explainPlan(verbose);
+        }
+    }
 }
 exports.QueryBase = QueryBase;
 /**
@@ -205,7 +261,7 @@ class VectorQuery extends QueryBase {
      * you the desired recall.
      */
     nprobes(nprobes) {
-        this.inner.nprobes(nprobes);
+        super.doCall((inner) => inner.nprobes(nprobes));
         return this;
     }
     /**
@@ -218,7 +274,7 @@ class VectorQuery extends QueryBase {
      * whose data type is a fixed-size-list of floats.
      */
     column(column) {
-        this.inner.column(column);
+        super.doCall((inner) => inner.column(column));
         return this;
     }
     /**
@@ -236,7 +292,7 @@ class VectorQuery extends QueryBase {
      * By default "l2" is used.
      */
     distanceType(distanceType) {
-        this.inner.distanceType(distanceType);
+        super.doCall((inner) => inner.distanceType(distanceType));
         return this;
     }
     /**
@@ -269,7 +325,7 @@ class VectorQuery extends QueryBase {
      * distance between the query vector and the actual uncompressed vector.
      */
     refineFactor(refineFactor) {
-        this.inner.refineFactor(refineFactor);
+        super.doCall((inner) => inner.refineFactor(refineFactor));
         return this;
     }
     /**
@@ -293,7 +349,7 @@ class VectorQuery extends QueryBase {
      * factor can often help restore some of the results lost by post filtering.
      */
     postfilter() {
-        this.inner.postfilter();
+        super.doCall((inner) => inner.postfilter());
         return this;
     }
     /**
@@ -306,7 +362,7 @@ class VectorQuery extends QueryBase {
      * calculate your recall to select an appropriate value for nprobes.
      */
     bypassVectorIndex() {
-        this.inner.bypassVectorIndex();
+        super.doCall((inner) => inner.bypassVectorIndex());
         return this;
     }
 }
@@ -354,8 +410,39 @@ class Query extends QueryBase {
      * a default `limit` of 10 will be used.  @see {@link Query#limit}
      */
     nearestTo(vector) {
-        const vectorQuery = this.inner.nearestTo(Float32Array.from(vector));
-        return new VectorQuery(vectorQuery);
+        if (this.inner instanceof Promise) {
+            const nativeQuery = this.inner.then(async (inner) => {
+                if (vector instanceof Promise) {
+                    const arr = await vector.then((v) => Float32Array.from(v));
+                    return inner.nearestTo(arr);
+                }
+                else {
+                    return inner.nearestTo(Float32Array.from(vector));
+                }
+            });
+            return new VectorQuery(nativeQuery);
+        }
+        if (vector instanceof Promise) {
+            const res = (async () => {
+                try {
+                    const v = await vector;
+                    const arr = Float32Array.from(v);
+                    //
+                    // biome-ignore lint/suspicious/noExplicitAny: we need to get the `inner`, but js has no package scoping
+                    const value = this.nearestTo(arr);
+                    const inner = value.inner;
+                    return inner;
+                }
+                catch (e) {
+                    return Promise.reject(e);
+                }
+            })();
+            return new VectorQuery(res);
+        }
+        else {
+            const vectorQuery = this.inner.nearestTo(Float32Array.from(vector));
+            return new VectorQuery(vectorQuery);
+        }
     }
 }
 exports.Query = Query;

package/dist/remote/client.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { type AxiosResponse } from "axios";
+import { Table as ArrowTable } from "../arrow";
+import { VectorQuery } from "../query";
+export declare class RestfulLanceDBClient {
+    #private;
+    constructor(dbName: string, apiKey: string, region: string, hostOverride?: string, connectionTimeout?: number, readTimeout?: number);
+    get session(): import("axios").AxiosInstance;
+    get url(): string;
+    get headers(): {
+        [key: string]: string;
+    };
+    isOpen(): boolean;
+    private checkNotClosed;
+    close(): void;
+    get(uri: string, params?: Record<string, any>): Promise<any>;
+    post(uri: string, body?: any): Promise<any>;
+    post(uri: string, body: any, additional: {
+        config?: {
+            responseType: "arraybuffer";
+        };
+        headers?: Record<string, string>;
+        params?: Record<string, string>;
+    }): Promise<Buffer>;
+    listTables(limit?: number, pageToken?: string): Promise<string[]>;
+    query(tableName: string, query: VectorQuery): Promise<ArrowTable>;
+    static checkStatus(response: AxiosResponse): void;
+}