tinybase 5.0.0-beta.1 → 5.0.0-beta.11

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

@@ -17,11 +17,12 @@ import {
   DefaultValueIdFromSchema,
   DefaultedCellFromSchema,
   DefaultedValueFromSchema,
+  StoreAlias,
   TableIdFromSchema,
   Truncate,
   ValueIdFromSchema,
 } from './internal/store';
-import {Id, IdOrNull, Ids, Json} from './common.d';
+import {Id, IdOrNull, Ids, Json} from './common.d.ts';
 
 /**
  * The TablesSchema type describes the tabular structure of a Store in terms of
@@ -166,6 +167,46 @@ export type OptionalSchemas = [OptionalTablesSchema, OptionalValuesSchema];
  */
 export type NoSchemas = [NoTablesSchema, NoValuesSchema];
 
+/**
+ * The Content type describes both the Tables and Values in a Store.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * [Tables, Values];
+ * ```
+ *
+ * It is an array of two objects, representing tabular and keyed value content.
+ * @example
+ * The following is a valid Content array:
+ * ```json
+ * [
+ *   {
+ *     "pets": {
+ *       "fido": {
+ *         "sold": false,
+ *         "price": 4,
+ *       },
+ *       "felix": {
+ *         "sold": true,
+ *         "price": 5,
+ *       },
+ *     },
+ *   },
+ *   {
+ *     open: true,
+ *     employees: 3,
+ *   },
+ * ]
+ * ```
+ * @category Store
+ * @since v5.0.0
+ */
+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 +828,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 +851,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 +860,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 +879,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 +896,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 +908,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 +929,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 +944,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 +962,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 +977,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 +1000,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 +1016,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 +1042,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 +1058,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 +1080,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 +1109,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 +1139,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 +1151,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 +1179,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 +1200,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 +1216,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 +1240,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 +1256,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 +1293,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 +1311,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 +1337,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 +1354,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 +1384,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 +1401,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 +1428,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 +1460,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 +1493,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 +1505,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 +1544,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 +1587,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 +1599,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 +1648,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 +1665,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 +1677,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 +1698,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 +1713,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 +1731,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 +1746,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 +1769,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 +1785,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 +1818,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 +1861,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 +1887,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 +1905,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 +1927,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 +2107,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 +2196,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,47 +2241,89 @@ export type ChangedValue<
  */
 export type InvalidValues = {[valueId: Id]: any[]};
 
-// TransactionChanges
-export type TransactionChanges<Schemas extends OptionalSchemas> = [
-  {
-    [TableId in TableIdFromSchema<Schemas[0]>]?: {
-      [rowId: Id]:
-        | {
-            [CellId in CellIdFromSchema<Schemas[0], TableId>]?: Cell<
-              Schemas[0],
-              TableId,
-              CellId
-            > | null;
-          }
-        | null;
-    } | null;
-  },
-  {
-    [ValueId in ValueIdFromSchema<Schemas[1]>]?: Value<
-      Schemas[1],
-      ValueId
-    > | null;
-  },
-];
-
 /**
- * The GetTransactionChanges type describes a function that returns the net
- * meaningful changes that were made to a Store during a transaction.
+ * The Changes type describes 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;
+ * [
+ *   changedTables: {
+ *     [tableId: Id]:
+ *       | {[rowId: Id]: {[cellId: Id]: CellOrUndefined} | undefined}
+ *       | undefined;
+ *   },
+ *   changedValues: {[valueId: Id]: ValueOrUndefined},
+ *   isChanges: 1,
+ * ];
  * ```
  *
- * 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.
+ * This contains mostly equivalent information to a TransactionLog, but in a
+ * form that can be more efficiently parsed and serialized (for example in the
+ * case of synchronization between systems).
+ *
+ * It is an array of two objects, representing tabular and keyed value changes.
+ * If the first item is an empty object, it means no tabular changes were made.
+ * If the second item is an empty object, it means no keyed value changes were
+ * made.
+ *
+ * If not empty, the first object has an entry for each Table in a Store that
+ * has had a change within it. If the entry is null, it means that whole Table
+ * was deleted. Otherwise, the entry will be an object with an entry for each
+ * Row in that Table that had a change within it. In turn, if that entry is
+ * null, it means the Row was deleted. Otherwise, the entry will be an object
+ * with an entry for each Cell in that Row that had a change within it. If the
+ * entry is null, the Cell was deleted, otherwise it will contain the new value
+ * the Cell was changed to during the transaction.
+ *
+ * If not empty, the second object has an entry for each Value in a Store that
+ * has had a change. If the entry is null, the Value was deleted, otherwise it
+ * will contain the new Value it was changed to during the transaction.
+ *
+ * A third, required, item in the array is the digit `1`, so that instances of
+ * Content and Changes types can be disambiguated.
+ * @example
+ * The following is a valid Changes array that conveys the following:
+ * ```json
+ * [
+ *   {                     // changes to tabular data in the Store
+ *     "pets": {             // this Table was changed
+ *       "fido": null,         // this Row was deleted
+ *       "felix": {            // this Row was changed
+ *         "sold": true,         // this Cell was changed
+ *         "price": null,        // this Cell was deleted
+ *       },
+ *     },
+ *     "pendingSales": null, // this Table was deleted
+ *   },
+ *   {},                   // no changes to keyed value data in the Store
+ *   1,                    // indicates that this is a Changes array
+ * ]
+ * ```
  * @category Transaction
  * @since v4.0.0
  */
