@powersync/common 0.0.0-dev-20240903063630 → 0.0.0-dev-20240920093037

package/lib/client/sync/stream/AbstractStreamingSyncImplementation.d.ts

@@ -1,9 +1,9 @@
-import { ILogger } from 'js-logger';
-import { SyncStatus, SyncStatusOptions } from '../../../db/crud/SyncStatus';
-import { BaseListener, BaseObserver, Disposable } from '../../../utils/BaseObserver';
-import { BucketStorageAdapter } from '../bucket/BucketStorageAdapter';
-import { AbstractRemote } from './AbstractRemote';
-import { StreamingSyncRequestParameterType } from './streaming-sync-types';
+import Logger, { ILogger } from 'js-logger';
+import { SyncStatus, SyncStatusOptions } from '../../../db/crud/SyncStatus.js';
+import { BaseListener, BaseObserver, Disposable } from '../../../utils/BaseObserver.js';
+import { BucketStorageAdapter } from '../bucket/BucketStorageAdapter.js';
+import { AbstractRemote } from './AbstractRemote.js';
+import { StreamingSyncRequestParameterType } from './streaming-sync-types.js';
 export declare enum LockType {
     CRUD = "crud",
     SYNC = "sync"
@@ -82,7 +82,7 @@ export interface StreamingSyncImplementation extends BaseObserver<StreamingSyncI
 export declare const DEFAULT_CRUD_UPLOAD_THROTTLE_MS = 1000;
 export declare const DEFAULT_STREAMING_SYNC_OPTIONS: {
     retryDelayMs: number;
-    logger: ILogger;
+    logger: Logger.ILogger;
     crudUploadThrottleMs: number;
 };
 export declare const DEFAULT_STREAM_CONNECTION_OPTIONS: Required<PowerSyncConnectionOptions>;
@@ -99,7 +99,7 @@ export declare abstract class AbstractStreamingSyncImplementation extends BaseOb
     waitForStatus(status: SyncStatusOptions): Promise<void>;
     get lastSyncedAt(): Date | undefined;
     get isConnected(): boolean;
-    protected get logger(): ILogger;
+    protected get logger(): Logger.ILogger;
     dispose(): Promise<void>;
     abstract obtainLock<T>(lockOptions: LockOptions<T>): Promise<T>;
     hasCompletedSync(): Promise<boolean>;

package/lib/client/sync/stream/AbstractStreamingSyncImplementation.js

@@ -1,10 +1,10 @@
-import throttle from 'lodash/throttle';
 import Logger from 'js-logger';
-import { SyncStatus } from '../../../db/crud/SyncStatus';
-import { AbortOperation } from '../../../utils/AbortOperation';
-import { BaseObserver } from '../../../utils/BaseObserver';
-import { SyncDataBucket } from '../bucket/SyncDataBucket';
-import { isStreamingKeepalive, isStreamingSyncCheckpoint, isStreamingSyncCheckpointComplete, isStreamingSyncCheckpointDiff, isStreamingSyncData } from './streaming-sync-types';
+import { SyncStatus } from '../../../db/crud/SyncStatus.js';
+import { AbortOperation } from '../../../utils/AbortOperation.js';
+import { BaseObserver } from '../../../utils/BaseObserver.js';
+import { SyncDataBucket } from '../bucket/SyncDataBucket.js';
+import { isStreamingKeepalive, isStreamingSyncCheckpoint, isStreamingSyncCheckpointComplete, isStreamingSyncCheckpointDiff, isStreamingSyncData } from './streaming-sync-types.js';
+import { throttleLeadingTrailing } from '../../../utils/throttle.js';
 export var LockType;
 (function (LockType) {
     LockType["CRUD"] = "crud";
@@ -45,12 +45,12 @@ export class AbstractStreamingSyncImplementation extends BaseObserver {
             }
         });
         this.abortController = null;
-        this.triggerCrudUpload = throttle(() => {
+        this.triggerCrudUpload = throttleLeadingTrailing(() => {
             if (!this.syncStatus.connected || this.syncStatus.dataFlowStatus.uploading) {
                 return;
             }
             this._uploadAllCrud();
-        }, this.options.crudUploadThrottleMs, { trailing: true });
+        }, this.options.crudUploadThrottleMs);
     }
     async waitForReady() { }
     waitForStatus(status) {
@@ -96,7 +96,9 @@ export class AbstractStreamingSyncImplementation extends BaseObserver {
         return this.options.adapter.hasCompletedSync();
     }
     async getWriteCheckpoint() {
-        const response = await this.options.remote.get('/write-checkpoint2.json');
+        const clientId = await this.options.adapter.getClientId();
+        let path = `/write-checkpoint2.json?client_id=${clientId}`;
+        const response = await this.options.remote.get(path);
         return response['data']['write_checkpoint'];
     }
     async _uploadAllCrud() {
@@ -319,6 +321,7 @@ The next upload iteration will be delayed.`);
                 let validatedCheckpoint = null;
                 let appliedCheckpoint = null;
                 let bucketSet = new Set(initialBuckets.keys());
+                const clientId = await this.options.adapter.getClientId();
                 this.logger.debug('Requesting stream from server');
                 const syncOptions = {
                     path: '/sync/stream',
@@ -327,7 +330,8 @@ The next upload iteration will be delayed.`);
                         buckets: req,
                         include_checksum: true,
                         raw_data: true,
-                        parameters: resolvedOptions.params
+                        parameters: resolvedOptions.params,
+                        client_id: clientId
                     }
                 };
                 const stream = resolvedOptions?.connectionMethod == SyncStreamConnectionMethod.HTTP
