tinybase 8.0.0-beta.1 → 8.0.0-beta.3

package/@types/_internal/store/with-schemas/index.d.ts

@@ -48,7 +48,7 @@ export type CellIsDefaultedFromSchema<
   Then,
   Else,
 > = Schema[TableId][CellId] extends {
-  default: string | number | boolean;
+  default: infer _;
 }
   ? Then
   : Else;
@@ -83,7 +83,7 @@ export type ValueIsDefaultedFromSchema<
   Then,
   Else,
 > = Schema[ValueId] extends {
-  default: string | number | boolean;
+  default: infer _;
 }
   ? Then
   : Else;

package/@types/common/index.d.ts

@@ -16,6 +16,28 @@ import type {CellOrUndefined, ValueOrUndefined} from '../store/index.d.ts';
  */
 export type Json = string;
 
+/**
+ * The AnyObject type is a simple alias for a plain object with string keys and
+ * unknown values.
+ *
+ * It is used to indicate that the value should be considered to be a plain
+ * JavaScript object, as can be stored in a Cell or Value with the `object`
+ * schema type.
+ * @category General
+ * @since v8.0.0
+ */
+export type AnyObject = {[key: string]: unknown};
+
+/**
+ * The AnyArray type is a simple alias for an array with unknown values.
+ *
+ * It is used to indicate that the value should be considered to be a JavaScript
+ * array, as can be stored in a Cell or Value with the `array` schema type.
+ * @category General
+ * @since v8.0.0
+ */
+export type AnyArray = unknown[] | readonly unknown[];
+
 /**
  * The Ids type is a simple alias for an array of strings, but is used to
  * indicate that the strings should be considered to be the keys of objects

package/@types/common/with-schemas/index.d.ts

@@ -28,6 +28,28 @@ import type {
  */
 export type Json = string;
 
+/**
+ * The AnyObject type is a simple alias for a plain object with string keys and
+ * unknown values.
+ *
+ * It is used to indicate that the value should be considered to be a plain
+ * JavaScript object, as can be stored in a Cell or Value with the `object`
+ * schema type.
+ * @category General
+ * @since v8.0.0
+ */
+export type AnyObject = {[key: string]: unknown};
+
+/**
+ * The AnyArray type is a simple alias for an array with unknown values.
+ *
+ * It is used to indicate that the value should be considered to be a JavaScript
+ * array, as can be stored in a Cell or Value with the `array` schema type.
+ * @category General
+ * @since v8.0.0
+ */
+export type AnyArray = unknown[] | readonly unknown[];
+
 /**
  * The Ids type is a simple alias for an array of strings, but is used to
  * indicate that the strings should be considered to be the keys of objects

package/@types/middleware/index.d.ts

@@ -28,17 +28,17 @@ import type {
  * The WillSetContentCallback type describes a function that is called before
  * Content is set in the Store.
  *
- * The callback receives the Content (a [Tables, Values] tuple) that is about
- * to be set. It can return the Content (possibly transformed) to allow the
- * write, or `undefined` to prevent the Content from being set.
+ * The callback receives the Content (a [Tables, Values] tuple) that is about to
+ * be set. It can return the Content (possibly transformed) to allow the write,
+ * or `undefined` to prevent the Content from being set.
  *
  * Multiple WillSetContentCallback functions can be registered and they will be
  * called sequentially, the Content being updated successively. If any callback
  * returns `undefined`, the chain short-circuits and the Content will not be
  * set.
  * @param content The Content about to be set.
- * @returns The Content to use (possibly transformed), or `undefined` to
- * prevent the write.
+ * @returns The Content to use (possibly transformed), or `undefined` to prevent
+ * the write.
  * @category Callback
  * @since v8.0.0
  */
@@ -54,8 +54,7 @@ export type WillSetContentCallback = (content: Content) => Content | undefined;
  *
  * Multiple WillSetTablesCallback functions can be registered and they will be
  * called sequentially, the Tables being updated successively. If any callback
- * returns `undefined`, the chain short-circuits and the Tables will not be
- * set.
+ * returns `undefined`, the chain short-circuits and the Tables will not be set.
  * @param tables The Tables object about to be set.
  * @returns The Tables to use (possibly transformed), or `undefined` to prevent
  * the write.