-export type GetTransactionChanges<Schemas extends OptionalSchemas> =
-  () => TransactionChanges<Schemas>;
+export type Changes<Schemas extends OptionalSchemas> = [
+  {
+    [TableId in TableIdFromSchema<Schemas[0]>]?:
+      | {
+          [rowId: Id]:
+            | {
+                [CellId in CellIdFromSchema<
+                  Schemas[0],
+                  TableId
+                >]?: CellOrUndefined<Schemas[0], TableId, CellId>;
+              }
+            | undefined;
+        }
+      | undefined;
+  },
+  {
+    [ValueId in ValueIdFromSchema<Schemas[1]>]?: Value<Schemas[1], ValueId>;
+  },
+  isChanges: 1,
+];
 
 /**
  * The TransactionLog type describes the changes that were made to a Store
@@ -2227,21 +2332,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 +2362,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 +2382,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 +2691,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 +2720,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 +3732,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 +3787,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>): this;
 
   /**
    * The setTables method takes an object and sets the entire tabular data of
@@ -3710,7 +3796,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
@@ -3755,7 +3841,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```
    * @category Setter
    */
-  setTables(tables: Tables<Schemas[0], true>): Store<Schemas>;
+  setTables(tables: Tables<Schemas[0], true>): this;
 
   /**
    * The setTable method takes an object and sets the entire data of a single
@@ -3764,7 +3850,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
@@ -3814,7 +3900,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
   setTable<TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: TableId,
     table: Table<Schemas[0], TableId, true>,
-  ): Store<Schemas>;
+  ): this;
 
   /**
    * The setRow method takes an object and sets the entire data of a single Row
@@ -3823,7 +3909,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
@@ -3873,7 +3959,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     tableId: TableId,
     rowId: Id,
     row: Row<Schemas[0], TableId, true>,
-  ): Store<Schemas>;
+  ): this;
 
   /**
    * The addRow method takes an object and creates a new Row in the Store,
@@ -3953,7 +4039,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
@@ -4005,7 +4091,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     tableId: TableId,
     rowId: Id,
     partialRow: Row<Schemas[0], TableId, true>,
-  ): Store<Schemas>;
+  ): this;
 
   /**
    * The setCell method sets the value of a single Cell in the Store.
@@ -4013,7 +4099,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
@@ -4078,7 +4164,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     cell:
       | Cell<Schemas[0], TableId, CellId>
       | MapCell<Schemas[0], TableId, CellId>,
-  ): Store<Schemas>;
+  ): this;
 
   /**
    * The setValues method takes an object and sets all the Values in the Store.
@@ -4086,7 +4172,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
@@ -4131,7 +4217,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Setter
    * @since v3.0.0
    */
