@posx/core 5.5.398 → 5.5.399

package/build/index.d.ts

@@ -444,20 +444,20 @@ declare class Till extends AppCoreModel implements ITill {
   constructor();
 }
 //#endregion
-//#region node_modules/.pnpm/dexie@3.2.4/node_modules/dexie/dist/dexie.d.ts
+//#region node_modules/.pnpm/dexie@4.3.0/node_modules/dexie/dist/dexie.d.ts
 /*
  * Dexie.js - a minimalistic wrapper for IndexedDB
  * ===============================================
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 3.2.4, Tue May 30 2023
+ * Version 4.3.0, Sat Dec 20 2025
  *
  * https://dexie.org
  *
  * Apache License Version 2.0, January 2004, http://www.apache.org/licenses/
  */
-// Generated by dts-bundle-generator v5.9.0
+// Generated by dts-bundle-generator v9.5.1
 
 interface IndexSpec {
   name: string;
@@ -467,11 +467,16 @@ interface IndexSpec {
   auto: boolean | undefined;
   compound: boolean | undefined;
   src: string;
+  type?: string | undefined;
 }
 interface TableSchema {
   name: string;
   primKey: IndexSpec;
   indexes: IndexSpec[];
+  yProps?: {
+    prop: string;
+    updatesTable: string;
+  }[]; // Available if y-dexie addon is used and schema defines Y.Doc properties.
   mappedClass: Function;
   idxByName: {
     [name: string]: IndexSpec;
@@ -495,7 +500,81 @@ interface DexieEventSet {
     [eventName: string]: ("asap" | [(f1: Function, f2: Function) => Function, Function]);
   }): DexieEvent;
 }
-type TransactionMode = "readonly" | "readwrite" | "r" | "r!" | "r?" | "rw" | "rw!" | "rw?";
+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;
+}
+interface Transaction {
+  db: Dexie;
+  active: boolean;
+  mode: IDBTransactionMode;
+  idbtrans: IDBTransaction;
+  //tables: { [type: string]: Table<any, any> }; Deprecated since 2.0. Obsolete from v3.0.
+  storeNames: Array<string>;
+  explicit?: boolean;
+  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>;
+  table<T, Key, TInsertType>(tableName: string): Table<T, Key, TInsertType>;
+}
+interface CreatingHookContext<T, Key> {
+  onsuccess?: (primKey: Key) => void;
+  onerror?: (err: any) => void;
+}
+interface UpdatingHookContext<T, Key> {
+  onsuccess?: (updatedObj: T) => void;
+  onerror?: (err: any) => void;
+}
+interface DeletingHookContext<T, Key> {
+  onsuccess?: () => void;
+  onerror?: (err: any) => void;
+}
+interface TableHooks<T = any, TKey = IndexableType, TInsertType = T> extends DexieEventSet {
+  (eventName: "creating", subscriber: (this: CreatingHookContext<T, TKey>, primKey: TKey, obj: T, transaction: Transaction) => void | undefined | TKey): 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;
+}
+type ThenShortcut<T, TResult> = (value: T) => TResult | PromiseLike<TResult>;
+interface WhereClause<T = any, TKey = IndexableType, TInsertType = T> {
+  above(key: any): Collection<T, TKey, TInsertType>;
+  aboveOrEqual(key: any): Collection<T, TKey, TInsertType>;
+  anyOf(keys: ReadonlyArray<IndexableType>): Collection<T, TKey, TInsertType>;
+  anyOf(...keys: Array<IndexableType>): Collection<T, TKey, TInsertType>;
+  anyOfIgnoreCase(keys: string[]): Collection<T, TKey, TInsertType>;
+  anyOfIgnoreCase(...keys: string[]): Collection<T, TKey, TInsertType>;
+  below(key: any): Collection<T, TKey, TInsertType>;
+  belowOrEqual(key: any): Collection<T, TKey, TInsertType>;
+  between(lower: any, upper: any, includeLower?: boolean, includeUpper?: boolean): Collection<T, TKey, TInsertType>;
+  equals(key: IndexableType): Collection<T, TKey, TInsertType>;
+  equalsIgnoreCase(key: string): Collection<T, TKey, TInsertType>;
+  inAnyRange(ranges: ReadonlyArray<{
+    0: any;
+    1: any;
+  }>, options?: {
+    includeLowers?: boolean;
+    includeUppers?: boolean;
+  }): Collection<T, TKey, TInsertType>;
+  startsWith(key: string): Collection<T, TKey, TInsertType>;
+  startsWithAnyOf(prefixes: string[]): Collection<T, TKey, TInsertType>;
+  startsWithAnyOf(...prefixes: string[]): Collection<T, TKey, TInsertType>;
+  startsWithIgnoreCase(key: string): Collection<T, TKey, TInsertType>;
+  startsWithAnyOfIgnoreCase(prefixes: string[]): Collection<T, TKey, TInsertType>;
+  startsWithAnyOfIgnoreCase(...prefixes: string[]): Collection<T, TKey, TInsertType>;
+  noneOf(keys: ReadonlyArray<IndexableType>): Collection<T, TKey, TInsertType>;
+  notEqual(key: IndexableType): Collection<T, TKey, TInsertType>;
+}
 interface PromiseExtendedConstructor extends PromiseConstructor {
   readonly prototype: PromiseExtended;
   new <T>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): PromiseExtended<T>;