@@ -216,11 +215,11 @@ export type WillDelTablesCallback = () => boolean;
 export type WillDelTableCallback = (tableId: Id) => boolean;
 
 /**
- * The WillDelRowCallback type describes a function that is called before a
- * Row is deleted from the Store.
+ * The WillDelRowCallback type describes a function that is called before a Row
+ * is deleted from the Store.
  *
- * The callback receives the table Id and row Id of the Row about to be
- * deleted. It returns `true` to allow the deletion, or `false` to prevent it.
+ * The callback receives the table Id and row Id of the Row about to be deleted.
+ * It returns `true` to allow the deletion, or `false` to prevent it.
  *
  * Multiple WillDelRowCallback functions can be registered and they will be
  * called sequentially. If any callback returns `false`, the chain
@@ -303,8 +302,8 @@ export type WillDelValueCallback = (valueId: Id) => boolean;
  * callback returns `undefined`, the chain short-circuits and the Changes will
  * not be applied.
  * @param changes The Changes about to be applied.
- * @returns The Changes to use (possibly transformed), or `undefined` to
- * prevent the write.
+ * @returns The Changes to use (possibly transformed), or `undefined` to prevent
+ * the write.
  * @category Callback
  * @since v8.0.0
  */
@@ -312,6 +311,49 @@ export type WillApplyChangesCallback = (
   changes: Changes,
 ) => Changes | undefined;
 
+/**
+ * The DidSetRowCallback type describes a function called after a Row is changed
+ * during a transaction, and after mutator listeners have fired.
+ *
+ * Unlike the `willSet*` callbacks, which intercept writes as they happen,
+ * `didSetRow` fires once per touched Row after all cell writes in the
+ * transaction have completed. This means multiple cell changes to the same Row
+ * within a single transaction result in just one `didSetRow` call, with the
+ * full before-transaction and after-transaction Row states.
+ *
+ * The callback receives the Table Id, Row Id, the Row as it was at the start of
+ * the transaction (`oldRow`), and the Row as it is now (`newRow`). It must
+ * return a Row:
+ *
+ * - `newRow` to accept the changes.
+ * - a different `Row` to replace the final state.
+ * - `oldRow` to revert all changes to the Row.
+ * - an empty object to delete the Row.
+ *
+ * Multiple DidSetRowCallback functions can be registered for the same table and
+ * they will be called sequentially, each receiving the Row returned by the
+ * previous callback. The chain never short-circuits: all registered callbacks
+ * always run.
+ *
+ * Note that `addDidSetRowCallback` is table-scoped: you must specify the table
+ * Id when registering. Callbacks are only invoked for rows in the specified
+ * table, keeping overhead to zero for other tables.
+ * @param tableId The Id of the Table containing the changed Row.
+ * @param rowId The Id of the Row that was changed.
+ * @param oldRow The Row as it was at the start of the transaction.
+ * @param newRow The Row as it is now, after all cell writes including those
+ * made by mutating listeners.
+ * @returns The Row to use as the final state.
+ * @category Callback
+ * @since v8.0.0
+ */
+export type DidSetRowCallback = (
+  tableId: Id,
+  rowId: Id,
+  oldRow: Row,
+  newRow: Row,
+) => Row;
+
 /**
  * A Middleware object lets you intercept and validate writes to a Store.
  *
@@ -360,14 +402,13 @@ export interface Middleware {
   getStore(): Store;
 
   /**
-   * The addWillSetContentCallback method registers a
-   * WillSetContentCallback that will be called before Content is set in the
-   * Store.
+   * The addWillSetContentCallback method registers a WillSetContentCallback
+   * that will be called before Content is set in the Store.
    *
-   * The callback can transform the Content or return `undefined` to prevent
-   * the write. Multiple callbacks can be registered and they are called
-   * sequentially, each receiving the (possibly transformed) Content from
-   * the previous callback.
+   * The callback can transform the Content or return `undefined` to prevent the
+   * write. Multiple callbacks can be registered and they are called
+   * sequentially, each receiving the (possibly transformed) Content from the
+   * previous callback.
    * @param callback The WillSetContentCallback to register.
    * @returns A reference to the Middleware object, for chaining.
    * @example
@@ -756,9 +797,9 @@ export interface Middleware {
    * The addWillDelTablesCallback method registers a WillDelTablesCallback that
    * will be called before all Tables are deleted from the Store.
    *
-   * The callback returns `true` to allow the deletion or `false` to prevent
-   * it. Multiple callbacks can be registered and they are called sequentially.
-   * If any callback returns `false`, the deletion is prevented.
+   * The callback returns `true` to allow the deletion or `false` to prevent it.
+   * Multiple callbacks can be registered and they are called sequentially. If
+   * any callback returns `false`, the deletion is prevented.
    * @param callback The WillDelTablesCallback to register.
    * @returns A reference to the Middleware object, for chaining.
    * @example
@@ -790,9 +831,9 @@ export interface Middleware {
    * The addWillDelTableCallback method registers a WillDelTableCallback that
    * will be called before any Table is deleted from the Store.
    *
-   * The callback returns `true` to allow the deletion or `false` to prevent
-   * it. Multiple callbacks can be registered and they are called sequentially.
-   * If any callback returns `false`, the deletion is prevented.
+   * The callback returns `true` to allow the deletion or `false` to prevent it.
+   * Multiple callbacks can be registered and they are called sequentially. If
+   * any callback returns `false`, the deletion is prevented.
    * @param callback The WillDelTableCallback to register.
    * @returns A reference to the Middleware object, for chaining.
    * @example
@@ -957,9 +998,9 @@ export interface Middleware {
   addWillDelValueCallback(callback: WillDelValueCallback): Middleware;
 
   /**
-   * The addWillApplyChangesCallback method registers a
-   * WillApplyChangesCallback that will be called before Changes are applied to
-   * the Store via the applyChanges method.
+   * The addWillApplyChangesCallback method registers a WillApplyChangesCallback
+   * that will be called before Changes are applied to the Store via the
+   * applyChanges method.
    *
    * This callback receives the Changes object and can return it (to allow),
    * return a modified Changes object (to transform), or return `undefined` (to
@@ -1003,6 +1044,87 @@ export interface Middleware {
    */
   addWillApplyChangesCallback(callback: WillApplyChangesCallback): Middleware;
 