-  setValues(values: Values<Schemas[1], true>): Store<Schemas>;
+  setValues(values: Values<Schemas[1], true>): this;
 
   /**
    * The setPartialValues method takes an object and sets its Values in the
@@ -4140,7 +4226,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
@@ -4186,7 +4272,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Setter
    * @since v3.0.0
    */
-  setPartialValues(partialValues: Values<Schemas[1], true>): Store<Schemas>;
+  setPartialValues(partialValues: Values<Schemas[1], true>): this;
 
   /**
    * The setValue method sets a single keyed Value in the Store.
@@ -4194,7 +4280,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
@@ -4248,34 +4334,35 @@ export interface Store<in out Schemas extends OptionalSchemas> {
   setValue<ValueId extends ValueIdFromSchema<Schemas[1]>>(
     valueId: ValueId,
     value: Value<Schemas[1], ValueId> | MapValue<Schemas[1], ValueId>,
-  ): Store<Schemas>;
+  ): this;
 
   /**
-   * 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,32 +4370,21 @@ 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>): this;
 
   /**
    * The setTablesJson method takes a string serialization of all of the Tables
    * in the Store and attempts to update them to that.
    *
-   * This has schema-based typing. The following is a simplified representation:
-   *
-   * ```ts override
-   * setTablesJson(tablesJson: Json): Store;
-   * ```
-   *
    * If the JSON cannot be parsed, this will fail silently. If it can be parsed,
    * it will then be subject to the same validation rules as the setTables
    * method (according to the Tables type, and matching any TablesSchema
@@ -4337,18 +4413,12 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Setter
    * @since v3.0.0
    */
-  setTablesJson(tablesJson: Json): Store<Schemas>;
+  setTablesJson(tablesJson: Json): this;
 
   /**
    * The setValuesJson method takes a string serialization of all of the Values
    * in the Store and attempts to update them to those values.
    *
-   * This has schema-based typing. The following is a simplified representation:
-   *
-   * ```ts override
-   * setValuesJson(valuesJson: Json): Store;
-   * ```
-   *
    * If the JSON cannot be parsed, this will fail silently. If it can be parsed,
    * it will then be subject to the same validation rules as the setValues
    * method (according to the Values type, and matching any ValuesSchema
@@ -4377,18 +4447,12 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Setter
    * @since v3.0.0
    */
-  setValuesJson(valuesJson: Json): Store<Schemas>;
+  setValuesJson(valuesJson: Json): this;
 
   /**
    * The setJson method takes a string serialization of all of the Tables and
    * Values in the Store and attempts to update them to those values.
    *
-   * This has schema-based typing. The following is a simplified representation:
-   *
-   * ```ts override
-   * setJson(tablesAndValuesJson: Json): Store;
-   * ```
-   *
    * From v3.0 onwards, the serialization should be of an array with two
    * entries. The first is the Tables object, the second the Values. In previous
    * versions (before the existence of the Values data structure), it was a sole
@@ -4441,7 +4505,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```
    * @category Setter
    */
-  setJson(tablesAndValuesJson: Json): Store<Schemas>;
+  setJson(tablesAndValuesJson: Json): this;
 
   /**
    * The setTablesSchema method lets you specify the TablesSchema of the tabular
@@ -4450,7 +4514,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 +4554,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 +4591,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
@@ -4600,12 +4664,6 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @example
    * This example removes the data of a Store.
    *
-   * This has schema-based typing. The following is a simplified representation:
-   *
-   * ```ts override
-   * delTables(): Store;
-   * ```
-   *
    * ```js
    * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
    *
@@ -4615,7 +4673,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```
    * @category Deleter
    */
-  delTables(): Store<Schemas>;
+  delTables(): this;
 
   /**
    * The delTable method lets you remove a single Table from the Store.
@@ -4627,7 +4685,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
@@ -4642,7 +4700,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```
    * @category Deleter
    */
