dexie 3.2.1-beta.2 → 4.0.0-alpha.2

package/README.md

@@ -1,7 +1,7 @@
 Dexie.js
 ========
 
-[![NPM Version][npm-image]][npm-url] [![Build Status](https://travis-ci.com/dfahlander/Dexie.js.svg?branch=master)](https://travis-ci.com/dfahlander/Dexie.js)[![Tested with Browserstack](https://dexie.org/assets/images/tested-with-browserstack2.png)](https://www.browserstack.com)
+[![NPM Version][npm-image]][npm-url] [![Build Status](https://travis-ci.com/dexie/Dexie.js.svg?branch=master)](https://travis-ci.com/dexie/Dexie.js)[![Tested with Browserstack](https://dexie.org/assets/images/tested-with-browserstack2.png)](https://www.browserstack.com)
 
 Dexie.js is a wrapper library for indexedDB - the standard database in the browser. https://dexie.org
 
@@ -191,7 +191,7 @@ Samples
 -------
 https://dexie.org/docs/Samples
 
-https://github.com/dfahlander/Dexie.js/tree/master/samples
+https://github.com/dexie/Dexie.js/tree/master/samples
 
 Knowledge Base
 -----

package/dist/dexie.d.ts

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 3.2.1-beta.2, Wed Jan 05 2022
+ * Version 4.0.0-alpha.2, Sun Apr 10 2022
  *
  * https://dexie.org
  *
@@ -51,7 +51,78 @@ export interface DexieEventSet {
 		]);
 	}): DexieEvent;
 }
-export type TransactionMode = "readonly" | "readwrite" | "r" | "r!" | "r?" | "rw" | "rw!" | "rw?";
+export interface TransactionEvents extends DexieEventSet {
+	(eventName: "complete", subscriber: () => any): void;
+	(eventName: "abort", subscriber: () => any): void;
+	(eventName: "error", subscriber: (error: any) => any): void;
+	complete: DexieEvent;
+	abort: DexieEvent;
+	error: DexieEvent;
+}
+export interface Transaction {
+	db: Dexie;
+	active: boolean;
+	mode: IDBTransactionMode;
+	//tables: { [type: string]: Table<any, any> }; Deprecated since 2.0. Obsolete from v3.0.
+	storeNames: Array<string>;
+	parent?: Transaction;
+	on: TransactionEvents;
+	abort(): void;
+	table(tableName: string): Table<any, any>;
+	table<T>(tableName: string): Table<T, any>;
+	table<T, Key>(tableName: string): Table<T, Key>;
+}
+export interface CreatingHookContext<T, Key> {
+	onsuccess?: (primKey: Key) => void;
+	onerror?: (err: any) => void;
+}
+export interface UpdatingHookContext<T, Key> {
+	onsuccess?: (updatedObj: T) => void;
+	onerror?: (err: any) => void;
+}
+export interface DeletingHookContext<T, Key> {
+	onsuccess?: () => void;
+	onerror?: (err: any) => void;
+}
+export interface TableHooks<T = any, TKey = IndexableType> extends DexieEventSet {
+	(eventName: "creating", subscriber: (this: CreatingHookContext<T, TKey>, primKey: TKey, obj: T, transaction: Transaction) => any): void;
+	(eventName: "reading", subscriber: (obj: T) => T | any): void;
+	(eventName: "updating", subscriber: (this: UpdatingHookContext<T, TKey>, modifications: Object, primKey: TKey, obj: T, transaction: Transaction) => any): void;
+	(eventName: "deleting", subscriber: (this: DeletingHookContext<T, TKey>, primKey: TKey, obj: T, transaction: Transaction) => any): void;
+	creating: DexieEvent;
+	reading: DexieEvent;
+	updating: DexieEvent;
+	deleting: DexieEvent;
+}
+export type ThenShortcut<T, TResult> = (value: T) => TResult | PromiseLike<TResult>;
+export interface WhereClause<T = any, TKey = IndexableType> {
+	above(key: any): Collection<T, TKey>;
+	aboveOrEqual(key: any): Collection<T, TKey>;
+	anyOf(keys: ReadonlyArray<IndexableType>): Collection<T, TKey>;
+	anyOf(...keys: Array<IndexableType>): Collection<T, TKey>;
+	anyOfIgnoreCase(keys: string[]): Collection<T, TKey>;
+	anyOfIgnoreCase(...keys: string[]): Collection<T, TKey>;
+	below(key: any): Collection<T, TKey>;
+	belowOrEqual(key: any): Collection<T, TKey>;
+	between(lower: any, upper: any, includeLower?: boolean, includeUpper?: boolean): Collection<T, TKey>;
+	equals(key: IndexableType): Collection<T, TKey>;
+	equalsIgnoreCase(key: string): Collection<T, TKey>;
+	inAnyRange(ranges: ReadonlyArray<{
+		0: any;
+		1: any;
+	}>, options?: {
+		includeLowers?: boolean;
+		includeUppers?: boolean;
+	}): Collection<T, TKey>;
+	startsWith(key: string): Collection<T, TKey>;
+	startsWithAnyOf(prefixes: string[]): Collection<T, TKey>;
+	startsWithAnyOf(...prefixes: string[]): Collection<T, TKey>;
+	startsWithIgnoreCase(key: string): Collection<T, TKey>;
+	startsWithAnyOfIgnoreCase(prefixes: string[]): Collection<T, TKey>;
+	startsWithAnyOfIgnoreCase(...prefixes: string[]): Collection<T, TKey>;
+	noneOf(keys: ReadonlyArray<IndexableType>): Collection<T, TKey>;
+	notEqual(key: IndexableType): Collection<T, TKey>;
+}
 export interface PromiseExtendedConstructor extends PromiseConstructor {
 	readonly prototype: PromiseExtended;
 	new <T>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): PromiseExtended<T>;