+  /**
+   * The addDidSetRowCallback method registers a DidSetRowCallback for a
+   * specific table that will be called after any Row in that table is changed
+   * during a transaction, after mutator listeners have fired.
+   *
+   * Unlike `willSetRow`, which fires synchronously during each write, this
+   * callback fires once per changed Row after all cell writes in the
+   * transaction have landed. Multiple cell changes to the same Row within a
+   * transaction produce a single callback with the full before/after Row
+   * states.
+   *
+   * The callback receives `oldRow` (the Row at the start of the transaction)
+   * and `newRow` (the Row after all writes). Return `newRow` to accept, a
+   * different `Row` to replace, `oldRow` to revert, or an empty object to
+   * delete.
+   * @param tableId The Id of the Table to watch.
+   * @param callback The DidSetRowCallback to register.
+   * @returns A reference to the Middleware object, for chaining.
+   * @example
+   * This example registers a callback that validates the 'pets' table,
+   * reverting any row that ends up without a required 'species' cell.
+   *
+   * ```js
+   * import {createMiddleware, createStore} from 'tinybase';
+   *
+   * const store = createStore();
+   * const middleware = createMiddleware(store);
+   *
+   * middleware.addDidSetRowCallback(
+   *   'pets',
+   *   (_tableId, _rowId, oldRow, newRow) =>
+   *     'species' in newRow ? newRow : oldRow,
+   * );
+   *
+   * store.setRow('pets', 'fido', {species: 'dog', name: 'Fido'});
+   * console.log(store.getRow('pets', 'fido'));
+   * // -> {species: 'dog', name: 'Fido'}
+   *
+   * store.setRow('pets', 'nemo', {name: 'Nemo'});
+   * console.log(store.getRow('pets', 'nemo'));
+   * // -> {}
+   *
+   * middleware.destroy();
+   * ```
+   * @example
+   * This example shows that multiple cell changes in one transaction result in
+   * a single didSetRow callback with the full before/after row states.
+   *
+   * ```js
+   * import {createMiddleware, createStore} from 'tinybase';
+   *
+   * const store = createStore();
+   * const middleware = createMiddleware(store);
+   *
+   * const seen = [];
+   * middleware.addDidSetRowCallback(
+   *   'pets',
+   *   (_tableId, rowId, oldRow, newRow) => {
+   *     seen.push({rowId, oldRow: {...oldRow}, newRow: {...newRow}});
+   *     return newRow;
+   *   },
+   * );
+   *
+   * store.transaction(() => {
+   *   store.setCell('pets', 'fido', 'name', 'Fido');
+   *   store.setCell('pets', 'fido', 'species', 'dog');
+   * });
+   * console.log(seen.length);
+   * // -> 1
+   * console.log(seen[0].rowId);
+   * // -> 'fido'
+   * console.log(seen[0].newRow);
+   * // -> {name: 'Fido', species: 'dog'}
+   *
+   * middleware.destroy();
+   * ```
+   * @category Configuration
+   * @since v8.0.0
+   */
+  addDidSetRowCallback(tableId: Id, callback: DidSetRowCallback): Middleware;
+
   /**
    * The destroy method should be called when this Middleware object is no
    * longer used. It removes all hooks and listeners from the Store, and

package/@types/middleware/with-schemas/index.d.ts

@@ -40,17 +40,17 @@ import type {
  * (content: Content) => Content | undefined;
  * ```
  *
- * The callback receives the Content (a [Tables, Values] tuple) that is about
- * to be set. It can return the Content (possibly transformed) to allow the
- * write, or `undefined` to prevent the Content from being set.
+ * The callback receives the Content (a [Tables, Values] tuple) that is about to
+ * be set. It can return the Content (possibly transformed) to allow the write,
+ * or `undefined` to prevent the Content from being set.
  *
  * Multiple WillSetContentCallback functions can be registered and they will be
  * called sequentially, the Content being updated successively. If any callback
  * returns `undefined`, the chain short-circuits and the Content will not be
  * set.
  * @param content The Content about to be set.
- * @returns The Content to use (possibly transformed), or `undefined` to
- * prevent the write.
+ * @returns The Content to use (possibly transformed), or `undefined` to prevent
+ * the write.
  * @category Callback
  * @since v8.0.0
  */