-  delTable(tableId: TableIdFromSchema<Schemas[0]>): Store<Schemas>;
+  delTable(tableId: TableIdFromSchema<Schemas[0]>): this;
 
   /**
    * The delRow method lets you remove a single Row from a Table.
@@ -4650,7 +4708,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.
@@ -4671,7 +4729,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```
    * @category Deleter
    */
-  delRow(tableId: TableIdFromSchema<Schemas[0]>, rowId: Id): Store<Schemas>;
+  delRow(tableId: TableIdFromSchema<Schemas[0]>, rowId: Id): this;
 
   /**
    * The delCell method lets you remove a single Cell from a Row.
@@ -4679,7 +4737,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
@@ -4765,17 +4823,11 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     rowId: Id,
     cellId: CellIdFromSchema<Schemas[0], TableId>,
     forceDel?: boolean,
-  ): Store<Schemas>;
+  ): this;
 
   /**
    * The delValues method lets you remove all the Values from a Store.
    *
-   * This has schema-based typing. The following is a simplified representation:
-   *
-   * ```ts override
-   * delValues(): Store;
-   * ```
-   *
    * If there is a ValuesSchema applied to the Store and it specifies a default
    * value for any Value Id, then deletion will result in it being set back to
    * its default value.
@@ -4809,7 +4861,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Deleter
    * @since v3.0.0
    */
-  delValues(): Store<Schemas>;
+  delValues(): this;
 
   /**
    * The delValue method lets you remove a single Value from a Store.
@@ -4817,7 +4869,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
@@ -4854,7 +4906,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Deleter
    * @since v3.0.0
    */
-  delValue(valueId: ValueIdFromSchema<Schemas[1]>): Store<Schemas>;
+  delValue(valueId: ValueIdFromSchema<Schemas[1]>): this;
 
   /**
    * The delTablesSchema method lets you remove the TablesSchema of the Store.
@@ -4865,7 +4917,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 +4943,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 +4968,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 +5023,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 +5099,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);
@@ -5085,12 +5134,6 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * relevant listeners until it completes when you call the finishTransaction
    * method.
    *
-   * This has schema-based typing. The following is a simplified representation:
-   *
-   * ```ts override
-   * startTransaction(): Store;
-   * ```
-   *
    * Transactions are useful for making bulk changes to the data in a Store, and
    * when you don't want listeners to be called as you make each change. Changes
    * are made silently during the transaction, and listeners relevant to the
@@ -5133,7 +5176,94 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Transaction
    * @since v1.3.0
    */
-  startTransaction(): Store<Schemas>;
+  startTransaction(): this;
+
+  /**
+   * 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
@@ -5143,7 +5273,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 +5342,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);
@@ -5236,7 +5366,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Transaction
    * @since v1.3.0
    */
-  finishTransaction(doRollback?: DoRollback<Schemas>): Store<Schemas>;
+  finishTransaction(doRollback?: DoRollback<Schemas>): this;
 
   /**
    * The forEachTable method takes a function that it will then call for each
@@ -5432,7 +5562,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 +5627,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 +5638,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 +5698,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 +5710,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 +5770,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * @category Listener
    */
   addTableIdsListener(
-    listener: TableIdsListener<Schemas>,
+    listener: TableIdsListener<Schemas, this>,
     mutator?: boolean,
   ): Id;
 
