tinybase 5.0.0-beta.1 → 5.0.0-beta.3

package/lib/types/with-schemas/store.d.ts

@@ -17,6 +17,7 @@ import {
   DefaultValueIdFromSchema,
   DefaultedCellFromSchema,
   DefaultedValueFromSchema,
+  StoreAlias,
   TableIdFromSchema,
   Truncate,
   ValueIdFromSchema,
@@ -166,6 +167,12 @@ export type OptionalSchemas = [OptionalTablesSchema, OptionalValuesSchema];
  */
 export type NoSchemas = [NoTablesSchema, NoValuesSchema];
 
+// Content
+export type Content<
+  Schemas extends OptionalSchemas,
+  WhenSet extends boolean = false,
+> = [Tables<Schemas[0], WhenSet>, Values<Schemas[1], WhenSet>];
+
 /**
  * The Tables type is the data structure representing all of the data in a
  * Store.
@@ -787,28 +794,20 @@ export type ChangedValueIds<Schema extends OptionalValuesSchema> = {
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
- *   getTransactionChanges: GetTransactionChanges,
- *   getTransactionLog: GetTransactionLog,
- * ) => boolean;
+ * (store: Store) => boolean;
  * ```
  *
  * A DoRollback can be provided when calling the transaction method or the
  * finishTransaction method. See those methods for specific examples.
  *
- * Since v4.0, this function is provided only with two functions that you can
- * call to get information about the changes made within the transaction (in
- * order to decide whether to do the rollback). See the GetTransactionChanges
- * and GetTransactionLog function types for more details.
- * @param getTransactionChanges A function to be called to get the changes made
- * to the Store during the transaction, since v4.0.
- * @param getTransactionChanges A function to be called to get a more detailed
- * log of the changes made or attempted during the transaction, since v4.0.
+ * Since v5.0, this function is called with the Store as a single argument. You
+ * can use the getTransactionChanges method and getTransactionLog method of the
+ * Store directly to decide whether to do the rollback.
+ * @param store A reference to the Store that is completing a transaction.
  * @category Callback
  */
 export type DoRollback<Schemas extends OptionalSchemas> = (
-  getTransactionChanges: GetTransactionChanges<Schemas>,
-  getTransactionLog: GetTransactionLog<Schemas>,
+  store: Store<Schemas>,
 ) => boolean;
 
 /**
@@ -818,10 +817,8 @@ export type DoRollback<Schemas extends OptionalSchemas> = (
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type TransactionListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
- *   getTransactionChanges: GetTransactionChanges,
- *   getTransactionLog: GetTransactionLog,
  * ) => void;
  * ```
  *
@@ -829,22 +826,17 @@ export type DoRollback<Schemas extends OptionalSchemas> = (
  * addWillFinishTransactionListener and addDidFinishTransactionListener methods.
  * See those methods for specific examples.
  *
- * When called, a TransactionListener is simply given a reference to the Store
- * and, since v4.0, two functions that you can call to get information about the
- * changes made within the transaction. See the GetTransactionChanges and
- * GetTransactionLog function types for more details.
+ * Since v5.0, this listener is called with no arguments other than the Store.
+ * You can use the getTransactionChanges method and getTransactionLog method of
+ * the Store directly to get information about the changes made within the
+ * transaction.
  * @param store A reference to the Store that is completing a transaction.
- * @param getTransactionChanges A function to be called to get the changes made
- * to the Store during the transaction, since v4.0.
- * @param getTransactionChanges A function to be called to get a more detailed
- * log of the changes made or attempted during the transaction, since v4.0.
  * @category Listener
  */
-export type TransactionListener<Schemas extends OptionalSchemas> = (
-  store: Store<Schemas>,
-  getTransactionChanges: GetTransactionChanges<Schemas>,
-  getTransactionLog: GetTransactionLog<Schemas>,
-) => void;
+export type TransactionListener<
+  Schemas extends OptionalSchemas,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
+> = (store: Store) => void;
 
 /**
  * The HasTablesListener type describes a function that is used to listen to
@@ -853,7 +845,10 @@ export type TransactionListener<Schemas extends OptionalSchemas> = (
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (store: Store, hasTables: boolean) => void;
+ * export type HasTablesListener<Store extends StoreAlias = StoreAlias> = (
+ *   store: Store,
+ *   hasTables: boolean,
+ * ) => void;
  * ```
  *
  * A HasTablesListener is provided when using the addHasTablesListener method.
@@ -867,10 +862,10 @@ export type TransactionListener<Schemas extends OptionalSchemas> = (
  * @category Listener
  * @since v4.4.0
  */
-export type HasTablesListener<Schemas extends OptionalSchemas> = (
-  store: Store<Schemas>,
-  hasTables: boolean,
-) => void;
+export type HasTablesListener<
+  Schemas extends OptionalSchemas,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
+> = (store: Store, hasTables: boolean) => void;
 
 /**
  * The TablesListener type describes a function that is used to listen to
@@ -879,7 +874,7 @@ export type HasTablesListener<Schemas extends OptionalSchemas> = (
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type TablesListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   getCellChange: GetCellChange | undefined,
  * ) => void;
@@ -900,8 +895,11 @@ export type HasTablesListener<Schemas extends OptionalSchemas> = (
  * changes.
  * @category Listener
  */
-export type TablesListener<Schemas extends OptionalSchemas> = (
-  store: Store<Schemas>,
+export type TablesListener<
+  Schemas extends OptionalSchemas,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
+> = (
+  store: Store,
   getCellChange: GetCellChange<Schemas[0]> | undefined,
 ) => void;
 
@@ -912,7 +910,7 @@ export type TablesListener<Schemas extends OptionalSchemas> = (
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type TableIdsListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   getIdChanges: GetIdChanges | undefined,
  * ) => void;
@@ -930,8 +928,11 @@ export type TablesListener<Schemas extends OptionalSchemas> = (
  * since v3.3.
  * @category Listener
  */
-export type TableIdsListener<Schemas extends OptionalSchemas> = (
-  store: Store<Schemas>,
+export type TableIdsListener<
+  Schemas extends OptionalSchemas,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
+> = (
+  store: Store,
   getIdChanges: GetIdChanges<TableIdFromSchema<Schemas[0]>> | undefined,
 ) => void;
 
@@ -942,7 +943,7 @@ export type TableIdsListener<Schemas extends OptionalSchemas> = (
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type HasTableListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   tableId: Id,
  *   hasTable: boolean,
@@ -965,8 +966,9 @@ export type TableIdsListener<Schemas extends OptionalSchemas> = (
 export type HasTableListener<
   Schemas extends OptionalSchemas,
   TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
 > = (
-  store: Store<Schemas>,
+  store: Store,
   tableId: TableIdOrNull extends null
     ? TableIdFromSchema<Schemas[0]>
     : TableIdOrNull,
@@ -980,7 +982,7 @@ export type HasTableListener<
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type TableListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   tableId: Id,
  *   getCellChange: GetCellChange | undefined,
@@ -1006,8 +1008,9 @@ export type HasTableListener<
 export type TableListener<
   Schemas extends OptionalSchemas,
   TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
 > = (
-  store: Store<Schemas>,
+  store: Store,
   tableId: TableIdOrNull extends null
     ? TableIdFromSchema<Schemas[0]>
     : TableIdOrNull,
@@ -1021,7 +1024,7 @@ export type TableListener<
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type TableCellIdsListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   tableId: Id,
  *   getIdChanges: GetIdChanges | undefined,
@@ -1043,12 +1046,13 @@ export type TableListener<
 export type TableCellIdsListener<
   Schemas extends OptionalSchemas,
   TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
   Params extends any[] = (
     TableIdOrNull extends null ? TableIdFromSchema<Schemas[0]> : TableIdOrNull
   ) extends infer TableId
     ? TableId extends TableIdFromSchema<Schemas[0]>
       ? [
-          store: Store<Schemas>,
+          store: Store,
           tableId: TableId,
           getIdChanges: GetIdChanges<CellIdFromSchema<Schemas[0], TableId>>,
         ]
@@ -1071,7 +1075,7 @@ export type TableCellIdsListener<
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type HasTableCellListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   tableId: Id,
  *   cellId: Id,
@@ -1101,6 +1105,7 @@ export type HasTableCellListener<
         ? CellIdFromSchema<Schemas[0], TableIdOrNull>
         : AllCellIdFromSchema<Schemas[0]>)
     | null,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
   Params extends any[] = (
     TableIdOrNull extends null ? TableIdFromSchema<Schemas[0]> : TableIdOrNull
   ) extends infer TableId
@@ -1112,7 +1117,7 @@ export type HasTableCellListener<
         ) extends infer CellId
         ? CellId extends CellIdFromSchema<Schemas[0], TableId>
           ? [
-              store: Store<Schemas>,
+              store: Store,
               tableId: TableId,
               cellId: CellId,
               hasTableCell: boolean,
@@ -1140,7 +1145,7 @@ export type HasTableCellListener<
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type RowCountListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   tableId: Id,
  *   count: number,
@@ -1161,8 +1166,9 @@ export type HasTableCellListener<
 export type RowCountListener<
   Schemas extends OptionalSchemas,
   TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
 > = (
-  store: Store<Schemas>,
+  store: Store,
   tableId: TableIdOrNull extends null
     ? TableIdFromSchema<Schemas[0]>
     : TableIdOrNull,
@@ -1176,7 +1182,7 @@ export type RowCountListener<
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type RowIdsListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   tableId: Id,
  *   getIdChanges: GetIdChanges | undefined,
@@ -1200,8 +1206,9 @@ export type RowCountListener<
 export type RowIdsListener<
   Schemas extends OptionalSchemas,
   TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
 > = (
-  store: Store<Schemas>,
+  store: Store,
   tableId: TableIdOrNull extends null
     ? TableIdFromSchema<Schemas[0]>
     : TableIdOrNull,
@@ -1215,7 +1222,7 @@ export type RowIdsListener<
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type SortedRowIdsListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   tableId: Id,
  *   cellId: Id | undefined,
@@ -1252,8 +1259,9 @@ export type SortedRowIdsListener<
   Descending extends boolean,
   Offset extends number,
   Limit extends number | undefined,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
 > = (
-  store: Store<Schemas>,
+  store: Store,
   tableId: TableId,
   cellId: CellId,
   descending: Descending,
@@ -1269,7 +1277,7 @@ export type SortedRowIdsListener<
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type HasRowListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   tableId: Id,
  *   rowId: Id,
@@ -1295,8 +1303,9 @@ export type HasRowListener<
   Schemas extends OptionalSchemas,
   TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
   RowIdOrNull extends IdOrNull,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
 > = (
-  store: Store<Schemas>,
+  store: Store,
   tableId: TableIdOrNull extends null
     ? TableIdFromSchema<Schemas[0]>
     : TableIdOrNull,
@@ -1311,7 +1320,7 @@ export type HasRowListener<
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type RowListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   tableId: Id,
  *   rowId: Id,
@@ -1341,8 +1350,9 @@ export type RowListener<
   Schemas extends OptionalSchemas,
   TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
   RowIdOrNull extends IdOrNull,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
 > = (
-  store: Store<Schemas>,
+  store: Store,
   tableId: TableIdOrNull extends null
     ? TableIdFromSchema<Schemas[0]>
     : TableIdOrNull,
@@ -1357,7 +1367,7 @@ export type RowListener<
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type CellIdsListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   tableId: Id,
  *   rowId: Id,
@@ -1384,12 +1394,13 @@ export type CellIdsListener<
   Schemas extends OptionalSchemas,
   TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
   RowIdOrNull extends IdOrNull,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
   Params extends any[] = (
     TableIdOrNull extends null ? TableIdFromSchema<Schemas[0]> : TableIdOrNull
   ) extends infer TableId
     ? TableId extends TableIdFromSchema<Schemas[0]>
       ? [
-          store: Store<Schemas>,
+          store: Store,
           tableId: TableId,
           rowId: RowIdOrNull extends null ? Id : RowIdOrNull,
           getIdChanges: GetIdChanges<CellIdFromSchema<Schemas[0], TableId>>,
@@ -1415,7 +1426,7 @@ export type CellIdsListener<
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type HasCellListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   tableId: Id,
  *   rowId: Id,
@@ -1448,6 +1459,7 @@ export type HasCellListener<
         ? CellIdFromSchema<Schemas[0], TableIdOrNull>
         : AllCellIdFromSchema<Schemas[0]>)
     | null,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
   Params extends any[] = (
     TableIdOrNull extends null ? TableIdFromSchema<Schemas[0]> : TableIdOrNull
   ) extends infer TableId
@@ -1459,7 +1471,7 @@ export type HasCellListener<
         ) extends infer CellId
         ? CellId extends CellIdFromSchema<Schemas[0], TableId>
           ? [
-              store: Store<Schemas>,
+              store: Store,
               tableId: TableId,
               rowId: RowIdOrNull extends null ? Id : RowIdOrNull,
               cellId: CellId,
@@ -1498,7 +1510,7 @@ export type HasCellListener<
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type CellListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   tableId: Id,
  *   rowId: Id,
@@ -1541,6 +1553,7 @@ export type CellListener<
         ? CellIdFromSchema<Schemas[0], TableIdOrNull>
         : AllCellIdFromSchema<Schemas[0]>)
     | null,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
   Params extends any[] = (
     TableIdOrNull extends null ? TableIdFromSchema<Schemas[0]> : TableIdOrNull
   ) extends infer TableId
@@ -1552,7 +1565,7 @@ export type CellListener<
         ) extends infer CellId
         ? CellId extends CellIdFromSchema<Schemas[0], TableId>
           ? [
-              store: Store<Schemas>,
+              store: Store,
               tableId: TableId,
               rowId: RowIdOrNull extends null ? Id : RowIdOrNull,
               cellId: CellId,
@@ -1601,7 +1614,10 @@ export type CellListener<
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (store: Store, hasValues: boolean) => void;
+ * export type HasValuesListener<Store extends StoreAlias = StoreAlias> = (
+ *   store: Store,
+ *   hasValues: boolean,
+ * ) => void;
  * ```
  *
  * A HasValuesListener is provided when using the addHasValuesListener method.
@@ -1615,10 +1631,10 @@ export type CellListener<
  * @category Listener
  * @since v4.4.0
  */
-export type HasValuesListener<Schemas extends OptionalSchemas> = (
-  store: Store<Schemas>,
-  hasValues: boolean,
-) => void;
+export type HasValuesListener<
+  Schemas extends OptionalSchemas,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
+> = (store: Store, hasValues: boolean) => void;
 
 /**
  * The ValuesListener type describes a function that is used to listen to
@@ -1627,7 +1643,7 @@ export type HasValuesListener<Schemas extends OptionalSchemas> = (
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type ValuesListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   getValueChange: GetValueChange | undefined,
  * ) => void;
@@ -1648,8 +1664,11 @@ export type HasValuesListener<Schemas extends OptionalSchemas> = (
  * changes.
  * @category Listener
  */
-export type ValuesListener<Schemas extends OptionalSchemas> = (
-  store: Store<Schemas>,
+export type ValuesListener<
+  Schemas extends OptionalSchemas,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
+> = (
+  store: Store,
   getValueChange: GetValueChange<Schemas[1]> | undefined,
 ) => void;
 
@@ -1660,7 +1679,7 @@ export type ValuesListener<Schemas extends OptionalSchemas> = (
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type ValueIdsListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   getIdChanges: GetIdChanges | undefined,
  * ) => void;
@@ -1678,8 +1697,11 @@ export type ValuesListener<Schemas extends OptionalSchemas> = (
  * since v3.3.
  * @category Listener
  */
-export type ValueIdsListener<Schemas extends OptionalSchemas> = (
-  store: Store<Schemas>,
+export type ValueIdsListener<
+  Schemas extends OptionalSchemas,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
+> = (
+  store: Store,
   getIdChanges: GetIdChanges<ValueIdFromSchema<Schemas[1]>> | undefined,
 ) => void;
 
@@ -1690,7 +1712,7 @@ export type ValueIdsListener<Schemas extends OptionalSchemas> = (
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type HasValueListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   valueId: Id,
  *   hasValue: boolean,
@@ -1713,8 +1735,9 @@ export type ValueIdsListener<Schemas extends OptionalSchemas> = (
 export type HasValueListener<
   Schemas extends OptionalSchemas,
   ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
 > = (
-  store: Store<Schemas>,
+  store: Store,
   valueId: ValueIdOrNull extends null
     ? ValueIdFromSchema<Schemas[1]>
     : ValueIdOrNull,
@@ -1728,7 +1751,7 @@ export type HasValueListener<
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type ValueListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   valueId: Id,
  *   newValue: Value,
@@ -1761,12 +1784,13 @@ export type HasValueListener<
 export type ValueListener<
   Schemas extends OptionalSchemas,
   ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
   Params extends any[] = (
     ValueIdOrNull extends null ? ValueIdFromSchema<Schemas[1]> : ValueIdOrNull
   ) extends infer ValueId
     ? ValueId extends ValueIdFromSchema<Schemas[1]>
       ? [
-          store: Store<Schemas>,
+          store: Store,
           valueId: ValueId,
           newValue: Value<Schemas[1], ValueId>,
           oldValue: Value<Schemas[1], ValueId>,
@@ -1803,7 +1827,7 @@ export type ValueListener<
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type InvalidCellListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   tableId: Id,
  *   rowId: Id,
@@ -1829,8 +1853,11 @@ export type ValueListener<
  * @category Listener
  * @since v1.1.0
  */
-export type InvalidCellListener<Schemas extends OptionalSchemas> = (
-  store: Store<Schemas>,
+export type InvalidCellListener<
+  Schemas extends OptionalSchemas,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
+> = (
+  store: Store,
   tableId: Id,
   rowId: Id,
   cellId: Id,
@@ -1844,7 +1871,7 @@ export type InvalidCellListener<Schemas extends OptionalSchemas> = (
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * (
+ * export type InvalidValueListener<Store extends StoreAlias = StoreAlias> = (
  *   store: Store,
  *   valueId: Id,
  *   invalidValues: any[],
@@ -1866,11 +1893,10 @@ export type InvalidCellListener<Schemas extends OptionalSchemas> = (
  * @category Listener
  * @since v3.0.0
  */
-export type InvalidValueListener<Schemas extends OptionalSchemas> = (
-  store: Store<Schemas>,
-  valueId: Id,
-  invalidValues: any[],
-) => void;
+export type InvalidValueListener<
+  Schemas extends OptionalSchemas,
+  Store extends StoreAlias<Schemas> = StoreAlias<Schemas>,
+> = (store: Store, valueId: Id, invalidValues: any[]) => void;
 
 /**
  * The GetIdChanges type describes a function that returns information about the
@@ -2047,7 +2073,7 @@ export type ChangedCells<Schema extends OptionalTablesSchema> = {
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * [CellOrUndefined, CellOrUndefined];
+ * [oldCell: CellOrUndefined, newCell: CellOrUndefined];
  * ```
  *
  * It provides both the old and new Cell values in a two-part array. These are
@@ -2136,7 +2162,10 @@ export type ChangedValues<Schema extends OptionalValuesSchema> = {
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * [ValueOrUndefined, ValueOrUndefined];
+ * [
+ *   oldValue: ValueOrUndefined,
+ *   newValue: ValueOrUndefined,
+ * ];
  * ```
  *
  * It provides both the the old and new Values in a two-part array. These
@@ -2178,8 +2207,8 @@ export type ChangedValue<
  */
 export type InvalidValues = {[valueId: Id]: any[]};
 
-// TransactionChanges
-export type TransactionChanges<Schemas extends OptionalSchemas> = [
+// Changes
+export type Changes<Schemas extends OptionalSchemas> = [
   {
     [TableId in TableIdFromSchema<Schemas[0]>]?: {
       [rowId: Id]:
@@ -2201,25 +2230,6 @@ export type TransactionChanges<Schemas extends OptionalSchemas> = [
   },
 ];
 
-/**
- * The GetTransactionChanges type describes a function that returns the net
- * meaningful changes that were made to a Store during a transaction.
- *
- * This has schema-based typing. The following is a simplified representation:
- *
- * ```ts override
- * () => TransactionChanges;
- * ```
- *
- * It is provided to the DoRollback callback and to a TransactionListener
- * listener when a transaction completes. See the TransactionChanges type for
- * more information and an example of the returned data structure.
- * @category Transaction
- * @since v4.0.0
- */
-export type GetTransactionChanges<Schemas extends OptionalSchemas> =
-  () => TransactionChanges<Schemas>;
-
 /**
  * The TransactionLog type describes the changes that were made to a Store
  * during a transaction in detail.
@@ -2227,21 +2237,21 @@ export type GetTransactionChanges<Schemas extends OptionalSchemas> =
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * {
- *   cellsTouched: boolean;
- *   valuesTouched: boolean;
- *   changedCells: ChangedCells;
- *   invalidCells: InvalidCells;
- *   changedValues: ChangedValues;
- *   invalidValues: InvalidValues;
- *   changedTableIds: ChangedTableIds;
- *   changedRowIds: ChangedRowIds;
- *   changedCellIds: ChangedCellIds;
- *   changedValueIds: ChangedValueIds;
- * };
+ * [
+ *   cellsTouched: boolean,
+ *   valuesTouched: boolean,
+ *   changedCells: ChangedCells,
+ *   invalidCells: InvalidCells,
+ *   changedValues: ChangedValues,
+ *   invalidValues: InvalidValues,
+ *   changedTableIds: ChangedTableIds,
+ *   changedRowIds: ChangedRowIds,
+ *   changedCellIds: ChangedCellIds,
+ *   changedValueIds: ChangedValueIds,
+ * ];
  * ```
  *
- * This contains equivalent information to a TransactionChanges object, but also
+ * This contains equivalent information to a Changes object, but also
  * information about what the previous state of the Store was. The changedCells
  * and changedValues entries contain information about all changes to those
  * parts of the Store, with their before and after values, for example.
@@ -2257,6 +2267,9 @@ export type GetTransactionChanges<Schemas extends OptionalSchemas> =
  * of `cellsTouched` and `valuesTouched` in the listener will be `false` because
  * all changes have been reverted.
  *
+ * In v5.0, this type changed from an object to an array, but still contains the
+ * same values.
+ *
  * See the documentation for the types of the inner objects for other details.
  * @category Transaction
  * @since v4.0.0
@@ -2274,25 +2287,6 @@ export type TransactionLog<Schemas extends OptionalSchemas> = {
   changedValueIds: ChangedValueIds<Schemas[1]>;
 };
 
-/**
- * The GetTransactionLog type describes a function that returns the changes that
- * were made to a Store during a transaction in detail.
- *
- * This has schema-based typing. The following is a simplified representation:
- *
- * ```ts override
- * () => TransactionLog;
- * ```
- *
- * It is provided to the DoRollback callback and to a TransactionListener
- * listener when a transaction completes. See the TransactionLog type for more
- * information.
- * @category Transaction
- * @since v4.0.0
- */
-export type GetTransactionLog<Schemas extends OptionalSchemas> =
-  () => TransactionLog<Schemas>;
-
 /**
  * The StoreListenerStats type describes the number of listeners registered with
  * the Store, and can be used for debugging purposes.
@@ -2602,7 +2596,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * getContent(): [Tables, Values];
+   * getContent(): Content;
    * ```
    *
    * Note that this returns a copy of, rather than a reference to the underlying
@@ -2631,7 +2625,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Getter
    * @since v4.0.0
    */
-  getContent(): [Tables<Schemas[0]>, Values<Schemas[1]>];
+  getContent(): Content<Schemas>;
 
   /**
    * The getTables method returns a Tables object containing the entire tabular
@@ -3643,7 +3637,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setContent([tables, values]: [Tables, Values]): Store;
+   * setContent(content: Content): this;
    * ```
    *
    * This method will cause listeners to be called for any Table, Row, Cell,
@@ -3698,10 +3692,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Setter
    * @since v4.0.0
    */
-  setContent([tables, values]: [
-    Tables<Schemas[0], true>,
-    Values<Schemas[1], true>,
-  ]): Store<Schemas>;
+  setContent(content: Content<Schemas, true>): Store<Schemas>;
 
   /**
    * The setTables method takes an object and sets the entire tabular data of
@@ -3710,7 +3701,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setTables(tables: Tables): Store;
+   * setTables(tables: Tables): this;
    * ```
    *
    * This method will cause listeners to be called for any Table, Row, Cell, or
@@ -3764,7 +3755,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setTable(tableId: Id, table: Table): Store;
+   * setTable(tableId: Id, table: Table): this;
    * ```
    *
    * This method will cause listeners to be called for any Table, Row, Cell, or
@@ -3823,7 +3814,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setRow(tableId: Id, rowId: Id, row: Row): Store;
+   * setRow(tableId: Id, rowId: Id, row: Row): this;
    * ```
    *
    * This method will cause listeners to be called for any Table, Row, Cell, or
@@ -3953,7 +3944,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setPartialRow(tableId: Id, rowId: Id, partialRow: Row): Store;
+   * setPartialRow(tableId: Id, rowId: Id, partialRow: Row): this;
    * ```
    *
    * This method will cause listeners to be called for any Table, Row, Cell, or
@@ -4013,7 +4004,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setCell(tableId: Id, rowId: Id, cellId: Id, cell: Cell | MapCell): Store;
+   * setCell(tableId: Id, rowId: Id, cellId: Id, cell: Cell | MapCell): this;
    * ```
    *
    * This method will cause listeners to be called for any Table, Row, Cell, or
@@ -4086,7 +4077,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setValues(values: Values): Store;
+   * setValues(values: Values): this;
    * ```
    *
    * This method will cause listeners to be called for any Value or Id changes
@@ -4140,7 +4131,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setPartialValues(partialValues: Values): Store;
+   * setPartialValues(partialValues: Values): this;
    * ```
    *
    * This method will cause listeners to be called for any Values or Id changes
@@ -4194,7 +4185,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setValue(valueId: Id, value: Value | MapValue): Store;
+   * setValue(valueId: Id, value: Value | MapValue): this;
    * ```
    *
    * This method will cause listeners to be called for any Value, or Id changes
@@ -4251,31 +4242,32 @@ export interface Store<in out Schemas extends OptionalSchemas> {
   ): Store<Schemas>;
 
   /**
-   * The setTransactionChanges method applies a set of TransactionChanges to the
-   * Store.
+   * The applyChanges method applies a set of Changes to the Store.
    *
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setTransactionChanges(transactionChanges: TransactionChanges): Store;
+   * applyChanges(changes: Changes): this;
    * ```
    *
-   * This method will take a TransactionChanges object (which is available at
-   * the end of a transaction) and apply it to a Store. The most likely need to
-   * do this is to take the changes made during the transaction of one Store,
-   * and apply it to the content of _another_ Store - such as when persisting
-   * and synchronizing data.
+   * This method will take a Changes object (which is available at the end of a
+   * transaction) and apply it to a Store. The most likely need to do this is to
+   * take the changes made during the transaction of one Store, and apply it to
+   * the content of _another_ Store - such as when persisting and synchronizing
+   * data.
    *
-   * Any part of the provided TransactionChanges object are invalid (either
-   * because of its type, or because it does not match the schemas associated
-   * with the Store) will be ignored silently.
+   * Any part of the provided Changes object are invalid (either because of its
+   * type, or because it does not match the schemas associated with the Store)
+   * will be ignored silently.
    *
    * The method returns a reference to the Store so that subsequent operations
    * can be chained in a fluent style.
-   * @param transactionChanges The TransactionChanges to apply to the Store.
+   *
+   * Prior to v5.0, this method was named `setTransactionChanges`.
+   * @param changes The Changes to apply to the Store.
    * @returns A reference to the Store.
    * @example
-   * This example applies a TransactionChanges object that sets a Cell and
+   * This example applies a Changes object that sets a Cell and
    * removes a Value.
    *
    * ```js
@@ -4283,21 +4275,16 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    *   .setTables({pets: {fido: {species: 'dog', color: 'brown'}}})
    *   .setValues({open: true});
    *
-   * store.setTransactionChanges([
-   *   {pets: {fido: {color: 'black'}}},
-   *   {open: null},
-   * ]);
+   * store.applyChanges([{pets: {fido: {color: 'black'}}}, {open: null}]);
    * console.log(store.getTables());
    * // -> {pets: {fido: {species: 'dog', color: 'black'}}}
    * console.log(store.getValues());
    * // -> {}
    * ```
    * @category Setter
-   * @since v4.0.0
+   * @since v5.0.0
    */
-  setTransactionChanges(
-    transactionChanges: TransactionChanges<Schemas>,
-  ): Store<Schemas>;
+  applyChanges(changes: Changes<Schemas>): Store<Schemas>;
 
   /**
    * The setTablesJson method takes a string serialization of all of the Tables
@@ -4306,7 +4293,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setTablesJson(tablesJson: Json): Store;
+   * setTablesJson(tablesJson: Json): this;
    * ```
    *
    * If the JSON cannot be parsed, this will fail silently. If it can be parsed,
@@ -4346,7 +4333,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setValuesJson(valuesJson: Json): Store;
+   * setValuesJson(valuesJson: Json): this;
    * ```
    *
    * If the JSON cannot be parsed, this will fail silently. If it can be parsed,
@@ -4386,7 +4373,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setJson(tablesAndValuesJson: Json): Store;
+   * setJson(tablesAndValuesJson: Json): this;
    * ```
    *
    * From v3.0 onwards, the serialization should be of an array with two
@@ -4450,7 +4437,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setTablesSchema(tablesSchema: TablesSchema): Store;
+   * setTablesSchema(tablesSchema: TablesSchema): this;
    * ```
    *
    * Note that this may result in a change to data in the Store, as defaults are
@@ -4490,7 +4477,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setValuesSchema(valuesSchema: ValuesSchema): Store;
+   * setValuesSchema(valuesSchema: ValuesSchema): this;
    * ```
    *
    * Note that this may result in a change to data in the Store, as defaults are
@@ -4527,7 +4514,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * setSchema(tablesSchema: TablesSchema, valuesSchema?: ValuesSchema): Store;
+   * setSchema(tablesSchema: TablesSchema, valuesSchema?: ValuesSchema): this;
    * ```
    *
    * Note that this may result in a change to data in the Store, as defaults are
@@ -4603,7 +4590,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * delTables(): Store;
+   * delTables(): this;
    * ```
    *
    * ```js
@@ -4627,7 +4614,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * delTable(tableId: Id): Store;
+   * delTable(tableId: Id): this;
    * ```
    *
    * ```js
@@ -4650,7 +4637,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * delRow(tableId: Id, rowId: Id): Store;
+   * delRow(tableId: Id, rowId: Id): this;
    * ```
    *
    * If this is the last Row in its Table, then that Table will be removed.
@@ -4679,7 +4666,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * delCell(tableId: Id, rowId: Id, cellId: Id, forceDel?: boolean): Store;
+   * delCell(tableId: Id, rowId: Id, cellId: Id, forceDel?: boolean): this;
    * ```
    *
    * When there is no TablesSchema applied to the Store, then if this is the
@@ -4773,7 +4760,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * delValues(): Store;
+   * delValues(): this;
    * ```
    *
    * If there is a ValuesSchema applied to the Store and it specifies a default
@@ -4817,7 +4804,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * delValue(valueId: Id): Store;
+   * delValue(valueId: Id): this;
    * ```
    *
    * If there is a ValuesSchema applied to the Store and it specifies a default
@@ -4865,7 +4852,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * delTablesSchema(): Store;
+   * delTablesSchema(): this;
    * ```
    *
    * ```js
@@ -4891,7 +4878,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * delValuesSchema(): Store;
+   * delValuesSchema(): this;
    * ```
    *
    * ```js
@@ -4916,7 +4903,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * delSchema(): Store;
+   * delSchema(): this;
    * ```
    *
    * Prior to v3.0, this method removed the TablesSchema only.
@@ -4971,10 +4958,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    *
    * The second, optional parameter, `doRollback` is a DoRollback callback that
    * you can use to rollback the transaction if it did not complete to your
-   * satisfaction. It is called with `getTransactionChanges` and
-   * `getTransactionLog` parameters, which inform you of the net changes that
-   * have been made during the transaction, at different levels of detail. See
-   * the DoRollback documentation for more details.
+   * satisfaction. See the DoRollback documentation for more details.
    * @param actions The function to be executed as a transaction.
    * @param doRollback An optional callback that should return `true` if you
    * want to rollback the transaction at the end. Since v1.2.
@@ -5050,9 +5034,9 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    *       .setCell('pets', 'fido', 'info', {sold: null})
    *       .setValue('open', false)
    *       .setValue('employees', ['alice', 'bob']),
-   *   (_, getTransactionLog) => {
-   *     const {changedCells, invalidCells, changedValues, invalidValues} =
-   *       getTransactionLog();
+   *   () => {
+   *     const [, , changedCells, invalidCells, changedValues, invalidValues] =
+   *       store.getTransactionLog();
    *     console.log(store.getTables());
    *     console.log(changedCells);
    *     console.log(invalidCells);
@@ -5088,7 +5072,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * startTransaction(): Store;
+   * startTransaction(): this;
    * ```
    *
    * Transactions are useful for making bulk changes to the data in a Store, and
@@ -5135,6 +5119,93 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    */
   startTransaction(): Store<Schemas>;
 
+  /**
+   * The getTransactionChanges method returns the net meaningful changes that
+   * have been made to a Store during a transaction.
+   *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getTransactionChanges(): Changes;
+   * ```
+   *
+   * This is useful for deciding whether to rollback a transaction, for example.
+   * The returned object is only meaningful if the method is called when the
+   * Store is in a transaction - such as in a TransactionListener.
+   * @example
+   * This example makes changes to the Store. At the end of the transaction,
+   * detail about what changed is enumerated.
+   *
+   * ```js
+   * const store = createStore()
+   *   .setTables({pets: {fido: {species: 'dog', color: 'brown'}}})
+   *   .setValues({open: true});
+   *
+   * store
+   *   .startTransaction()
+   *   .setCell('pets', 'fido', 'color', 'black')
+   *   .setValue('open', false)
+   *   .finishTransaction(() => {
+   *     const [changedCells, changedValues] = store.getTransactionChanges();
+   *     console.log(changedCells);
+   *     console.log(changedValues);
+   *   });
+   * // -> {pets: {fido: {color: 'black'}}}
+   * // -> {open: false}
+   * ```
+   * @category Transaction
+   * @since v5.0.0
+   */
+  getTransactionChanges(): Changes<Schemas>;
+
+  /**
+   * The getTransactionLog method returns the changes that were made to a Store
+   * during a transaction in more detail, including invalid changes, and what
+   * previous values were.
+   *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getTransactionLog(): TransactionLog;
+   * ```
+   *
+   * This is useful for deciding whether to rollback a transaction, for example.
+   * The returned object is only meaningful if the method is called when the
+   * Store is in a transaction - such as in a TransactionListener.
+   * @example
+   * This example makes changes to the Store. At the end of the transaction,
+   * detail about what changed is enumerated.
+   *
+   * ```js
+   * const store = createStore()
+   *   .setTables({pets: {fido: {species: 'dog', color: 'brown'}}})
+   *   .setValues({open: true});
+   *
+   * store
+   *   .startTransaction()
+   *   .setCell('pets', 'fido', 'color', 'black')
+   *   .setCell('pets', 'fido', 'eyes', ['left', 'right'])
+   *   .setCell('pets', 'fido', 'info', {sold: null})
+   *   .setValue('open', false)
+   *   .setValue('employees', ['alice', 'bob'])
+   *   .finishTransaction(() => {
+   *     const [, , changedCells, invalidCells, changedValues, invalidValues] =
+   *       store.getTransactionLog();
+   *     console.log(changedCells);
+   *     console.log(invalidCells);
+   *     console.log(changedValues);
+   *     console.log(invalidValues);
+   *   });
+   * // -> {pets: {fido: {color: ['brown', 'black']}}}
+   * // -> {pets: {fido: {eyes: [['left', 'right']], info: [{sold: null}]}}}
+   * // -> {open: [true, false]}
+   * // -> {employees: [['alice', 'bob']]}
+   * ```
+   * @category Transaction
+   * @since v5.0.0
+   */
+  getTransactionLog(): TransactionLog<Schemas>;
+
   /**
    * The finishTransaction method allows you to explicitly finish a transaction
    * that has made multiple mutations to the Store, triggering all calls to the
@@ -5143,7 +5214,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * finishTransaction(doRollback?: DoRollback): Store;
+   * finishTransaction(doRollback?: DoRollback): this;
    * ```
    *
    * Transactions are useful for making bulk changes to the data in a Store, and
@@ -5212,9 +5283,9 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    *   .setCell('pets', 'fido', 'info', {sold: null})
    *   .setValue('open', false)
    *   .setValue('employees', ['alice', 'bob'])
-   *   .finishTransaction((_, getTransactionLog) => {
-   *     const {changedCells, invalidCells, changedValues, invalidValues} =
-   *       getTransactionLog();
+   *   .finishTransaction(() => {
+   *     const [, , changedCells, invalidCells, changedValues, invalidValues] =
+   *       store.getTransactionLog();
    *     console.log(store.getTables());
    *     console.log(changedCells);
    *     console.log(invalidCells);
@@ -5432,7 +5503,10 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * addHasTablesListener(listener: HasTablesListener, mutator?: boolean): Id;
+   * addHasTablesListener(
+   *   listener: HasTablesListener<this>,
+   *   mutator?: boolean,
+   * ): Id;
    * ```
    *
    * The provided listener is a HasTablesListener function, and will be called
@@ -5494,7 +5568,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @since v4.4.0
    */
   addHasTablesListener(
-    listener: HasTablesListener<Schemas>,
+    listener: HasTablesListener<Schemas, this>,
     mutator?: boolean,
   ): Id;
 
@@ -5505,7 +5579,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * addTablesListener(listener: TablesListener, mutator?: boolean): Id;
+   * addTablesListener(listener: TablesListener<this>, mutator?: boolean): Id;
    * ```
    *
    * The provided listener is a TablesListener function, and will be called with
@@ -5565,7 +5639,10 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```
    * @category Listener
    */
-  addTablesListener(listener: TablesListener<Schemas>, mutator?: boolean): Id;
+  addTablesListener(
+    listener: TablesListener<Schemas, this>,
+    mutator?: boolean,
+  ): Id;
 
   /**
    * The addTableIdsListener method registers a listener function with the Store
@@ -5574,7 +5651,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * addTableIdsListener(listener: TableIdsListener, mutator?: boolean): Id;
+   * addTableIdsListener(listener: TableIdsListener<this>, mutator?: boolean): Id;
    * ```
    *
    * The provided listener is a TableIdsListener function, and will be called
@@ -5634,7 +5711,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Listener
    */
   addTableIdsListener(
-    listener: TableIdsListener<Schemas>,
+    listener: TableIdsListener<Schemas, this>,
     mutator?: boolean,
   ): Id;
 
@@ -5647,7 +5724,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addHasTableListener(
    *   tableId: IdOrNull,
-   *   listener: HasTableListener,
+   *   listener: HasTableListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -5747,7 +5824,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
   >(
     tableId: TableIdOrNull,
-    listener: HasTableListener<Schemas, TableIdOrNull>,
+    listener: HasTableListener<Schemas, TableIdOrNull, this>,
     mutator?: boolean,
   ): Id;
 
@@ -5760,7 +5837,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addTableListener(
    *   tableId: IdOrNull,
-   *   listener: TableListener,
+   *   listener: TableListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -5853,7 +5930,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    */
   addTableListener<TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null>(
     tableId: TableIdOrNull,
-    listener: TableListener<Schemas, TableIdOrNull>,
+    listener: TableListener<Schemas, TableIdOrNull, this>,
     mutator?: boolean,
   ): Id;
 
@@ -5867,7 +5944,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addTableCellIdsListener(
    *   tableId: IdOrNull,
-   *   listener: TableCellIdsListener,
+   *   listener: TableCellIdsListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -5969,7 +6046,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
   >(
     tableId: TableIdOrNull,
-    listener: TableCellIdsListener<Schemas, TableIdOrNull>,
+    listener: TableCellIdsListener<Schemas, TableIdOrNull, this>,
     mutator?: boolean,
   ): Id;
 
@@ -5984,7 +6061,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * addHasTableCellListener(
    *   tableId: IdOrNull,
    *   cellId: IdOrNull,
-   *   listener: HasTableCellListener,
+   *   listener: HasTableCellListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -6106,7 +6183,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
   >(
     tableId: TableIdOrNull,
     cellId: CellIdOrNull,
-    listener: HasTableCellListener<Schemas, TableIdOrNull, CellIdOrNull>,
+    listener: HasTableCellListener<Schemas, TableIdOrNull, CellIdOrNull, this>,
     mutator?: boolean,
   ): Id;
 
@@ -6119,7 +6196,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addRowCountListener(
    *   tableId: IdOrNull,
-   *   listener: RowCountListener,
+   *   listener: RowCountListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -6211,7 +6288,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
   >(
     tableId: TableIdOrNull,
-    listener: RowCountListener<Schemas, TableIdOrNull>,
+    listener: RowCountListener<Schemas, TableIdOrNull, this>,
     mutator?: boolean,
   ): Id;
 
@@ -6224,7 +6301,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addRowIdsListener(
    *   tableId: IdOrNull,
-   *   listener: RowIdsListener,
+   *   listener: RowIdsListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -6312,7 +6389,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    */
   addRowIdsListener<TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null>(
     tableId: TableIdOrNull,
-    listener: RowIdsListener<Schemas, TableIdOrNull>,
+    listener: RowIdsListener<Schemas, TableIdOrNull, this>,
     mutator?: boolean,
   ): Id;
 
@@ -6330,7 +6407,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    *   descending: boolean,
    *   offset: number,
    *   limit: number | undefined,
-   *   listener: SortedRowIdsListener,
+   *   listener: SortedRowIdsListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -6563,7 +6640,8 @@ export interface Store<in out Schemas extends OptionalSchemas> {
       CellIdOrUndefined,
       Descending,
       Offset,
-      Limit
+      Limit,
+      this
     >,
     mutator?: boolean,
   ): Id;
@@ -6578,7 +6656,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * addHasRowListener(
    *   tableId: IdOrNull,
    *   rowId: IdOrNull,
-   *   listener: HasRowListener,
+   *   listener: HasRowListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -6695,7 +6773,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
   >(
     tableId: TableIdOrNull,
     rowId: RowIdOrNull,
-    listener: HasRowListener<Schemas, TableIdOrNull, RowIdOrNull>,
+    listener: HasRowListener<Schemas, TableIdOrNull, RowIdOrNull, this>,
     mutator?: boolean,
   ): Id;
 
@@ -6709,7 +6787,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * addRowListener(
    *   tableId: IdOrNull,
    *   rowId: IdOrNull,
-   *   listener: RowListener,
+   *   listener: RowListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -6818,7 +6896,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
   >(
     tableId: TableIdOrNull,
     rowId: RowIdOrNull,
-    listener: RowListener<Schemas, TableIdOrNull, RowIdOrNull>,
+    listener: RowListener<Schemas, TableIdOrNull, RowIdOrNull, this>,
     mutator?: boolean,
   ): Id;
 
@@ -6832,7 +6910,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * addCellIdsListener(
    *   tableId: IdOrNull,
    *   rowId: IdOrNull,
-   *   listener: CellIdsListener,
+   *   listener: CellIdsListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -6937,7 +7015,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
   >(
     tableId: TableIdOrNull,
     rowId: RowIdOrNull,
-    listener: CellIdsListener<Schemas, TableIdOrNull, RowIdOrNull>,
+    listener: CellIdsListener<Schemas, TableIdOrNull, RowIdOrNull, this>,
     mutator?: boolean,
   ): Id;
 
@@ -6952,7 +7030,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    *   tableId: IdOrNull,
    *   rowId: IdOrNull,
    *   cellId: IdOrNull,
-   *   listener: HasCellListener,
+   *   listener: HasCellListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -7085,7 +7163,8 @@ export interface Store<in out Schemas extends OptionalSchemas> {
       Schemas,
       TableIdOrNull,
       RowIdOrNull,
-      CellIdOrNull
+      CellIdOrNull,
+      this
     >,
     mutator?: boolean,
   ): Id;
@@ -7101,7 +7180,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    *   tableId: IdOrNull,
    *   rowId: IdOrNull,
    *   cellId: IdOrNull,
-   *   listener: CellListener,
+   *   listener: CellListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -7225,7 +7304,13 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     tableId: TableIdOrNull,
     rowId: RowIdOrNull,
     cellId: CellIdOrNull,
-    listener: CellListener<Schemas, TableIdOrNull, RowIdOrNull, CellIdOrNull>,
+    listener: CellListener<
+      Schemas,
+      TableIdOrNull,
+      RowIdOrNull,
+      CellIdOrNull,
+      this
+    >,
     mutator?: boolean,
   ): Id;
 
@@ -7237,7 +7322,10 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * addHasValuesListener(listener: HasValuesListener, mutator?: boolean): Id;
+   * addHasValuesListener(
+   *   listener: HasValuesListener<this>,
+   *   mutator?: boolean,
+   * ): Id;
    * ```
    *
    * The provided listener is a HasValuesListener function, and will be called
@@ -7297,7 +7385,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @since v4.4.0
    */
   addHasValuesListener(
-    listener: HasValuesListener<Schemas>,
+    listener: HasValuesListener<Schemas, this>,
     mutator?: boolean,
   ): Id;
 
@@ -7308,7 +7396,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * addValuesListener(listener: ValuesListener, mutator?: boolean): Id;
+   * addValuesListener(listener: ValuesListener<this>, mutator?: boolean): Id;
    * ```
    *
    * The provided listener is a ValuesListener function, and will be called with
@@ -7365,7 +7453,10 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Listener
    * @since v3.0.0
    */
-  addValuesListener(listener: ValuesListener<Schemas>, mutator?: boolean): Id;
+  addValuesListener(
+    listener: ValuesListener<Schemas, this>,
+    mutator?: boolean,
+  ): Id;
 
   /**
    * The addValueIdsListener method registers a listener function with the Store
@@ -7374,7 +7465,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * addValueIdsListener(listener: ValueIdsListener, mutator?: boolean): Id;
+   * addValueIdsListener(listener: ValueIdsListener<this>, mutator?: boolean): Id;
    * ```
    *
    * The provided listener is a ValueIdsListener function, and will be called
@@ -7435,7 +7526,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @since v3.0.0
    */
   addValueIdsListener(
-    listener: ValueIdsListener<Schemas>,
+    listener: ValueIdsListener<Schemas, this>,
     mutator?: boolean,
   ): Id;
 
@@ -7448,7 +7539,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addHasValueListener(
    *   valueId: IdOrNull,
-   *   listener: HasValueListener,
+   *   listener: HasValueListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -7542,7 +7633,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null,
   >(
     valueId: ValueIdOrNull,
-    listener: HasValueListener<Schemas, ValueIdOrNull>,
+    listener: HasValueListener<Schemas, ValueIdOrNull, this>,
     mutator?: boolean,
   ): Id;
 
@@ -7555,7 +7646,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addValueListener(
    *   valueId: IdOrNull,
-   *   listener: ValueListener,
+   *   listener: ValueListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -7644,7 +7735,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    */
   addValueListener<ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null>(
     valueId: ValueIdOrNull,
-    listener: ValueListener<Schemas, ValueIdOrNull>,
+    listener: ValueListener<Schemas, ValueIdOrNull, this>,
     mutator?: boolean,
   ): Id;
 
@@ -7660,7 +7751,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    *   tableId: IdOrNull,
    *   rowId: IdOrNull,
    *   cellId: IdOrNull,
-   *   listener: InvalidCellListener,
+   *   listener: InvalidCellListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -7886,7 +7977,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     tableId: IdOrNull,
     rowId: IdOrNull,
     cellId: IdOrNull,
-    listener: InvalidCellListener<Schemas>,
+    listener: InvalidCellListener<Schemas, this>,
     mutator?: boolean,
   ): Id;
 
@@ -7900,7 +7991,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addInvalidValueListener(
    *   valueId: IdOrNull,
-   *   listener: InvalidValueListener,
+   *   listener: InvalidValueListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -8071,7 +8162,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    */
   addInvalidValueListener(
     valueId: IdOrNull,
-    listener: InvalidValueListener<Schemas>,
+    listener: InvalidValueListener<Schemas, this>,
     mutator?: boolean,
   ): Id;
 
@@ -8082,7 +8173,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * addStartTransactionListener(listener: TransactionListener): Id;
+   * addStartTransactionListener(listener: TransactionListener<this>): Id;
    * ```
    *
    * The provided TransactionListener will receive a reference to the Store and
@@ -8125,7 +8216,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Listener
    * @since v3.2.0
    */
-  addStartTransactionListener(listener: TransactionListener<Schemas>): Id;
+  addStartTransactionListener(listener: TransactionListener<Schemas, this>): Id;
 
   /**
    * The addWillFinishTransactionListener method registers a listener function
@@ -8135,7 +8226,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * addWillFinishTransactionListener(listener: TransactionListener): Id;
+   * addWillFinishTransactionListener(listener: TransactionListener<this>): Id;
    * ```
    *
    * This is useful if you need to know that a set of listeners are about to be
@@ -8172,12 +8263,10 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    *     pets: {fido: {species: 'dog', color: 'brown'}},
    *   })
    *   .setValues({open: true, employees: 3});
-   * const listenerId = store.addWillFinishTransactionListener(
-   *   (store, _, getTransactionLog) => {
-   *     const {cellsTouched, valuesTouched} = getTransactionLog?.() ?? {};
-   *     console.log(`Cells/Values touched: ${cellsTouched}/${valuesTouched}`);
-   *   },
-   * );
+   * const listenerId = store.addWillFinishTransactionListener((store) => {
+   *   const [cellsTouched, valuesTouched] = store.getTransactionLog() ?? {};
+   *   console.log(`Cells/Values touched: ${cellsTouched}/${valuesTouched}`);
+   * });
    * const listenerId2 = store.addTablesListener(() =>
    *   console.log('Tables changed'),
    * );
@@ -8219,7 +8308,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * // Transaction was rolled back.
    *
    * store.callListener(listenerId);
-   * // -> 'Cells/Values touched: undefined/undefined'
+   * // -> 'Cells/Values touched: false/false'
    * // It is meaningless to call this listener directly.
    *
    * store
@@ -8230,7 +8319,9 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Listener
    * @since v1.3.0
    */
-  addWillFinishTransactionListener(listener: TransactionListener<Schemas>): Id;
+  addWillFinishTransactionListener(
+    listener: TransactionListener<Schemas, this>,
+  ): Id;
 
   /**
    * The addDidFinishTransactionListener method registers a listener function
@@ -8240,7 +8331,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * addDidFinishTransactionListener(listener: TransactionListener): Id;
+   * addDidFinishTransactionListener(listener: TransactionListener<this>): Id;
    * ```
    *
    * This is useful if you need to know that a set of listeners have just been
@@ -8276,12 +8367,10 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    *     pets: {fido: {species: 'dog', color: 'brown'}},
    *   })
    *   .setValues({open: true, employees: 3});
-   * const listenerId = store.addDidFinishTransactionListener(
-   *   (store, _, getTransactionLog) => {
-   *     const {cellsTouched, valuesTouched} = getTransactionLog?.() ?? {};
-   *     console.log(`Cells/Values touched: ${cellsTouched}/${valuesTouched}`);
-   *   },
-   * );
+   * const listenerId = store.addDidFinishTransactionListener((store) => {
+   *   const [cellsTouched, valuesTouched] = store.getTransactionLog() ?? {};
+   *   console.log(`Cells/Values touched: ${cellsTouched}/${valuesTouched}`);
+   * });
    * const listenerId2 = store.addTablesListener(() =>
    *   console.log('Tables changed'),
    * );
@@ -8323,7 +8412,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * // Transaction was rolled back.
    *
    * store.callListener(listenerId);
-   * // -> 'Cells/Values touched: undefined/undefined'
+   * // -> 'Cells/Values touched: false/false'
    * // It is meaningless to call this listener directly.
    *
    * store
@@ -8334,7 +8423,9 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Listener
    * @since v1.3.0
    */
-  addDidFinishTransactionListener(listener: TransactionListener<Schemas>): Id;
+  addDidFinishTransactionListener(
+    listener: TransactionListener<Schemas, this>,
+  ): Id;
 
   /**
    * The callListener method provides a way for you to manually provoke a
@@ -8343,7 +8434,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * callListener(listenerId: Id): Store;
+   * callListener(listenerId: Id): this;
    * ```
    *
    * This is useful when you are using mutator listeners to guarantee that data
@@ -8465,7 +8556,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * delListener(listenerId: Id): Store;
+   * delListener(listenerId: Id): this;
    * ```
    *
    * Use the Id returned by whichever method was used to add the listener. Note