@@ -503,4 +507,3 @@ The next upload iteration will be delayed.`);
         return new Promise((resolve) => setTimeout(resolve, this.options.retryDelayMs));
     }
 }
-//# sourceMappingURL=AbstractStreamingSyncImplementation.js.map

package/lib/client/sync/stream/streaming-sync-types.d.ts

@@ -1,6 +1,6 @@
-import { BucketChecksum, Checkpoint } from '../bucket/BucketStorageAdapter';
-import { CrudEntry, OpId } from '../bucket/CrudEntry';
-import { SyncDataBucketJSON } from '../bucket/SyncDataBucket';
+import { BucketChecksum, Checkpoint } from '../bucket/BucketStorageAdapter.js';
+import { CrudEntry, OpId } from '../bucket/CrudEntry.js';
+import { SyncDataBucketJSON } from '../bucket/SyncDataBucket.js';
 /**
  * For sync2.json
  */
@@ -69,6 +69,7 @@ export interface StreamingSyncRequest {
      * Client parameters to be passed to the sync rules.
      */
     parameters?: Record<string, StreamingSyncRequestParameterType>;
+    client_id?: string;
 }
 export interface StreamingSyncCheckpoint {
     checkpoint: Checkpoint;

package/lib/client/sync/stream/streaming-sync-types.js

@@ -20,4 +20,3 @@ export function isContinueCheckpointRequest(request) {
 export function isSyncNewCheckpointRequest(request) {
     return typeof request.request_checkpoint == 'object';
 }
-//# sourceMappingURL=streaming-sync-types.js.map

package/lib/db/DBAdapter.d.ts

@@ -2,7 +2,7 @@
  * Set of generic interfaces to allow PowerSync compatibility with
  * different SQLite DB implementations.
  */
-import { BaseListener, BaseObserverInterface } from '../utils/BaseObserver';
+import { BaseListener, BaseObserverInterface } from '../utils/BaseObserver.js';
 /**
  * TODO most of these types could be exported to a common `types` package
  * which is used by the DB adapter libraries as well.

package/lib/db/DBAdapter.js

@@ -17,4 +17,3 @@ export function isBatchedUpdateNotification(update) {
 export function extractTableUpdates(update) {
     return isBatchedUpdateNotification(update) ? update.tables : [update.table];
 }
-//# sourceMappingURL=DBAdapter.js.map

package/lib/db/crud/SyncStatus.js

@@ -55,4 +55,3 @@ export class SyncStatus {
         };
     }
 }
-//# sourceMappingURL=SyncStatus.js.map

package/lib/db/crud/UploadQueueStatus.js

@@ -22,4 +22,3 @@ export class UploadQueueStats {
         }
     }
 }
-//# sourceMappingURL=UploadQueueStatus.js.map

package/lib/db/schema/Column.d.ts

@@ -0,0 +1,30 @@
+export declare enum ColumnType {
+    TEXT = "TEXT",
+    INTEGER = "INTEGER",
+    REAL = "REAL"
+}
+export interface ColumnOptions {
+    name: string;
+    type?: ColumnType;
+}
+export type BaseColumnType<T extends number | string | null> = {
+    type: ColumnType;
+};
+export type ColumnsType = Record<string, BaseColumnType<any>>;
+export type ExtractColumnValueType<T extends BaseColumnType<any>> = T extends BaseColumnType<infer R> ? R : unknown;
+export declare const MAX_AMOUNT_OF_COLUMNS = 63;
+export declare const column: {
+    text: BaseColumnType<string | null>;
+    integer: BaseColumnType<number | null>;
+    real: BaseColumnType<number | null>;
+};
+export declare class Column {
+    protected options: ColumnOptions;
+    constructor(options: ColumnOptions);
+    get name(): string;
+    get type(): ColumnType | undefined;
+    toJSON(): {
+        name: string;
+        type: ColumnType | undefined;
+    };
+}

package/lib/db/{Column.js → schema/Column.js}

@@ -5,6 +5,23 @@ export var ColumnType;
     ColumnType["INTEGER"] = "INTEGER";
     ColumnType["REAL"] = "REAL";
 })(ColumnType || (ColumnType = {}));
+const text = {
+    type: ColumnType.TEXT
+};
+const integer = {
+    type: ColumnType.INTEGER
+};
+const real = {
+    type: ColumnType.REAL
+};
+// There is maximum of 127 arguments for any function in SQLite. Currently we use json_object which uses 1 arg per key (column name)
+// and one per value, which limits it to 63 arguments.
+export const MAX_AMOUNT_OF_COLUMNS = 63;
+export const column = {
+    text,
+    integer,
+    real
+};
 export class Column {
     options;
     constructor(options) {
@@ -23,4 +40,3 @@ export class Column {
         };
     }
 }
-//# sourceMappingURL=Column.js.map

package/lib/db/schema/Index.d.ts

@@ -1,5 +1,5 @@
-import { IndexedColumn } from './IndexedColumn';
-import { Table } from './Table';
+import { IndexedColumn } from './IndexedColumn.js';
+import { Table } from './Table.js';
 export interface IndexOptions {
     name: string;
     columns?: IndexedColumn[];
@@ -16,7 +16,7 @@ export declare class Index {
         columns: {
             name: string;
             ascending: boolean | undefined;
-            type: import("../Column").ColumnType;
+            type: import("./Column.js").ColumnType;
         }[];
     };
 }

package/lib/db/schema/Index.js

@@ -1,4 +1,4 @@
-import { IndexedColumn } from './IndexedColumn';
+import { IndexedColumn } from './IndexedColumn.js';
 export const DEFAULT_INDEX_OPTIONS = {
     columns: []
 };
@@ -27,4 +27,3 @@ export class Index {
         };
     }
 }
-//# sourceMappingURL=Index.js.map

package/lib/db/schema/IndexedColumn.d.ts

@@ -1,5 +1,5 @@
-import { ColumnType } from '../Column';
-import { Table } from './Table';
+import { ColumnType } from './Column.js';
+import { Table } from './Table.js';
 export interface IndexColumnOptions {
     name: string;
     ascending?: boolean;

package/lib/db/schema/IndexedColumn.js

@@ -1,4 +1,4 @@
-import { ColumnType } from '../Column';
+import { ColumnType } from './Column.js';
 export const DEFAULT_INDEX_COLUMN_OPTIONS = {
     ascending: true
 };
@@ -27,4 +27,3 @@ export class IndexedColumn {
         };
     }
 }
-//# sourceMappingURL=IndexedColumn.js.map

package/lib/db/schema/Schema.d.ts

@@ -1,6 +1,5 @@
-import { Table as ClassicTable } from './Table';
-import { RowType, TableV2 } from './TableV2';
-type SchemaType = Record<string, TableV2<any>>;
+import { RowType, Table } from './Table.js';
+type SchemaType = Record<string, Table<any>>;
 type SchemaTableType<S extends SchemaType> = {
     [K in keyof S]: RowType<S[K]>;
 };
@@ -10,8 +9,8 @@ type SchemaTableType<S extends SchemaType> = {
 export declare class Schema<S extends SchemaType = SchemaType> {
     readonly types: SchemaTableType<S>;
     readonly props: S;
-    readonly tables: ClassicTable[];
-    constructor(tables: ClassicTable[] | S);
+    readonly tables: Table[];
+    constructor(tables: Table[] | S);
     validate(): void;
     toJSON(): {
         tables: {
@@ -21,14 +20,14 @@ export declare class Schema<S extends SchemaType = SchemaType> {
             insert_only: boolean;
             columns: {
                 name: string;
-                type: import("../Column").ColumnType | undefined;
+                type: import("./Column.js").ColumnType | undefined;
             }[];
             indexes: {
                 name: string;
                 columns: {
                     name: string;
                     ascending: boolean | undefined;
-                    type: import("../Column").ColumnType;
+                    type: import("./Column.js").ColumnType;
                 }[];
             }[];
         }[];

package/lib/db/schema/Schema.js

@@ -1,4 +1,4 @@
-import { Table as ClassicTable } from './Table';
+import { Table } from './Table.js';
 /**
  * A schema is a collection of tables. It is used to define the structure of a database.
  */
@@ -25,13 +25,21 @@ export class Schema {
     }
     toJSON() {
         return {
+            // This is required because "name" field is not present in TableV2
             tables: this.tables.map((t) => t.toJSON())
         };
     }
     convertToClassicTables(props) {
         return Object.entries(props).map(([name, table]) => {
-            return ClassicTable.createTable(name, table);
+            const convertedTable = new Table({
+                name,
+                columns: table.columns,
+                indexes: table.indexes,
+                localOnly: table.localOnly,
+                insertOnly: table.insertOnly,
+                viewName: table.viewNameOverride || name
+            });
+            return convertedTable;
         });
     }
 }
-//# sourceMappingURL=Schema.js.map

package/lib/db/schema/Table.d.ts

@@ -1,6 +1,6 @@
-import { Column } from '../Column';
-import type { Index } from './Index';
-import { TableV2 } from './TableV2';
+import { Column, ColumnsType, ColumnType, ExtractColumnValueType } from './Column.js';
+import { Index } from './Index.js';
+import { TableV2 } from './TableV2.js';
 export interface TableOptions {
     /**
      * The synced table name, matching sync rules
@@ -12,18 +12,98 @@ export interface TableOptions {
     insertOnly?: boolean;
     viewName?: string;
 }
-export declare const DEFAULT_TABLE_OPTIONS: Partial<TableOptions>;
+export type RowType<T extends TableV2<any>> = {
+    [K in keyof T['columnMap']]: ExtractColumnValueType<T['columnMap'][K]>;
+} & {
+    id: string;
+};
+export type IndexShorthand = Record<string, string[]>;
+export interface TableV2Options {
+    indexes?: IndexShorthand;
+    localOnly?: boolean;
+    insertOnly?: boolean;
+    viewName?: string;
+}
+export declare const DEFAULT_TABLE_OPTIONS: {
+    indexes: never[];
+    insertOnly: boolean;
+    localOnly: boolean;
+};
 export declare const InvalidSQLCharacters: RegExp;
-export declare class Table {
+export declare class Table<Columns extends ColumnsType = ColumnsType> {
     protected options: TableOptions;
-    static createLocalOnly(options: TableOptions): Table;
-    static createInsertOnly(options: TableOptions): Table;
-    static createTable(name: string, table: TableV2): Table;
+    protected _mappedColumns: Columns;
+    static createLocalOnly(options: TableOptions): Table<ColumnsType>;
+    static createInsertOnly(options: TableOptions): Table<ColumnsType>;
+    /**
+     * Create a table.
+     * @deprecated This was only only included for TableV2 and is no longer necessary.
+     * Prefer to use new Table() directly.
+     *
+     * TODO remove in the next major release.
+     */
+    static createTable(name: string, table: Table): Table<ColumnsType>;
+    /**
+     * Creates a new Table instance.
+     *
+     * This constructor supports two different versions:
+     * 1. New constructor: Using a Columns object and an optional TableV2Options object
+     * 2. Deprecated constructor: Using a TableOptions object (will be removed in the next major release)
+     *
+     * @constructor
+     * @param {Columns | TableOptions} optionsOrColumns - Either a Columns object (for V2 syntax) or a TableOptions object (for V1 syntax)
+     * @param {TableV2Options} [v2Options] - Optional configuration options for V2 syntax
+     *
+     * @example
+     * ```javascript
+     * // New Constructor
+     * const table = new Table(
+     *   {
+     *     name: column.text,
+     *     age: column.integer
+     *   },
+     *   { indexes: { nameIndex: ['name'] } }
+     * );
+     *```
+     *
+     *
+     * @example
+     * ```javascript
+     * // Deprecated Constructor
+     * const table = new Table({
+     *   name: 'users',
+     *   columns: [
+     *     new Column({ name: 'name', type: ColumnType.TEXT }),
+     *     new Column({ name: 'age', type: ColumnType.INTEGER })
+     *   ]
+     * });
+     *```
+     */
+    constructor(columns: Columns, options?: TableV2Options);
+    /**
+     * @deprecated This constructor will be removed in the next major release.
+     * Use the new constructor shown below instead as this does not show types.
+     * @example
+     * <caption>Use this instead</caption>
+     * ```javascript
+     *   const table = new Table(
+     *     {
+     *      name: column.text,
+     *      age: column.integer
+     *     },
+     *     { indexes: { nameIndex: ['name'] } }
+     *   );
+     *```
+     */
     constructor(options: TableOptions);
+    private isTableV1;
+    private initTableV1;
+    private initTableV2;
     get name(): string;
     get viewNameOverride(): string | undefined;
     get viewName(): string;
     get columns(): Column[];
+    get columnMap(): Columns;
     get indexes(): Index[];
     get localOnly(): boolean;
     get insertOnly(): boolean;
@@ -37,14 +117,14 @@ export declare class Table {
         insert_only: boolean;
         columns: {
             name: string;
-            type: import("../Column").ColumnType | undefined;
+            type: ColumnType | undefined;
         }[];
         indexes: {
             name: string;
             columns: {
                 name: string;
                 ascending: boolean | undefined;
-                type: import("../Column").ColumnType;
+                type: ColumnType;
             }[];
         }[];
     };

package/lib/db/schema/Table.js

@@ -1,31 +1,75 @@
-import { Column } from '../Column';
+import { Column, ColumnType, MAX_AMOUNT_OF_COLUMNS } from './Column.js';
+import { Index } from './Index.js';
+import { IndexedColumn } from './IndexedColumn.js';
 export const DEFAULT_TABLE_OPTIONS = {
     indexes: [],
     insertOnly: false,
     localOnly: false
 };
-const MAX_AMOUNT_OF_COLUMNS = 63;
 export const InvalidSQLCharacters = /["'%,.#\s[\]]/;
 export class Table {
     options;
+    _mappedColumns;
     static createLocalOnly(options) {
         return new Table({ ...options, localOnly: true, insertOnly: false });
     }
     static createInsertOnly(options) {
         return new Table({ ...options, localOnly: false, insertOnly: true });
     }
+    /**
+     * Create a table.
+     * @deprecated This was only only included for TableV2 and is no longer necessary.
+     * Prefer to use new Table() directly.
+     *
+     * TODO remove in the next major release.
+     */
     static createTable(name, table) {
         return new Table({
             name,
-            columns: Object.entries(table.columns).map(([name, col]) => new Column({ name, type: col.type })),
+            columns: table.columns,
             indexes: table.indexes,
             localOnly: table.options.localOnly,
             insertOnly: table.options.insertOnly,
             viewName: table.options.viewName
         });
     }
-    constructor(options) {
-        this.options = { ...DEFAULT_TABLE_OPTIONS, ...options };
+    constructor(optionsOrColumns, v2Options) {
+        if (this.isTableV1(optionsOrColumns)) {
+            this.initTableV1(optionsOrColumns);
+        }
+        else {
+            this.initTableV2(optionsOrColumns, v2Options);
+        }
+    }
+    isTableV1(arg) {
+        return 'columns' in arg && Array.isArray(arg.columns);
+    }
+    initTableV1(options) {
+        this.options = {
+            ...options,
+            indexes: options.indexes || [],
+            insertOnly: options.insertOnly ?? DEFAULT_TABLE_OPTIONS.insertOnly,
+            localOnly: options.localOnly ?? DEFAULT_TABLE_OPTIONS.localOnly
+        };
+    }
+    initTableV2(columns, options) {
+        const convertedColumns = Object.entries(columns).map(([name, columnInfo]) => new Column({ name, type: columnInfo.type }));
+        const convertedIndexes = Object.entries(options?.indexes ?? {}).map(([name, columnNames]) => new Index({
+            name,
+            columns: columnNames.map((name) => new IndexedColumn({
+                name: name.replace(/^-/, ''),
+                ascending: !name.startsWith('-')
+            }))
+        }));
+        this.options = {
+            name: '',
+            columns: convertedColumns,
+            indexes: convertedIndexes,
+            insertOnly: options?.insertOnly ?? DEFAULT_TABLE_OPTIONS.insertOnly,
+            localOnly: options?.localOnly ?? DEFAULT_TABLE_OPTIONS.localOnly,
+            viewName: options?.viewName
+        };
+        this._mappedColumns = columns;
     }
     get name() {
         return this.options.name;
@@ -39,6 +83,13 @@ export class Table {
     get columns() {
         return this.options.columns;
     }
+    get columnMap() {
+        return (this._mappedColumns ??
+            this.columns.reduce((hash, column) => {
+                hash[column.name] = { type: column.type ?? ColumnType.TEXT };
+                return hash;
+            }, {}));
+    }
     get indexes() {
         return this.options.indexes ?? [];
     }
@@ -71,30 +122,30 @@ export class Table {
             throw new Error(`Invalid characters in view name: ${this.viewNameOverride}`);
         }
         if (this.columns.length > MAX_AMOUNT_OF_COLUMNS) {
-            throw new Error(`Table ${this.name} has too many columns. The maximum number of columns is ${MAX_AMOUNT_OF_COLUMNS}.`);
+            throw new Error(`Table has too many columns. The maximum number of columns is ${MAX_AMOUNT_OF_COLUMNS}.`);
         }
         const columnNames = new Set();
         columnNames.add('id');
         for (const column of this.columns) {
             const { name: columnName } = column;
             if (column.name === 'id') {
-                throw new Error(`${this.name}: id column is automatically added, custom id columns are not supported`);
+                throw new Error(`An id column is automatically added, custom id columns are not supported`);
             }
             if (columnNames.has(columnName)) {
                 throw new Error(`Duplicate column ${columnName}`);
             }
             if (InvalidSQLCharacters.test(columnName)) {
-                throw new Error(`Invalid characters in column name: $name.${column}`);
+                throw new Error(`Invalid characters in column name: ${column.name}`);
             }
             columnNames.add(columnName);
         }
         const indexNames = new Set();
         for (const index of this.indexes) {
             if (indexNames.has(index.name)) {
-                throw new Error(`Duplicate index $name.${index}`);
+                throw new Error(`Duplicate index ${index.name}`);
             }
             if (InvalidSQLCharacters.test(index.name)) {
-                throw new Error(`Invalid characters in index name: $name.${index}`);
+                throw new Error(`Invalid characters in index name: ${index.name}`);
             }
             for (const column of index.columns) {
                 if (!columnNames.has(column.name)) {
@@ -115,4 +166,3 @@ export class Table {
         };
     }
 }
-//# sourceMappingURL=Table.js.map

package/lib/db/schema/TableV2.d.ts

@@ -1,31 +1,9 @@
-import { ColumnType } from '../Column';
-import { Index } from './Index';
-export type BaseColumnType<T extends number | string | null> = {
-    type: ColumnType;
-};
-export declare const column: {
-    text: BaseColumnType<string | null>;
-    integer: BaseColumnType<number | null>;
-    real: BaseColumnType<number | null>;
-};
-export type ColumnsType = Record<string, BaseColumnType<any>>;
-export type ExtractColumnValueType<T extends BaseColumnType<any>> = T extends BaseColumnType<infer R> ? R : unknown;
-export type RowType<T extends TableV2<any>> = {
-    [K in keyof T['columns']]: ExtractColumnValueType<T['columns'][K]>;
-} & {
-    id: string;
-};
-export type IndexShorthand = Record<string, string[]>;
-export interface TableV2Options {
-    indexes?: IndexShorthand;
-    localOnly?: boolean;
-    insertOnly?: boolean;
-    viewName?: string;
-}
-export declare class TableV2<Columns extends ColumnsType = ColumnsType> {
-    columns: Columns;
-    options: TableV2Options;
-    indexes: Index[];
-    constructor(columns: Columns, options?: TableV2Options);
-    private validateTable;
+import { ColumnsType } from './Column.js';
+import { Table } from './Table.js';
+/**
+  Generate a new table from the columns and indexes
+  @deprecated You should use {@link Table} instead as it now allows TableV2 syntax.
+  This will be removed in the next major release.
+*/
+export declare class TableV2<Columns extends ColumnsType = ColumnsType> extends Table<Columns> {
 }