@@ -74,8 +74,7 @@ export type WillSetContentCallback<Schemas extends OptionalSchemas> = (
  *
  * Multiple WillSetTablesCallback functions can be registered and they will be
  * called sequentially, the Tables being updated successively. If any callback
- * returns `undefined`, the chain short-circuits and the Tables will not be
- * set.
+ * returns `undefined`, the chain short-circuits and the Tables will not be set.
  * @param tables The Tables object about to be set.
  * @returns The Tables to use (possibly transformed), or `undefined` to prevent
  * the write.
@@ -328,8 +327,8 @@ export type WillDelTableCallback<
 > = (...params: Params | [tableId: never]) => boolean;
 
 /**
- * The WillDelRowCallback type describes a function that is called before a
- * Row is deleted from the Store.
+ * The WillDelRowCallback type describes a function that is called before a Row
+ * is deleted from the Store.
  *
  * This has schema-based typing. The following is a simplified representation:
  *
@@ -337,8 +336,8 @@ export type WillDelTableCallback<
  * (tableId: Id, rowId: Id) => boolean;
  * ```
  *
- * The callback receives the table Id and row Id of the Row about to be
- * deleted. It returns `true` to allow the deletion, or `false` to prevent it.
+ * The callback receives the table Id and row Id of the Row about to be deleted.
+ * It returns `true` to allow the deletion, or `false` to prevent it.
  *
  * Multiple WillDelRowCallback functions can be registered and they will be
  * called sequentially. If any callback returns `false`, the chain
@@ -468,8 +467,8 @@ export type WillDelValueCallback<
  * callback returns `undefined`, the chain short-circuits and the Changes will
  * not be applied.
  * @param changes The Changes about to be applied.
- * @returns The Changes to use (possibly transformed), or `undefined` to
- * prevent the write.
+ * @returns The Changes to use (possibly transformed), or `undefined` to prevent
+ * the write.
  * @category Callback
  * @since v8.0.0
  */
@@ -477,6 +476,63 @@ export type WillApplyChangesCallback<Schemas extends OptionalSchemas> = (
   changes: Changes<Schemas>,
 ) => Changes<Schemas> | undefined;
 
+/**
+ * The DidSetRowCallback type describes a function called after a Row is changed
+ * during a transaction, and after mutator listeners have fired.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   tableId: Id,
+ *   rowId: Id,
+ *   oldRow: Row,
+ *   newRow: Row,
+ * ) => Row;
+ * ```
+ *
+ * Unlike the `willSet*` callbacks, which intercept writes as they happen,
+ * `didSetRow` fires once per touched Row after all cell writes in the
+ * transaction have completed. This means multiple cell changes to the same Row
+ * within a single transaction result in just one `didSetRow` call, with the
+ * full before-transaction and after-transaction Row states.
+ *
+ * The callback receives the Table Id, Row Id, the Row as it was at the start of
+ * the transaction (`oldRow`), and the Row as it is now (`newRow`). It must
+ * return a Row:
+ *
+ * - `newRow` to accept the changes.
+ * - a different `Row` to replace the final state.
+ * - `oldRow` to revert all changes to the Row.
+ * - an empty object to delete the Row.
+ *
+ * Multiple DidSetRowCallback functions can be registered for the same table and
+ * they will be called sequentially, each receiving the Row returned by the
+ * previous callback. The chain never short-circuits: all registered callbacks
+ * always run.
+ *
+ * Note that `addDidSetRowCallback` is table-scoped: you must specify the table
+ * Id when registering. Callbacks are only invoked for rows in the specified
+ * table, keeping overhead to zero for other tables.
+ * @param tableId The Id of the Table containing the changed Row.
+ * @param rowId The Id of the Row that was changed.
+ * @param oldRow The Row as it was at the start of the transaction.
+ * @param newRow The Row as it is now, after all cell writes including those
+ * made by mutating listeners.
+ * @returns The Row to use as the final state.
+ * @category Callback
+ * @since v8.0.0
+ */
+export type DidSetRowCallback<
+  Schema extends OptionalTablesSchema,
+  TableId extends TableIdFromSchema<Schema>,
+> = (
+  tableId: TableId,
+  rowId: Id,
+  oldRow: Row<Schema, TableId>,
+  newRow: Row<Schema, TableId>,
+) => Row<Schema, TableId>;
+
 /**
  * A Middleware object lets you intercept and validate writes to a Store.
  *
@@ -531,9 +587,8 @@ export interface Middleware<in out Schemas extends OptionalSchemas> {
   getStore(): Store<Schemas>;
 
   /**
-   * The addWillSetContentCallback method registers a
-   * WillSetContentCallback that will be called before Content is set in the
-   * Store.
+   * The addWillSetContentCallback method registers a WillSetContentCallback
+   * that will be called before Content is set in the Store.
    *
    * This has schema-based typing. The following is a simplified representation:
    *
@@ -541,10 +596,10 @@ export interface Middleware<in out Schemas extends OptionalSchemas> {
    * addWillSetContentCallback(callback: WillSetContentCallback): Middleware;
    * ```
    *
-   * The callback can transform the Content or return `undefined` to prevent
-   * the write. Multiple callbacks can be registered and they are called
-   * sequentially, each receiving the (possibly transformed) Content from
-   * the previous callback.
+   * The callback can transform the Content or return `undefined` to prevent the
+   * write. Multiple callbacks can be registered and they are called
+   * sequentially, each receiving the (possibly transformed) Content from the
+   * previous callback.
    * @param callback The WillSetContentCallback to register.
    * @returns A reference to the Middleware object, for chaining.
    * @example
@@ -989,9 +1044,9 @@ export interface Middleware<in out Schemas extends OptionalSchemas> {
    * addWillDelTablesCallback(callback: WillDelTablesCallback): Middleware;
    * ```
    *
-   * The callback returns `true` to allow the deletion or `false` to prevent
-   * it. Multiple callbacks can be registered and they are called sequentially.
-   * If any callback returns `false`, the deletion is prevented.
+   * The callback returns `true` to allow the deletion or `false` to prevent it.
+   * Multiple callbacks can be registered and they are called sequentially. If
+   * any callback returns `false`, the deletion is prevented.
    * @param callback The WillDelTablesCallback to register.
    * @returns A reference to the Middleware object, for chaining.
    * @example
@@ -1031,9 +1086,9 @@ export interface Middleware<in out Schemas extends OptionalSchemas> {
    * addWillDelTableCallback(callback: WillDelTableCallback): Middleware;
    * ```
    *
-   * The callback returns `true` to allow the deletion or `false` to prevent
-   * it. Multiple callbacks can be registered and they are called sequentially.
-   * If any callback returns `false`, the deletion is prevented.
+   * The callback returns `true` to allow the deletion or `false` to prevent it.
+   * Multiple callbacks can be registered and they are called sequentially. If
+   * any callback returns `false`, the deletion is prevented.
    * @param callback The WillDelTableCallback to register.
    * @returns A reference to the Middleware object, for chaining.
    * @example
@@ -1232,9 +1287,9 @@ export interface Middleware<in out Schemas extends OptionalSchemas> {
   ): Middleware<Schemas>;
 
   /**
-   * The addWillApplyChangesCallback method registers a
-   * WillApplyChangesCallback that will be called before Changes are applied to
-   * the Store via the applyChanges method.
+   * The addWillApplyChangesCallback method registers a WillApplyChangesCallback
+   * that will be called before Changes are applied to the Store via the
+   * applyChanges method.
    *
    * This has schema-based typing. The following is a simplified representation:
    *
@@ -1286,6 +1341,96 @@ export interface Middleware<in out Schemas extends OptionalSchemas> {
     callback: WillApplyChangesCallback<Schemas>,
   ): Middleware<Schemas>;
 
+  /**
+   * The addDidSetRowCallback method registers a DidSetRowCallback for a
+   * specific table that will be called after any Row in that table is changed
+   * during a transaction, after mutator listeners have fired.
+   *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addDidSetRowCallback(tableId: Id, callback: DidSetRowCallback): Middleware;
+   * ```
+   *
+   * Unlike `willSetRow`, which fires synchronously during each write, this
+   * callback fires once per changed Row after all cell writes in the
+   * transaction have landed. Multiple cell changes to the same Row within a
+   * transaction produce a single callback with the full before/after Row
+   * states.
+   *
+   * The callback receives `oldRow` (the Row at the start of the transaction)
+   * and `newRow` (the Row after all writes). Return `newRow` to accept, a
+   * different `Row` to replace, `oldRow` to revert, or an empty object to
+   * delete.
+   * @param tableId The Id of the Table to watch.
+   * @param callback The DidSetRowCallback to register.
+   * @returns A reference to the Middleware object, for chaining.
+   * @example
+   * This example registers a callback that validates the 'pets' table,
+   * reverting any row that ends up without a required 'species' cell.
+   *
+   * ```js
+   * import {createMiddleware, createStore} from 'tinybase';
+   *
+   * const store = createStore();
+   * const middleware = createMiddleware(store);
+   *
+   * middleware.addDidSetRowCallback(
+   *   'pets',
+   *   (_tableId, _rowId, oldRow, newRow) =>
+   *     'species' in newRow ? newRow : oldRow,
+   * );
+   *
+   * store.setRow('pets', 'fido', {species: 'dog', name: 'Fido'});
+   * console.log(store.getRow('pets', 'fido'));
+   * // -> {species: 'dog', name: 'Fido'}
+   *
+   * store.setRow('pets', 'nemo', {name: 'Nemo'});
+   * console.log(store.getRow('pets', 'nemo'));
+   * // -> {}
+   *
+   * middleware.destroy();
+   * ```
+   * @example
+   * This example shows that multiple cell changes in one transaction result in
+   * a single didSetRow callback with the full before/after row states.
+   *
+   * ```js
+   * import {createMiddleware, createStore} from 'tinybase';
+   *
+   * const store = createStore();
+   * const middleware = createMiddleware(store);
+   *
+   * const seen = [];
+   * middleware.addDidSetRowCallback(
+   *   'pets',
+   *   (_tableId, rowId, oldRow, newRow) => {
+   *     seen.push({rowId, oldRow: {...oldRow}, newRow: {...newRow}});
+   *     return newRow;
+   *   },
+   * );
+   *
+   * store.transaction(() => {
+   *   store.setCell('pets', 'fido', 'name', 'Fido');
+   *   store.setCell('pets', 'fido', 'species', 'dog');
+   * });
+   * console.log(seen.length);
+   * // -> 1
+   * console.log(seen[0].rowId);
+   * // -> 'fido'
+   * console.log(seen[0].newRow);
+   * // -> {name: 'Fido', species: 'dog'}
+   *
+   * middleware.destroy();
+   * ```
+   * @category Configuration
+   * @since v8.0.0
+   */
+  addDidSetRowCallback<TableId extends TableIdFromSchema<Schemas[0]>>(
+    tableId: TableId,
+    callback: DidSetRowCallback<Schemas[0], TableId>,
+  ): Middleware<Schemas>;
+
   /**
    * The destroy method should be called when this Middleware object is no
    * longer used. It removes all hooks and listeners from the Store, and