@@ -540,14 +619,34 @@ interface PromiseExtended<T = any> extends Promise<T> {
   finally<U>(onFinally?: () => U | PromiseLike<U>): PromiseExtended<T>;
   timeout(ms: number, msg?: string): PromiseExtended<T>;
 }
-type ThenShortcut<T, TResult> = (value: T) => TResult | PromiseLike<TResult>;
-interface Collection<T = any, TKey = IndexableType> {
-  //db: Database;
-  and(filter: (x: T) => boolean): Collection<T, TKey>;
-  clone(props?: Object): Collection<T, TKey>;
+type KeyPathIgnoreObject = ArrayBuffer | ArrayBufferView | RegExp | Blob | FileList | FileSystemFileHandle | FileSystemDirectoryHandle | DataView | ImageBitmap | ImageData | Map<any, any> | Set<any> | CryptoKey | Promise<any> | ReadableStream<any> | ReadableStreamDefaultReader<any> | ReadableStreamDefaultController<any> | {
+  whenLoaded: Promise<any>;
+};
+// Y.Doc
+type KeyPaths<T, MAXDEPTH = "II", CURRDEPTH extends string = ""> = { [P in keyof T]: P extends string ? CURRDEPTH extends MAXDEPTH ? P : T[P] extends Array<infer K> ? K extends any[] // Array of arrays (issue #2026)
+? P | `${P}.${number}` | `${P}.${number}.${number}` : K extends object // only drill into the array element if it's an object
+? P | `${P}.${number}` | `${P}.${number}.${KeyPaths<Required<K>>}` : P | `${P}.${number}` : T[P] extends ((...args: any[]) => any // Method
+) ? never : T[P] extends KeyPathIgnoreObject // Not valid in update spec or where clause (+ avoid circular reference)
+? P : T[P] extends object ? P | `${P}.${KeyPaths<Required<T[P]>, MAXDEPTH, `${CURRDEPTH}I`>}` : P : never }[keyof T];
+type KeyPathValue<T, PATH> = PATH extends `${infer R}.${infer S}` ? R extends keyof T ? KeyPathValue<Required<T[R]>, S> : T extends any[] ? PATH extends `${number}.${infer S}` ? KeyPathValue<Required<T[number]>, S> : void : void : PATH extends `${number}` ? T extends any[] ? T[number] : void : PATH extends keyof T ? T[PATH] : any;
+type PropModSpec = {
+  replacePrefix?: [string, string];
+  add?: number | bigint | Array<string | number>;
+  remove?: number | bigint | Array<string | number>;
+};
+declare class PropModification {
+  ["@@propmod"]: PropModSpec;
+  constructor(spec: PropModSpec);
+  execute<T>(value: T): T;
+}
+type UpdateSpec<T> = { [KP in KeyPaths<Required<T>>]?: KeyPathValue<Required<T>, KP> | PropModification };
+interface Collection<T = any, TKey = IndexableType, TInsertType = T> {
+  db: Dexie;
+  and(filter: (x: T) => boolean): Collection<T, TKey, TInsertType>;
+  clone(props?: Object): Collection<T, TKey, TInsertType>;
   count(): PromiseExtended<number>;
-  count<R>(thenShortcut: ThenShortcut<number, R>): PromiseExtended<R>;
-  distinct(): Collection<T, TKey>;
+  count<R$1>(thenShortcut: ThenShortcut<number, R$1>): PromiseExtended<R$1>;
+  distinct(): Collection<T, TKey, TInsertType>;
   each(callback: (obj: T, cursor: {
     key: IndexableType;
     primaryKey: TKey;
@@ -564,117 +663,120 @@ interface Collection<T = any, TKey = IndexableType> {
     key: IndexableType;
     primaryKey: TKey;
   }) => any): PromiseExtended<void>;
-  filter(filter: (x: T) => boolean): Collection<T, TKey>;
+  filter<S$1 extends T>(filter: (x: T) => x is S$1): Collection<S$1, TKey>;
+  filter(filter: (x: T) => boolean): Collection<T, TKey, TInsertType>;
   first(): PromiseExtended<T | undefined>;
-  first<R>(thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
+  first<R$1>(thenShortcut: ThenShortcut<T | undefined, R$1>): PromiseExtended<R$1>;
+  firstKey(): PromiseExtended<IndexableType | undefined>;
   keys(): PromiseExtended<IndexableTypeArray>;
-  keys<R>(thenShortcut: ThenShortcut<IndexableTypeArray, R>): PromiseExtended<R>;
+  keys<R$1>(thenShortcut: ThenShortcut<IndexableTypeArray, R$1>): PromiseExtended<R$1>;
   primaryKeys(): PromiseExtended<TKey[]>;
-  primaryKeys<R>(thenShortcut: ThenShortcut<TKey[], R>): PromiseExtended<R>;
+  primaryKeys<R$1>(thenShortcut: ThenShortcut<TKey[], R$1>): PromiseExtended<R$1>;
   last(): PromiseExtended<T | undefined>;
-  last<R>(thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
-  limit(n: number): Collection<T, TKey>;
-  offset(n: number): Collection<T, TKey>;
-  or(indexOrPrimayKey: string): WhereClause<T, TKey>;
-  raw(): Collection<T, TKey>;
-  reverse(): Collection<T, TKey>;
+  last<R$1>(thenShortcut: ThenShortcut<T | undefined, R$1>): PromiseExtended<R$1>;
+  lastKey(): PromiseExtended<IndexableType | undefined>;
+  limit(n: number): Collection<T, TKey, TInsertType>;
+  offset(n: number): Collection<T, TKey, TInsertType>;
+  or(indexOrPrimayKey: string): WhereClause<T, TKey, TInsertType>;
+  raw(): Collection<T, TKey, TInsertType>;
+  reverse(): Collection<T, TKey, TInsertType>;
   sortBy(keyPath: string): PromiseExtended<T[]>;
-  sortBy<R>(keyPath: string, thenShortcut: ThenShortcut<T[], R>): PromiseExtended<R>;
+  sortBy<R$1>(keyPath: string, thenShortcut: ThenShortcut<T[], R$1>): PromiseExtended<R$1>;
   toArray(): PromiseExtended<Array<T>>;
-  toArray<R>(thenShortcut: ThenShortcut<T[], R>): PromiseExtended<R>;
+  toArray<R$1>(thenShortcut: ThenShortcut<T[], R$1>): PromiseExtended<R$1>;
   uniqueKeys(): PromiseExtended<IndexableTypeArray>;
-  uniqueKeys<R>(thenShortcut: ThenShortcut<IndexableTypeArray, R>): PromiseExtended<R>;
-  until(filter: (value: T) => boolean, includeStopEntry?: boolean): Collection<T, TKey>;
+  uniqueKeys<R$1>(thenShortcut: ThenShortcut<IndexableTypeArray, R$1>): PromiseExtended<R$1>;
+  until(filter: (value: T) => boolean, includeStopEntry?: boolean): Collection<T, TKey, TInsertType>;
   // Mutating methods
   delete(): PromiseExtended<number>;
   modify(changeCallback: (obj: T, ctx: {
-    value: T;
+    value: TInsertType;
   }) => void | boolean): PromiseExtended<number>;
-  modify(changes: {
-    [keyPath: string]: any;
-  }): PromiseExtended<number>;
-}
-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>;
-}
-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>;
+  modify(changes: UpdateSpec<TInsertType>): PromiseExtended<number>;
 }
-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;
+type IntervalTree = IntervalTreeNode | EmptyRange;
+interface IntervalTreeNode {
+  from: IndexableType; // lower bound
+  to: IndexableType; // upper bound
+  l?: IntervalTreeNode | null; // left
+  r?: IntervalTreeNode | null; // right
+  d: number; // depth
 }
-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>;
+interface EmptyRange {
+  d: 0;
 }
-interface CreatingHookContext<T, Key> {
-  onsuccess?: (primKey: Key) => void;
-  onerror?: (err: any) => void;
+interface DexieOnReadyEvent {
+  subscribe(fn: (vipDb: Dexie) => any, bSticky: boolean): void;
+  unsubscribe(fn: (vipDb: Dexie) => any): void;
+  fire(vipDb: Dexie): any;
 }
-interface UpdatingHookContext<T, Key> {
-  onsuccess?: (updatedObj: T) => void;
-  onerror?: (err: any) => void;
+interface DexieVersionChangeEvent {
+  subscribe(fn: (event: IDBVersionChangeEvent) => any): void;
+  unsubscribe(fn: (event: IDBVersionChangeEvent) => any): void;
+  fire(event: IDBVersionChangeEvent): any;
 }
-interface DeletingHookContext<T, Key> {
-  onsuccess?: () => void;
-  onerror?: (err: any) => void;
+interface DexiePopulateEvent {
+  subscribe(fn: (trans: Transaction) => any): void;
+  unsubscribe(fn: (trans: Transaction) => any): void;
+  fire(trans: Transaction): any;
 }
-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;
+interface DexieCloseEvent {
+  subscribe(fn: (event: Event) => any): void;
+  unsubscribe(fn: (event: Event) => any): void;
+  fire(event: Event): any;
+}
+interface DbEventFns {
+  (eventName: "populate", subscriber: (trans: Transaction) => any): void;
+  (eventName: "blocked", subscriber: (event: IDBVersionChangeEvent) => any): void;
+  (eventName: "versionchange", subscriber: (event: IDBVersionChangeEvent) => any): void;
+  (eventName: "close", subscriber: (event: Event) => any): void;
+}
+interface DbEvents extends DbEventFns, DexieEventSet {
+  (eventName: "ready", subscriber: (vipDb: Dexie) => any, bSticky?: boolean): void;
+  ready: DexieOnReadyEvent;
+  populate: DexiePopulateEvent;
+  blocked: DexieEvent;
+  versionchange: DexieVersionChangeEvent;
+  close: DexieCloseEvent;
+}
+/** Set of mutated parts of the database
+ */
+type ObservabilitySet = {
+  /** 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;
+};
+interface DexieOnStorageMutatedEvent {
+  subscribe(fn: (parts: ObservabilitySet) => any): void;
+  unsubscribe(fn: (parts: ObservabilitySet) => any): void;
+  fire(parts: ObservabilitySet): any;
+}
+interface GlobalDexieEvents extends DexieEventSet {
+  (eventName: "storagemutated", subscriber: (parts: ObservabilitySet) => any): void;
+  storagemutated: DexieOnStorageMutatedEvent;
 }
 declare const enum DBCoreRangeType {
   Equal = 1,
@@ -702,21 +804,24 @@ interface DBCoreMutateResponse {
     [operationNumber: number]: Error;
   };
   lastResult: any;
-  results?: any[]; // Present on AddRequest and PutRequest.
+  results?: any[]; // Always present on responses to AddRequest and PutRequest.
 }
 interface DBCoreAddRequest {
   type: "add";
   trans: DBCoreTransaction;
-  values: any[];
+  values: readonly any[];
   keys?: any[];
+  mutatedParts?: ObservabilitySet;
   /** @deprecated Will always get results since 3.1.0-alpha.5 */
   wantResults?: boolean;
 }
 interface DBCorePutRequest {
   type: "put";
   trans: DBCoreTransaction;
-  values: any[];
+  values: readonly any[];
   keys?: any[];
+  mutatedParts?: ObservabilitySet;
+  upsert?: boolean; // If true, will insert the object if it does not exist. If false, will only update existing objects using the 'updates' property.
   criteria?: {
     index: string | null;
     range: DBCoreKeyRange;
@@ -724,9 +829,13 @@ interface DBCorePutRequest {
   changeSpec?: {
     [keyPath: string]: any;
   }; // Common changeSpec for each key
-  changeSpecs?: {
-    [keyPath: string]: any;
-  }[]; // changeSpec per key. 
+  isAdditionalChunk?: boolean;
+  updates?: {
+    keys: any[];
+    changeSpecs: {
+      [keyPath: string]: any;
+    }[]; // changeSpec per key.  
+  };
   /** @deprecated Will always get results since 3.1.0-alpha.5 */
   wantResults?: boolean;
 }
@@ -734,24 +843,29 @@ interface DBCoreDeleteRequest {
   type: "delete";
   trans: DBCoreTransaction;
   keys: any[];
+  mutatedParts?: ObservabilitySet;
   criteria?: {
     index: string | null;
     range: DBCoreKeyRange;
   };
+  isAdditionalChunk?: boolean;
 }
 interface DBCoreDeleteRangeRequest {
   type: "deleteRange";
   trans: DBCoreTransaction;
   range: DBCoreKeyRange;
+  mutatedParts?: ObservabilitySet;
 }
 interface DBCoreGetManyRequest {
   trans: DBCoreTransaction;
   keys: any[];
   cache?: "immutable" | "clone";
+  obsSet?: ObservabilitySet;
 }
 interface DBCoreGetRequest {
   trans: DBCoreTransaction;
   key: any;
+  obsSet?: ObservabilitySet;
 }
 interface DBCoreQuery {
   index: DBCoreIndex; //keyPath: null | string | string[]; // null represents primary key. string a property, string[] several properties.
@@ -762,6 +876,7 @@ interface DBCoreQueryRequest {
   values?: boolean;
   limit?: number;
   query: DBCoreQuery;
+  obsSet?: ObservabilitySet;
 }
 interface DBCoreQueryResponse {
   result: any[];
@@ -772,10 +887,12 @@ interface DBCoreOpenCursorRequest {
   unique?: boolean;
   reverse?: boolean;
   query: DBCoreQuery;
+  obsSet?: ObservabilitySet;
 }
 interface DBCoreCountRequest {
   trans: DBCoreTransaction;
   query: DBCoreQuery;
+  obsSet?: ObservabilitySet;
 }
 interface DBCoreCursor {
   readonly trans: DBCoreTransaction;
@@ -820,6 +937,8 @@ interface DBCoreIndex {
   readonly multiEntry?: boolean;
   /** Extract (using keyPath) a key from given value (object). Null for outbound primary keys */
   readonly extractKey: ((value: any) => any) | null;
+  /** If this index is a virtual index, lowLevelIndex represents the actual IndexedDB index behind it */
+  readonly lowLevelIndex?: DBCoreIndex;
 }
 interface DBCore {
   stack: "dbcore";
@@ -841,133 +960,91 @@ interface DBCoreTable {
   openCursor(req: DBCoreOpenCursorRequest): Promise<DBCoreCursor | null>;
   count(req: DBCoreCountRequest): Promise<number>;
 }
-interface Table<T = any, TKey = IndexableType> {
-  db: Database;
+interface Table<T = any, TKey = any, TInsertType = T> {
+  db: Dexie;
   name: string;
   schema: TableSchema;
-  hook: TableHooks<T, TKey>;
+  hook: TableHooks<T, TKey, TInsertType>;
   core: DBCoreTable;
   get(key: TKey): PromiseExtended<T | undefined>;
-  get<R>(key: TKey, thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
+  get<R$1>(key: TKey, thenShortcut: ThenShortcut<T | undefined, R$1>): PromiseExtended<R$1>;
   get(equalityCriterias: {
     [key: string]: any;
   }): PromiseExtended<T | undefined>;
-  get<R>(equalityCriterias: {
+  get<R$1>(equalityCriterias: {
     [key: string]: any;
-  }, thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
-  where(index: string | string[]): WhereClause<T, TKey>;
+  }, thenShortcut: ThenShortcut<T | undefined, R$1>): PromiseExtended<R$1>;
+  where(index: string | string[]): WhereClause<T, TKey, TInsertType>;
   where(equalityCriterias: {
     [key: string]: any;
-  }): Collection<T, TKey>;
-  filter(fn: (obj: T) => boolean): Collection<T, TKey>;
+  }): Collection<T, TKey, TInsertType>;
+  filter(fn: (obj: T) => boolean): Collection<T, TKey, TInsertType>;
   count(): PromiseExtended<number>;
-  count<R>(thenShortcut: ThenShortcut<number, R>): PromiseExtended<R>;
-  offset(n: number): Collection<T, TKey>;
-  limit(n: number): Collection<T, TKey>;
+  count<R$1>(thenShortcut: ThenShortcut<number, R$1>): PromiseExtended<R$1>;
+  offset(n: number): Collection<T, TKey, TInsertType>;
+  limit(n: number): Collection<T, TKey, TInsertType>;
   each(callback: (obj: T, cursor: {
     key: any;
     primaryKey: TKey;
   }) => 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>;
+  toArray<R$1>(thenShortcut: ThenShortcut<T[], R$1>): PromiseExtended<R$1>;
+  toCollection(): Collection<T, TKey, TInsertType>;
+  orderBy(index: string | string[]): Collection<T, TKey, TInsertType>;
+  reverse(): Collection<T, TKey, TInsertType>;
   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>;
+  add(item: TInsertType, key?: TKey): PromiseExtended<TKey>;
+  update(key: TKey | T, changes: UpdateSpec<TInsertType> | ((obj: T, ctx: {
+    value: any;
+    primKey: IndexableType;
+  }) => void | boolean)): PromiseExtended<number>;
+  upsert(key: TKey | T, changes: UpdateSpec<TInsertType>): PromiseExtended<boolean>;
+  put(item: TInsertType, key?: TKey): PromiseExtended<TKey>;
   delete(key: TKey): PromiseExtended<void>;
   clear(): PromiseExtended<void>;
   bulkGet(keys: TKey[]): PromiseExtended<(T | undefined)[]>;
-  bulkAdd<B extends boolean>(items: readonly T[], keys: IndexableTypeArrayReadonly, options: {
+  bulkAdd<B extends boolean>(items: readonly TInsertType[], keys: IndexableTypeArrayReadonly, options: {
     allKeys: B;
   }): PromiseExtended<B extends true ? TKey[] : TKey>;
-  bulkAdd<B extends boolean>(items: readonly T[], options: {
+  bulkAdd<B extends boolean>(items: readonly TInsertType[], options: {
     allKeys: B;
   }): PromiseExtended<B extends true ? TKey[] : TKey>;
-  bulkAdd(items: readonly T[], keys?: IndexableTypeArrayReadonly, options?: {
+  bulkAdd(items: readonly TInsertType[], keys?: IndexableTypeArrayReadonly, options?: {
     allKeys: boolean;
   }): PromiseExtended<TKey>;
-  bulkPut<B extends boolean>(items: readonly T[], keys: IndexableTypeArrayReadonly, options: {
+  bulkPut<B extends boolean>(items: readonly TInsertType[], keys: IndexableTypeArrayReadonly, options: {
     allKeys: B;
   }): PromiseExtended<B extends true ? TKey[] : TKey>;
-  bulkPut<B extends boolean>(items: readonly T[], options: {
+  bulkPut<B extends boolean>(items: readonly TInsertType[], options: {
     allKeys: B;
   }): PromiseExtended<B extends true ? TKey[] : TKey>;
-  bulkPut(items: readonly T[], keys?: IndexableTypeArrayReadonly, options?: {
+  bulkPut(items: readonly TInsertType[], keys?: IndexableTypeArrayReadonly, options?: {
     allKeys: boolean;
   }): PromiseExtended<TKey>;
+  bulkUpdate(keysAndChanges: ReadonlyArray<{
+    key: TKey;
+    changes: UpdateSpec<T>;
+  }>): PromiseExtended<number>;
   bulkDelete(keys: TKey[]): PromiseExtended<void>;
 }
+type DbSchema = {
+  [tableName: string]: TableSchema;
+};
 interface Version {
   stores(schema: {
     [tableName: string]: string | null;
   }): Version;
   upgrade(fn: (trans: Transaction) => PromiseLike<any> | void): Version;
 }
-type IntervalTree = IntervalTreeNode | EmptyRange;
-interface IntervalTreeNode {
-  from: IndexableType; // lower bound
-  to: IndexableType; // upper bound
-  l: IntervalTreeNode | null; // left
-  r: IntervalTreeNode | null; // right
-  d: number; // depth
-}
-interface EmptyRange {
-  d: 0;
-}
-interface DexieOnReadyEvent {
-  subscribe(fn: (vipDb: Dexie) => any, bSticky: boolean): void;
-  unsubscribe(fn: (vipDb: Dexie) => any): void;
-  fire(vipDb: Dexie): any;
-}
-interface DexieVersionChangeEvent {
-  subscribe(fn: (event: IDBVersionChangeEvent) => any): void;
-  unsubscribe(fn: (event: IDBVersionChangeEvent) => any): void;
-  fire(event: IDBVersionChangeEvent): any;
-}
-interface DexiePopulateEvent {
-  subscribe(fn: (trans: Transaction) => any): void;
-  unsubscribe(fn: (trans: Transaction) => any): void;
-  fire(trans: Transaction): any;
-}
-interface DexieCloseEvent {
-  subscribe(fn: (event: Event) => any): void;
-  unsubscribe(fn: (event: Event) => any): void;
-  fire(event: Event): any;
-}
-interface DbEvents extends DexieEventSet {
-  (eventName: "ready", subscriber: (vipDb: Dexie) => any, bSticky?: boolean): void;
-  (eventName: "populate", subscriber: (trans: Transaction) => any): void;
-  (eventName: "blocked", subscriber: (event: IDBVersionChangeEvent) => any): void;
-  (eventName: "versionchange", subscriber: (event: IDBVersionChangeEvent) => any): void;
-  (eventName: "close", subscriber: (event: Event) => any): void;
-  ready: DexieOnReadyEvent;
-  populate: DexiePopulateEvent;
-  blocked: DexieEvent;
-  versionchange: DexieVersionChangeEvent;
-  close: DexieCloseEvent;
-}
-type ObservabilitySet = {
-  // `idb:${dbName}/${tableName}/changedRowContents` - keys.
-  // `idb:${dbName}/${tableName}/changedIndexes/${indexName}` - indexes
-  [part: string]: IntervalTree;
-};
-interface DexieOnStorageMutatedEvent {
-  subscribe(fn: (parts: ObservabilitySet) => any): void;
-  unsubscribe(fn: (parts: ObservabilitySet) => any): void;
-  fire(parts: ObservabilitySet): any;
-}
-interface GlobalDexieEvents extends DexieEventSet {
-  (eventName: "storagemutated", subscriber: (parts: ObservabilitySet) => any): void;
-  storagemutated: DexieOnStorageMutatedEvent;
+interface ExtendableVersion extends Version {
+  db: Dexie;
+  _parseStoresSpec(stores: {
+    [tableName: string]: string | null;
+  }, outSchema: DbSchema): void;
+  _createTableSchema(tableName: string, primKey: IndexSpec, indexes: IndexSpec[]): TableSchema;
+  _parseIndexSyntax(primKeyAndIndexes: string): IndexSpec[];
 }
-type DbSchema = {
-  [tableName: string]: TableSchema;
-};
+type TransactionMode = "readonly" | "readwrite" | "r" | "r!" | "r?" | "rw" | "rw!" | "rw?";
 interface Middleware<TStack extends {
   stack: string;
 }> {
@@ -979,7 +1056,16 @@ interface Middleware<TStack extends {
 interface DexieStacks {
   dbcore: DBCore;
 }
-interface Dexie extends Database {
+type TableProp<DX> = { [K in keyof DX]: DX[K] extends {
+  schema: any;
+  get: any;
+  put: any;
+  add: any;
+  where: any;
+} ? K : never }[keyof DX] & string;
+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] };
+interface Dexie {
   readonly name: string;
   readonly tables: Table[];
   readonly verno: number;
@@ -987,27 +1073,28 @@ interface Dexie extends Database {
   readonly _allTables: {
     [name: string]: Table<any, IndexableType>;
   };
+  readonly _options: DexieOptions;
   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;
+  once: DbEventFns;
   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>;
-  close(): void;
-  delete(): PromiseExtended<void>;
+  table<T = any, TKey = IndexableType, TInsertType = T>(tableName: string): Table<T, TKey, TInsertType>;
+  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(closeOptions?: {
+    disableAutoOpen: boolean;
+  }): void;
+  delete(closeOptions?: {
+    disableAutoOpen: boolean;
+  }): PromiseExtended<void>;
   isOpen(): boolean;
   hasBeenClosed(): boolean;
   hasFailed(): boolean;
@@ -1036,8 +1123,8 @@ interface Dexie extends Database {
   WhereClause: {
     prototype: WhereClause;
   };
-  Version: {
-    prototype: Version;
+  Version: Function & {
+    prototype: ExtendableVersion;
   };
   Transaction: {
     prototype: Transaction;
@@ -1184,6 +1271,7 @@ interface DexieDOMDependencies {
   indexedDB: IDBFactory;
   IDBKeyRange: typeof IDBKeyRange;
 }
+// There typings are extracted from https://github.com/tc39/proposal-observable
 declare global {
   interface SymbolConstructor {
     readonly observable: symbol;
@@ -1212,6 +1300,40 @@ interface Observer<T = any> {
   error?: (error: any) => void;
   complete?: () => void;
 }
+type GlobalQueryCache = {
+  // TODO: Change to parts: {[part: string]: TblQueryCache}
+  //       och unsignaledParts: ObservabilitySet;
+  [part: string]: TblQueryCache; // part is `idb://${dbName}/${tableName}`
+};
+interface TblQueryCache {
+  queries: {
+    query: {
+      [indexName: string]: CacheEntry[];
+    };
+    count: {
+      [indexName: string]: CacheEntry[];
+    };
+  };
+  objs: Map<string | number, object>;
+  optimisticOps: DBCoreMutateRequest[];
+  unsignaledParts: ObservabilitySet;
+}
+interface CacheEntryCommon {
+  subscribers: Set<() => void>;
+  obsSet: ObservabilitySet;
+  //txObsSet: ObservabilitySet;
+  promise: Promise<any>;
+  dirty: boolean;
+}
+type CacheEntry = CacheEntryCommon & ({
+  type: "query";
+  req: DBCoreQueryRequest;
+  res?: readonly any[];
+} | {
+  type: "count";
+  req: DBCoreCountRequest;
+  res?: number;
+});
 type ChromeTransactionDurability = "default" | "strict" | "relaxed";
 interface DexieOptions {
   addons?: Array<(db: Dexie) => void>;
@@ -1225,27 +1347,31 @@ interface DexieOptions {
     upperBound: Function;
   };
   allowEmptyDB?: boolean;
-  modifyChunkSize?: number;
+  modifyChunkSize?: number | {
+    [key: string]: number;
+  };
   chromeTransactionDurability?: ChromeTransactionDurability;
+  cache?: "immutable" | "cloned" | "disabled";
 }
 interface DexieConstructor extends DexieExceptionClasses {
   new (databaseName: string, options?: DexieOptions): Dexie;
-  prototype: Dexie;
+  prototype: any;
   addons: Array<(db: Dexie) => void>;
   version: number;
   semVer: string;
   currentTransaction: Transaction;
   waitFor<T>(promise: PromiseLike<T> | T, timeoutMilliseconds?: number): Promise<T>;
   getDatabaseNames(): Promise<string[]>;
-  getDatabaseNames<R>(thenShortcut: ThenShortcut<string[], R>): Promise<R>;
+  getDatabaseNames<R$1>(thenShortcut: ThenShortcut<string[], R$1>): Promise<R$1>;
   vip<U>(scopeFunction: () => U): U;
   ignoreTransaction<U>(fn: () => U): U;
+  disableBfCache?: boolean;
   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; //?
@@ -1255,6 +1381,8 @@ interface DexieConstructor extends DexieExceptionClasses {
   delete(dbName: string): Promise<void>;
   dependencies: DexieDOMDependencies;
   default: Dexie; // Work-around for different build tools handling default imports differently.
+  cache: GlobalQueryCache;
+  debug: false | true | "dexie";
   Promise: PromiseExtendedConstructor;
   //TableSchema: {}; // Deprecate!
   //IndexSpec: {new():IndexSpec}; //? Deprecate
@@ -1263,13 +1391,16 @@ interface DexieConstructor extends DexieExceptionClasses {
   errnames: DexieErrors;
 }
 declare var Dexie: DexieConstructor;
-interface _Table<T, TKey> extends Table<T, TKey> {}
+// Alias of Table and Collection in order to be able to refer them from module below...
+interface _Table<T, TKey, TInsertType> extends Table<T, TKey, TInsertType> {}
 interface _Collection<T, TKey> extends Collection<T, TKey> {}
+// Besides being the only exported value, let Dexie also be
+// a namespace for types...
 declare module Dexie {
   // The "Dexie.Promise" type.
   type Promise<T = any> = PromiseExtended<T>; // Because many samples have been Dexie.Promise.
   // The "Dexie.Table" interface. Same as named exported interface Table.
-  interface Table<T = any, Key = any> extends _Table<T, Key> {} // Because all samples have been Dexie.Table<...>
+  interface Table<T = any, Key = any, TInsertType = T> extends _Table<T, Key, TInsertType> {} // Because all samples have been Dexie.Table<...>
   // The "Dexie.Collection" interface. Same as named exported interface Collection.
   interface Collection<T = any, Key = any> extends _Collection<T, Key> {} // Because app-code may declare it.
 }