@@ -5647,7 +5783,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addHasTableListener(
    *   tableId: IdOrNull,
-   *   listener: HasTableListener,
+   *   listener: HasTableListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -5747,7 +5883,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 +5896,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addTableListener(
    *   tableId: IdOrNull,
-   *   listener: TableListener,
+   *   listener: TableListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -5853,7 +5989,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 +6003,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addTableCellIdsListener(
    *   tableId: IdOrNull,
-   *   listener: TableCellIdsListener,
+   *   listener: TableCellIdsListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -5969,7 +6105,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 +6120,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * addHasTableCellListener(
    *   tableId: IdOrNull,
    *   cellId: IdOrNull,
-   *   listener: HasTableCellListener,
+   *   listener: HasTableCellListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -6106,7 +6242,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 +6255,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addRowCountListener(
    *   tableId: IdOrNull,
-   *   listener: RowCountListener,
+   *   listener: RowCountListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -6211,7 +6347,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 +6360,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addRowIdsListener(
    *   tableId: IdOrNull,
-   *   listener: RowIdsListener,
+   *   listener: RowIdsListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -6312,7 +6448,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 +6466,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 +6699,8 @@ export interface Store<in out Schemas extends OptionalSchemas> {
       CellIdOrUndefined,
       Descending,
       Offset,
-      Limit
+      Limit,
+      this
     >,
     mutator?: boolean,
   ): Id;
@@ -6578,7 +6715,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * addHasRowListener(
    *   tableId: IdOrNull,
    *   rowId: IdOrNull,
-   *   listener: HasRowListener,
+   *   listener: HasRowListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -6695,7 +6832,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 +6846,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * addRowListener(
    *   tableId: IdOrNull,
    *   rowId: IdOrNull,
-   *   listener: RowListener,
+   *   listener: RowListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -6818,7 +6955,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 +6969,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * addCellIdsListener(
    *   tableId: IdOrNull,
    *   rowId: IdOrNull,
-   *   listener: CellIdsListener,
+   *   listener: CellIdsListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -6937,7 +7074,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 +7089,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 +7222,8 @@ export interface Store<in out Schemas extends OptionalSchemas> {
       Schemas,
       TableIdOrNull,
       RowIdOrNull,
-      CellIdOrNull
+      CellIdOrNull,
+      this
     >,
     mutator?: boolean,
   ): Id;
@@ -7101,7 +7239,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 +7363,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 +7381,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 +7444,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 +7455,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 +7512,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 +7524,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 +7585,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 +7598,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addHasValueListener(
    *   valueId: IdOrNull,
-   *   listener: HasValueListener,
+   *   listener: HasValueListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -7542,7 +7692,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 +7705,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addValueListener(
    *   valueId: IdOrNull,
-   *   listener: ValueListener,
+   *   listener: ValueListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -7644,7 +7794,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 +7810,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 +8036,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 +8050,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```ts override
    * addInvalidValueListener(
    *   valueId: IdOrNull,
-   *   listener: InvalidValueListener,
+   *   listener: InvalidValueListener<this>,
    *   mutator?: boolean,
    * ): Id;
    * ```
@@ -8071,7 +8221,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    */
   addInvalidValueListener(
     valueId: IdOrNull,
-    listener: InvalidValueListener<Schemas>,
+    listener: InvalidValueListener<Schemas, this>,
     mutator?: boolean,
   ): Id;
 
@@ -8082,7 +8232,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 +8275,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 +8285,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 +8322,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 +8367,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 +8378,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 +8390,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 +8426,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 +8471,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,18 +8482,14 @@ 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
    * listener to be called, even if the underlying data hasn't changed.
    *
-   * This has schema-based typing. The following is a simplified representation:
-   *
-   * ```ts override
-   * callListener(listenerId: Id): Store;
-   * ```
-   *
    * This is useful when you are using mutator listeners to guarantee that data
    * conforms to programmatic conditions, and those conditions change such that
    * you need to update the Store in bulk.
@@ -8456,18 +8600,12 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```
    * @category Listener
    */
-  callListener(listenerId: Id): Store<Schemas>;
+  callListener(listenerId: Id): this;
 
   /**
    * The delListener method removes a listener that was previously added to the
    * Store.
    *
-   * This has schema-based typing. The following is a simplified representation:
-   *
-   * ```ts override
-   * delListener(listenerId: Id): Store;
-   * ```
-   *
    * Use the Id returned by whichever method was used to add the listener. Note
    * that the Store may re-use this Id for future listeners added to it.
    * @param listenerId The Id of the listener to remove.
@@ -8494,7 +8632,7 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * ```
    * @category Listener
    */
-  delListener(listenerId: Id): Store<Schemas>;
+  delListener(listenerId: Id): this;
 
   /**
    * The getListenerStats method provides a set of statistics about the