@@ -285,9 +356,17 @@ export interface PromiseExtended<T = any> extends Promise<T> {
 	finally<U>(onFinally?: () => U | PromiseLike<U>): PromiseExtended<T>;
 	timeout(ms: number, msg?: string): PromiseExtended<T>;
 }
-export type ThenShortcut<T, TResult> = (value: T) => TResult | PromiseLike<TResult>;
+export type KeyPaths<T> = {
+	[P in keyof T]: P extends string ? T[P] extends any[] ? P : T[P] extends (...args: any[]) => any // Method
+	 ? never : T[P] extends object ? P | `${P}.${KeyPaths<T[P]>}` : P : never;
+}[keyof T];
+export type Extract<T, P> = P extends keyof T ? T[P] : void;
+export type KeyPathValue<T, PATH> = PATH extends `${infer R}.${infer S}` ? R extends keyof T ? Extract<T[R], S> : void : Extract<T, PATH>;
+export type UpdateSpec<T> = {
+	[KP in KeyPaths<T>]?: KeyPathValue<T, KP>;
+};
 export interface Collection<T = any, TKey = IndexableType> {
-	//db: Database;
+	db: Dexie;
 	and(filter: (x: T) => boolean): Collection<T, TKey>;
 	clone(props?: Object): Collection<T, TKey>;
 	count(): PromiseExtended<number>;
@@ -335,91 +414,7 @@ export interface Collection<T = any, TKey = IndexableType> {
 	modify(changeCallback: (obj: T, ctx: {
 		value: T;
 	}) => void | boolean): PromiseExtended<number>;
-	modify(changes: {
-		[keyPath: string]: any;
-	}): PromiseExtended<number>;
-}
-export interface WhereClause<T = any, TKey = IndexableType> {
-	above(key: any): Collection<T, TKey>;
-	aboveOrEqual(key: any): Collection<T, TKey>;
-	anyOf(keys: ReadonlyArray<IndexableType>): Collection<T, TKey>;
-	anyOf(...keys: Array<IndexableType>): Collection<T, TKey>;
-	anyOfIgnoreCase(keys: string[]): Collection<T, TKey>;
-	anyOfIgnoreCase(...keys: string[]): Collection<T, TKey>;
-	below(key: any): Collection<T, TKey>;
-	belowOrEqual(key: any): Collection<T, TKey>;
-	between(lower: any, upper: any, includeLower?: boolean, includeUpper?: boolean): Collection<T, TKey>;
-	equals(key: IndexableType): Collection<T, TKey>;
-	equalsIgnoreCase(key: string): Collection<T, TKey>;
-	inAnyRange(ranges: ReadonlyArray<{
-		0: any;
-		1: any;
-	}>, options?: {
-		includeLowers?: boolean;
-		includeUppers?: boolean;
-	}): Collection<T, TKey>;
-	startsWith(key: string): Collection<T, TKey>;
-	startsWithAnyOf(prefixes: string[]): Collection<T, TKey>;
-	startsWithAnyOf(...prefixes: string[]): Collection<T, TKey>;
-	startsWithIgnoreCase(key: string): Collection<T, TKey>;
-	startsWithAnyOfIgnoreCase(prefixes: string[]): Collection<T, TKey>;
-	startsWithAnyOfIgnoreCase(...prefixes: string[]): Collection<T, TKey>;
-	noneOf(keys: ReadonlyArray<IndexableType>): Collection<T, TKey>;
-	notEqual(key: IndexableType): Collection<T, TKey>;
-}
-export interface Database {
-	readonly name: string;
-	readonly tables: Table[];
-	table<T = any, TKey = any>(tableName: string): Table<T, TKey>;
-	transaction<U>(mode: TransactionMode, table: Table, scope: () => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, scope: () => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, table3: Table, scope: () => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, table3: Table, table4: Table, scope: () => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, table3: Table, table4: Table, table5: Table, scope: () => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, tables: Table[], scope: () => PromiseLike<U> | U): PromiseExtended<U>;
-}
-export interface TransactionEvents extends DexieEventSet {
-	(eventName: "complete", subscriber: () => any): void;
-	(eventName: "abort", subscriber: () => any): void;
-	(eventName: "error", subscriber: (error: any) => any): void;
-	complete: DexieEvent;
-	abort: DexieEvent;
-	error: DexieEvent;
-}
-export interface Transaction {
-	db: Database;
-	active: boolean;
-	mode: IDBTransactionMode;
-	//tables: { [type: string]: Table<any, any> }; Deprecated since 2.0. Obsolete from v3.0.
-	storeNames: Array<string>;
-	parent?: Transaction;
-	on: TransactionEvents;
-	abort(): void;
-	table(tableName: string): Table<any, any>;
-	table<T>(tableName: string): Table<T, any>;
-	table<T, Key>(tableName: string): Table<T, Key>;
-}
-export interface CreatingHookContext<T, Key> {
-	onsuccess?: (primKey: Key) => void;
-	onerror?: (err: any) => void;
-}
-export interface UpdatingHookContext<T, Key> {
-	onsuccess?: (updatedObj: T) => void;
-	onerror?: (err: any) => void;
-}
-export interface DeletingHookContext<T, Key> {
-	onsuccess?: () => void;
-	onerror?: (err: any) => void;
-}
-export interface TableHooks<T = any, TKey = IndexableType> extends DexieEventSet {
-	(eventName: "creating", subscriber: (this: CreatingHookContext<T, TKey>, primKey: TKey, obj: T, transaction: Transaction) => any): void;
-	(eventName: "reading", subscriber: (obj: T) => T | any): void;
-	(eventName: "updating", subscriber: (this: UpdatingHookContext<T, TKey>, modifications: Object, primKey: TKey, obj: T, transaction: Transaction) => any): void;
-	(eventName: "deleting", subscriber: (this: DeletingHookContext<T, TKey>, primKey: TKey, obj: T, transaction: Transaction) => any): void;
-	creating: DexieEvent;
-	reading: DexieEvent;
-	updating: DexieEvent;
-	deleting: DexieEvent;
+	modify(changes: UpdateSpec<T>): PromiseExtended<number>;
 }
 export const enum DBCoreRangeType {
 	Equal = 1,
@@ -452,7 +447,7 @@ export interface DBCoreMutateResponse {
 export interface DBCoreAddRequest {
 	type: "add";
 	trans: DBCoreTransaction;
-	values: any[];
+	values: readonly any[];
 	keys?: any[];
 	/** @deprecated Will always get results since 3.1.0-alpha.5 */
 	wantResults?: boolean;
@@ -460,7 +455,7 @@ export interface DBCoreAddRequest {
 export interface DBCorePutRequest {
 	type: "put";
 	trans: DBCoreTransaction;
-	values: any[];
+	values: readonly any[];
 	keys?: any[];
 	criteria?: {
 		index: string | null;
@@ -586,66 +581,76 @@ export interface DBCoreTable {
 	openCursor(req: DBCoreOpenCursorRequest): Promise<DBCoreCursor | null>;
 	count(req: DBCoreCountRequest): Promise<number>;
 }
-export interface Table<T = any, TKey = IndexableType> {
-	db: Database;
+export type MethodProps<T> = {
+	[P in keyof T]: T[P] extends (...args: any[]) => any ? P : never;
+}[keyof T];
+export type InsertType<T, TOptionalProperties, TKeyPropNameOrKeyType> = string extends MethodProps<T> ? T : Omit<T, TOptionalProperties extends keyof T ? TKeyPropNameOrKeyType extends keyof T ? MethodProps<T> | TOptionalProperties | TKeyPropNameOrKeyType : MethodProps<T> | TOptionalProperties : MethodProps<T>> & (TOptionalProperties extends keyof T ? TKeyPropNameOrKeyType extends keyof T ? {
+	[P in (TOptionalProperties | TKeyPropNameOrKeyType)]?: T[P];
+} : {
+	[P in TOptionalProperties]?: T[P];
+} : {});
+export type IDType<T, TKey> = TKey extends keyof T ? T[TKey] : TKey;
+export interface Table<T = any, TKeyPropNameOrKeyType = IndexableType, TOpt = void> {
+	db: Dexie;
 	name: string;
 	schema: TableSchema;
-	hook: TableHooks<T, TKey>;
+	hook: TableHooks<T, IDType<T, TKeyPropNameOrKeyType>>;
 	core: DBCoreTable;
-	get(key: TKey): PromiseExtended<T | undefined>;
-	get<R>(key: TKey, thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
+	get(key: IDType<T, TKeyPropNameOrKeyType>): PromiseExtended<T | undefined>;
+	get<R>(key: IDType<T, TKeyPropNameOrKeyType>, thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
 	get(equalityCriterias: {
 		[key: string]: any;
 	}): PromiseExtended<T | undefined>;
 	get<R>(equalityCriterias: {
 		[key: string]: any;
 	}, thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
-	where(index: string | string[]): WhereClause<T, TKey>;
+	where(index: string | string[]): WhereClause<T, IDType<T, TKeyPropNameOrKeyType>>;
 	where(equalityCriterias: {
 		[key: string]: any;
-	}): Collection<T, TKey>;
-	filter(fn: (obj: T) => boolean): Collection<T, TKey>;
+	}): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
+	filter(fn: (obj: T) => boolean): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
 	count(): PromiseExtended<number>;
 	count<R>(thenShortcut: ThenShortcut<number, R>): PromiseExtended<R>;
-	offset(n: number): Collection<T, TKey>;
-	limit(n: number): Collection<T, TKey>;
+	offset(n: number): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
+	limit(n: number): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
 	each(callback: (obj: T, cursor: {
 		key: any;
-		primaryKey: TKey;
+		primaryKey: IDType<T, TKeyPropNameOrKeyType>;
 	}) => any): PromiseExtended<void>;
 	toArray(): PromiseExtended<Array<T>>;
 	toArray<R>(thenShortcut: ThenShortcut<T[], R>): PromiseExtended<R>;
-	toCollection(): Collection<T, TKey>;
-	orderBy(index: string | string[]): Collection<T, TKey>;
-	reverse(): Collection<T, TKey>;
+	toCollection(): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
+	orderBy(index: string | string[]): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
+	reverse(): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
 	mapToClass(constructor: Function): Function;
-	add(item: T, key?: TKey): PromiseExtended<TKey>;
-	update(key: TKey | T, changes: {
-		[keyPath: string]: any;
-	}): PromiseExtended<number>;
-	put(item: T, key?: TKey): PromiseExtended<TKey>;
-	delete(key: TKey): PromiseExtended<void>;
+	add(item: InsertType<T, TOpt, TKeyPropNameOrKeyType>, key?: IDType<T, TKeyPropNameOrKeyType>): PromiseExtended<IDType<T, TKeyPropNameOrKeyType>>;
+	update(key: IDType<T, TKeyPropNameOrKeyType> | T, changes: UpdateSpec<T> | ((obj: T, ctx: {
+		value: any;
+		primKey: IndexableType;
+	}) => void | boolean)): PromiseExtended<number>;
+	put(item: InsertType<T, TOpt, TKeyPropNameOrKeyType>, key?: IDType<T, TKeyPropNameOrKeyType>): PromiseExtended<IDType<T, TKeyPropNameOrKeyType>>;
+	delete(key: IDType<T, TKeyPropNameOrKeyType>): PromiseExtended<void>;
 	clear(): PromiseExtended<void>;
-	bulkGet(keys: TKey[]): PromiseExtended<(T | undefined)[]>;
-	bulkAdd<B extends boolean>(items: readonly T[], keys: IndexableTypeArrayReadonly, options: {
+	bulkGet(keys: IDType<T, TKeyPropNameOrKeyType>[]): PromiseExtended<(T | undefined)[]>;
+	bulkAdd<B extends boolean>(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], keys: IndexableTypeArrayReadonly, options: {
 		allKeys: B;
-	}): PromiseExtended<B extends true ? TKey[] : TKey>;
-	bulkAdd<B extends boolean>(items: readonly T[], options: {
+	}): PromiseExtended<B extends true ? IDType<T, TKeyPropNameOrKeyType>[] : IDType<T, TKeyPropNameOrKeyType>>;
+	bulkAdd<B extends boolean>(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], options: {
 		allKeys: B;
-	}): PromiseExtended<B extends true ? TKey[] : TKey>;
-	bulkAdd(items: readonly T[], keys?: IndexableTypeArrayReadonly, options?: {
+	}): PromiseExtended<B extends true ? IDType<T, TKeyPropNameOrKeyType>[] : IDType<T, TKeyPropNameOrKeyType>>;
+	bulkAdd(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], keys?: IndexableTypeArrayReadonly, options?: {
 		allKeys: boolean;
-	}): PromiseExtended<TKey>;
-	bulkPut<B extends boolean>(items: readonly T[], keys: IndexableTypeArrayReadonly, options: {
+	}): PromiseExtended<IDType<T, TKeyPropNameOrKeyType>>;
+	bulkPut<B extends boolean>(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], keys: IndexableTypeArrayReadonly, options: {
 		allKeys: B;
-	}): PromiseExtended<B extends true ? TKey[] : TKey>;
-	bulkPut<B extends boolean>(items: readonly T[], options: {
+	}): PromiseExtended<B extends true ? IDType<T, TKeyPropNameOrKeyType>[] : IDType<T, TKeyPropNameOrKeyType>>;
+	bulkPut<B extends boolean>(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], options: {
 		allKeys: B;
-	}): PromiseExtended<B extends true ? TKey[] : TKey>;
-	bulkPut(items: readonly T[], keys?: IndexableTypeArrayReadonly, options?: {
+	}): PromiseExtended<B extends true ? IDType<T, TKeyPropNameOrKeyType>[] : IDType<T, TKeyPropNameOrKeyType>>;
+	bulkPut(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], keys?: IndexableTypeArrayReadonly, options?: {
 		allKeys: boolean;
-	}): PromiseExtended<TKey>;
-	bulkDelete(keys: TKey[]): PromiseExtended<void>;
+	}): PromiseExtended<IDType<T, TKeyPropNameOrKeyType>>;
+	bulkDelete(keys: IDType<T, TKeyPropNameOrKeyType>[]): PromiseExtended<void>;
 }
 export interface Version {
 	stores(schema: {
@@ -696,9 +701,34 @@ export interface DbEvents extends DexieEventSet {
 	versionchange: DexieVersionChangeEvent;
 	close: DexieCloseEvent;
 }
+/** Set of mutated parts of the database
+ */
 export type ObservabilitySet = {
-	// `idb:${dbName}/${tableName}/changedRowContents` - keys.
-	// `idb:${dbName}/${tableName}/changedIndexes/${indexName}` - indexes
+	/** Database part having been mutated.
+	 *
+	 * This structure is produced in observability-middleware.ts
+	 * and consumed in live-query.ts.
+	 *
+	 * Format of 'part':
+	 *
+	 *   `idb://${dbName}/${tableName}/${indexName}`
+	 *
+	 * * dbName is the database name
+	 * * tableName is the table name
+	 * * indexName is any of:
+	 *    1. An empty string - represents the primary keys of the affected objs
+	 *    2. ":dels" - represents primary keys of deleted objects in the table
+	 *    3. The keyPath of an index, such as "name", "age" or "address.city" -
+	 *       represents indexes that, if used in a query, might affect the
+	 *       result of that query.
+	 *
+	 * IntervalTree
+	 *    * See definition of IntervalTree type in rangeset.d.ts
+	 *    * See rangesOverlap() in rangeset.ts that can be used to compare two
+	 *      IntervalTrees and detect collissions.
+	 *    * See RangeSet class that can be used to create an IntervalTree and add
+	 *      ranges to it.
+	 */
 	[part: string]: IntervalTree;
 };
 export interface DexieOnStorageMutatedEvent {
@@ -710,6 +740,7 @@ export interface GlobalDexieEvents extends DexieEventSet {
 	(eventName: "storagemutated", subscriber: (parts: ObservabilitySet) => any): void;
 	storagemutated: DexieOnStorageMutatedEvent;
 }
+export type TransactionMode = "readonly" | "readwrite" | "r" | "r!" | "r?" | "rw" | "rw!" | "rw?";
 export type DbSchema = {
 	[tableName: string]: TableSchema;
 };
@@ -724,33 +755,42 @@ export interface Middleware<TStack extends {
 export interface DexieStacks {
 	dbcore: DBCore;
 }
-export interface Dexie extends Database {
+export type TableProp<DX extends Dexie> = {
+	[K in keyof DX]: DX[K] extends {
+		schema: any;
+		get: any;
+		put: any;
+		add: any;
+		where: any;
+	} ? K : never;
+}[keyof DX] & string;
+export type TXWithTables<DX extends Dexie> = Dexie extends DX ? Transaction // If not subclassed, just expect a Transaction without table props
+ : Transaction & {
+	[P in TableProp<DX>]: DX[P];
+};
+export interface Dexie {
 	readonly name: string;
 	readonly tables: Table[];
 	readonly verno: number;
+	/** The 'vip' instance - passed to db.on('ready') and allows usage before db.on('ready') completes. */
 	readonly vip: Dexie;
 	readonly _allTables: {
 		[name: string]: Table<any, IndexableType>;
 	};
 	readonly core: DBCore;
 	_createTransaction: (this: Dexie, mode: IDBTransactionMode, storeNames: ArrayLike<string>, dbschema: DbSchema, parentTransaction?: Transaction | null) => Transaction;
+	readonly _novip: Dexie;
 	_dbSchema: DbSchema;
 	version(versionNumber: number): Version;
 	on: DbEvents;
 	open(): PromiseExtended<Dexie>;
 	table<T = any, TKey = IndexableType>(tableName: string): Table<T, TKey>;
-	transaction<U>(mode: TransactionMode, table: Table, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: string, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: string, table2: string, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, table3: Table, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: string, table2: string, table3: string, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, table3: Table, table4: Table, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: string, table2: string, table3: string, table4: string, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, table3: Table, table4: Table, table5: Table, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: string, table2: string, table3: string, table4: string, table5: string, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, tables: Table[], scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, tables: string[], scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
+	transaction<U>(mode: TransactionMode, tables: readonly (string | Table)[], scope: (trans: TXWithTables<this>) => PromiseLike<U> | U): PromiseExtended<U>;
+	transaction<U>(mode: TransactionMode, table: string | Table, scope: (trans: TXWithTables<this>) => PromiseLike<U> | U): PromiseExtended<U>;
+	transaction<U>(mode: TransactionMode, table: string | Table, table2: string | Table, scope: (trans: TXWithTables<this>) => PromiseLike<U> | U): PromiseExtended<U>;
+	transaction<U>(mode: TransactionMode, table: string | Table, table2: string | Table, table3: string | Table, scope: (trans: TXWithTables<this>) => PromiseLike<U> | U): PromiseExtended<U>;
+	transaction<U>(mode: TransactionMode, table: string | Table, table2: string | Table, table3: string | Table, table4: string | Table, scope: (trans: TXWithTables<this>) => PromiseLike<U> | U): PromiseExtended<U>;
+	transaction<U>(mode: TransactionMode, table: string | Table, table2: string | Table, table3: string | Table, table5: string | Table, scope: (trans: TXWithTables<this>) => PromiseLike<U> | U): PromiseExtended<U>;
 	close(): void;
 	delete(): PromiseExtended<void>;
 	isOpen(): boolean;
@@ -976,9 +1016,9 @@ export interface DexieConstructor extends DexieExceptionClasses {
 	liveQuery<T>(fn: () => T | Promise<T>): Observable<T>;
 	extendObservabilitySet(target: ObservabilitySet, newSet: ObservabilitySet): ObservabilitySet;
 	override<F>(origFunc: F, overridedFactory: (fn: any) => any): F; // ?
-	getByKeyPath(obj: Object, keyPath: string): any;
-	setByKeyPath(obj: Object, keyPath: string, value: any): void;
-	delByKeyPath(obj: Object, keyPath: string): void;
+	getByKeyPath(obj: Object, keyPath: string | string[]): any;
+	setByKeyPath(obj: Object, keyPath: string | string[], value: any): void;
+	delByKeyPath(obj: Object, keyPath: string | string[]): void;
 	shallowClone<T>(obj: T): T;
 	deepClone<T>(obj: T): T;
 	asap(fn: Function): void; //?
@@ -995,6 +1035,11 @@ export interface DexieConstructor extends DexieExceptionClasses {
 	on: GlobalDexieEvents;
 	errnames: DexieErrors;
 }
+export class Entity<TDexieSubClass extends Dexie = Dexie> {
+	protected constructor();
+	protected readonly db: TDexieSubClass;
+	table(): TableProp<TDexieSubClass>;
+}
 export declare var Dexie: DexieConstructor;
 export interface _Table<T, TKey> extends Table<T, TKey> {
 }
@@ -1013,6 +1058,7 @@ export declare module Dexie {
 export function liveQuery<T>(querier: () => T | Promise<T>): Observable<T>;
 export function mergeRanges(target: IntervalTree, newSet: IntervalTree): void;
 export function rangesOverlap(rangeSet1: IntervalTree, rangeSet2: IntervalTree): boolean;
+export function cmp(a: any, b: any): number;
 /** Exporting 'Dexie' as the default export.
  **/
 export default Dexie;