tinybase 4.3.23 → 4.4.0-beta.1

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

@@ -846,9 +846,35 @@ export type TransactionListener<Schemas extends OptionalSchemas> = (
   getTransactionLog: GetTransactionLog<Schemas>,
 ) => void;
 
+/**
+ * The HasTablesListener type describes a function that is used to listen to
+ * Tables as a whole being added to or removed from the Store.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (store: Store, hasTables: boolean) => void;
+ * ```
+ *
+ * A HasTablesListener is provided when using the addHasTablesListener method.
+ * See that method for specific examples.
+ *
+ * When called, a HasTablesListener is given a reference to the Store. It is
+ * also given a flag to indicate whether Tables now exist (having not done
+ * previously), or do not (having done so previously).
+ * @param store A reference to the Store that changed.
+ * @param hasTables Whether Tables now exist or not.
+ * @category Listener
+ * @since v4.4.0
+ */
+export type HasTablesListener<Schemas extends OptionalSchemas> = (
+  store: Store<Schemas>,
+  hasTables: boolean,
+) => void;
+
 /**
  * The TablesListener type describes a function that is used to listen to
- * changes to the whole Store.
+ * changes to the tabular part of the Store.
  *
  * This has schema-based typing. The following is a simplified representation:
  *
@@ -909,6 +935,44 @@ export type TableIdsListener<Schemas extends OptionalSchemas> = (
   getIdChanges: GetIdChanges<TableIdFromSchema<Schemas[0]>> | undefined,
 ) => void;
 
+/**
+ * The HasTableListener type describes a function that is used to listen to a
+ * Table being added to or removed from the Store.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   store: Store,
+ *   tableId: Id,
+ *   hasTable: boolean,
+ * ) => void;
+ * ```
+ *
+ * A HasTableListener is provided when using the addHasTableListener method. See
+ * that method for specific examples.
+ *
+ * When called, a HasTableListener is given a reference to the Store, and the Id
+ * of the Table that changed. It is also given a flag to indicate whether the
+ * Table now exists (having not done previously), or does not (having done so
+ * previously).
+ * @param store A reference to the Store that changed.
+ * @param tableId The Id of the Table that changed.
+ * @param hasTable Whether the Table now exists or not.
+ * @category Listener
+ * @since v4.4.0
+ */
+export type HasTableListener<
+  Schemas extends OptionalSchemas,
+  TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+> = (
+  store: Store<Schemas>,
+  tableId: TableIdOrNull extends null
+    ? TableIdFromSchema<Schemas[0]>
+    : TableIdOrNull,
+  hasTable: boolean,
+) => void;
+
 /**
  * The TableListener type describes a function that is used to listen to changes
  * to a Table.
@@ -1000,6 +1064,75 @@ export type TableCellIdsListener<
   : // | ((...params: Params1) => void)
     never;
 
+/**
+ * The HasTableCellListener type describes a function that is used to listen to
+ * a Cell being added to or removed from a Table as a whole.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   store: Store,
+ *   tableId: Id,
+ *   cellId: Id,
+ *   hasTableCell: boolean,
+ * ) => void;
+ * ```
+ *
+ * A HasTableCellListener is provided when using the addHasTableCellListener
+ * method. See that method for specific examples.
+ *
+ * When called, a HasTableCellListener is given a reference to the Store, the Id
+ * of the Table that changed, and the Id of the Cell that changed. It is also
+ * given a flag to indicate whether the Cell now exists anywhere in the Table
+ * (having not done previously), or does not (having done so previously).
+ * @param store A reference to the Store that changed.
+ * @param tableId The Id of the Table that changed.
+ * @param cellId The Id of the Table Cell that changed.
+ * @param hasTableCell Whether the Cell now exists anywhere in the Table or not.
+ * @category Listener
+ * @since v4.4.0
+ */
+export type HasTableCellListener<
+  Schemas extends OptionalSchemas,
+  TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+  CellIdOrNull extends
+    | (TableIdOrNull extends TableIdFromSchema<Schemas[0]>
+        ? CellIdFromSchema<Schemas[0], TableIdOrNull>
+        : AllCellIdFromSchema<Schemas[0]>)
+    | null,
+  Params extends any[] = (
+    TableIdOrNull extends null ? TableIdFromSchema<Schemas[0]> : TableIdOrNull
+  ) extends infer TableId
+    ? TableId extends TableIdFromSchema<Schemas[0]>
+      ? (
+          CellIdOrNull extends null
+            ? CellIdFromSchema<Schemas[0], TableId>
+            : CellIdOrNull
+        ) extends infer CellId
+        ? CellId extends CellIdFromSchema<Schemas[0], TableId>
+          ? [
+              store: Store<Schemas>,
+              tableId: TableId,
+              cellId: CellId,
+              hasTableCell: boolean,
+            ]
+          : never
+        : never
+      : never
+    : never,
+  Params4 extends any[] =
+    | Params
+    | [store: never, tableId: never, cellId: never, hasTableCell: never],
+  Params3 extends any[] = Truncate<Params4>,
+  //  Params2 extends any[] = Truncate<Params3>,
+  // Params1 extends any[] = Truncate<Params2>,
+> = Params extends any
+  ? ((...params: Params4) => void) | ((...params: Params3) => void)
+  : // | ((...params: Params2) => void)
+    // | ((...params: Params1) => void)
+    never;
+
 /**
  * The RowCountListener type describes a function that is used to listen to
  * changes to the number of Row objects in a Table.
@@ -1129,6 +1262,48 @@ export type SortedRowIdsListener<
   sortedRowIds: Ids,
 ) => void;
 
+/**
+ * The HasRowListener type describes a function that is used to listen to a Row
+ * being added to or removed from the Store.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   store: Store,
+ *   tableId: Id,
+ *   rowId: Id,
+ *   hasRow: boolean,
+ * ) => void;
+ * ```
+ *
+ * A HasRowListener is provided when using the addHasRowListener method. See
+ * that method for specific examples.
+ *
+ * When called, a HasRowListener is given a reference to the Store, the Id of
+ * the Table that changed, and the Id of the Row that changed. It is also given
+ * a flag to indicate whether the Row now exists (having not done previously),
+ * or does not (having done so previously).
+ * @param store A reference to the Store that changed.
+ * @param tableId The Id of the Table that changed.
+ * @param rowId The Id of the Row that changed.
+ * @param hasRow Whether the Row now exists or not.
+ * @category Listener
+ * @since v4.4.0
+ */
+export type HasRowListener<
+  Schemas extends OptionalSchemas,
+  TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+  RowIdOrNull extends IdOrNull,
+> = (
+  store: Store<Schemas>,
+  tableId: TableIdOrNull extends null
+    ? TableIdFromSchema<Schemas[0]>
+    : TableIdOrNull,
+  rowId: RowIdOrNull extends null ? Id : RowIdOrNull,
+  hasRow: boolean,
+) => void;
+
 /**
  * The RowListener type describes a function that is used to listen to changes
  * to a Row.
@@ -1233,6 +1408,89 @@ export type CellIdsListener<
     // | ((...params: Params1) => void)
     never;
 
+/**
+ * The HasCellListener type describes a function that is used to listen to a
+ * Cell being added to or removed from the Store.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   store: Store,
+ *   tableId: Id,
+ *   rowId: Id,
+ *   cellId: Id,
+ *   hasCell: boolean,
+ * ) => void;
+ * ```
+ *
+ * A HasCellListener is provided when using the addHasCellListener method. See
+ * that method for specific examples.
+ *
+ * When called, a HasCellListener is given a reference to the Store, the Id of
+ * the Table that changed, the Id of the Row that changed, and the Id of Cell
+ * that changed. It is also given a flag to indicate whether the Cell now exists
+ * (having not done previously), or does not (having done so previously).
+ * @param store A reference to the Store that changed.
+ * @param tableId The Id of the Table that changed.
+ * @param rowId The Id of the Row that changed.
+ * @param cellId The Id of the Cell that changed.
+ * @param hasCell Whether the Cell now exists or not.
+ * @category Listener
+ * @since v4.4.0
+ */
+export type HasCellListener<
+  Schemas extends OptionalSchemas,
+  TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+  RowIdOrNull extends IdOrNull,
+  CellIdOrNull extends
+    | (TableIdOrNull extends TableIdFromSchema<Schemas[0]>
+        ? CellIdFromSchema<Schemas[0], TableIdOrNull>
+        : AllCellIdFromSchema<Schemas[0]>)
+    | null,
+  Params extends any[] = (
+    TableIdOrNull extends null ? TableIdFromSchema<Schemas[0]> : TableIdOrNull
+  ) extends infer TableId
+    ? TableId extends TableIdFromSchema<Schemas[0]>
+      ? (
+          CellIdOrNull extends null
+            ? CellIdFromSchema<Schemas[0], TableId>
+            : CellIdOrNull
+        ) extends infer CellId
+        ? CellId extends CellIdFromSchema<Schemas[0], TableId>
+          ? [
+              store: Store<Schemas>,
+              tableId: TableId,
+              rowId: RowIdOrNull extends null ? Id : RowIdOrNull,
+              cellId: CellId,
+              hasCell: boolean,
+            ]
+          : never
+        : never
+      : never
+    : never,
+  Params5 extends any[] =
+    | Params
+    | [
+        store: never,
+        tableId: never,
+        rowId: never,
+        cellId: never,
+        hasCell: boolean,
+      ],
+  Params4 extends any[] = Truncate<Params5>,
+  // Params3 extends any[] = Truncate<Params4>,
+  // Params2 extends any[] = Truncate<Params3>,
+  // Params1 extends any[] = Truncate<Params2>,
+> = Params extends any
+  ? ((...params: Params5) => void) | ((...params: Params4) => void)
+  : // | ((...params: Params3) => void)
+    // | ((...params: Params2) => void)
+    // | ((...params: Params1) => void)
+    // The unions may no longer be discriminatory with fewer parameters, and
+    // TypeScript fails to resolve callback signatures in some cases.
+    never;
+
 /**
  * The CellListener type describes a function that is used to listen to changes
  * to a Cell.
@@ -1336,6 +1594,32 @@ export type CellListener<
     // | ((...params: Params1) => void)
     never;
 
+/**
+ * The HasValuesListener type describes a function that is used to listen to
+ * Values as a whole being added to or removed from the Store.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (store: Store, hasValues: boolean) => void;
+ * ```
+ *
+ * A HasValuesListener is provided when using the addHasValuesListener method.
+ * See that method for specific examples.
+ *
+ * When called, a HasValuesListener is given a reference to the Store. It is
+ * also given a flag to indicate whether Values now exist (having not done
+ * previously), or do not (having done so previously).
+ * @param store A reference to the Store that changed.
+ * @param hasValues Whether Values now exist or not.
+ * @category Listener
+ * @since v4.4.0
+ */
+export type HasValuesListener<Schemas extends OptionalSchemas> = (
+  store: Store<Schemas>,
+  hasValues: boolean,
+) => void;
+
 /**
  * The ValuesListener type describes a function that is used to listen to
  * changes to all the Values in a Store.
@@ -1399,6 +1683,44 @@ export type ValueIdsListener<Schemas extends OptionalSchemas> = (
   getIdChanges: GetIdChanges<ValueIdFromSchema<Schemas[1]>> | undefined,
 ) => void;
 
+/**
+ * The HasValueListener type describes a function that is used to listen to a
+ * Value being added to or removed from the Store.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   store: Store,
+ *   valueId: Id,
+ *   hasValue: boolean,
+ * ) => void;
+ * ```
+ *
+ * A HasValueListener is provided when using the addHasValueListener method. See
+ * that method for specific examples.
+ *
+ * When called, a HasValueListener is given a reference to the Store and the Id
+ * of Value that changed. It is also given a flag to indicate whether the Value
+ * now exists (having not done previously), or does not (having done so
+ * previously).
+ * @param store A reference to the Store that changed.
+ * @param valueId The Id of the Value that changed.
+ * @param hasValue Whether the Value now exists or not.
+ * @category Listener
+ * @since v4.4.0
+ */
+export type HasValueListener<
+  Schemas extends OptionalSchemas,
+  ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null,
+> = (
+  store: Store<Schemas>,
+  valueId: ValueIdOrNull extends null
+    ? ValueIdFromSchema<Schemas[1]>
+    : ValueIdOrNull,
+  hasValue: boolean,
+) => void;
+
 /**
  * The ValueListener type describes a function that is used to listen to changes
  * to a Value.
@@ -1982,6 +2304,11 @@ export type GetTransactionLog<Schemas extends OptionalSchemas> =
  * @category Development
  */
 export type StoreListenerStats = {
+  /**
+   * The number of HasTablesListener functions registered with the Store, since
+   * v4.4.
+   */
+  hasTables?: number;
   /**
    * The number of TablesListener functions registered with the Store.
    */
@@ -1990,6 +2317,11 @@ export type StoreListenerStats = {
    * The number of TableIdsListener functions registered with the Store.
    */
   tableIds?: number;
+  /**
+   * The number of HasTableListener functions registered with the Store, since
+   * v4.4.
+   */
+  hasTable?: number;
   /**
    * The number of TableListener functions registered with the Store.
    */
@@ -1999,6 +2331,11 @@ export type StoreListenerStats = {
    * since v3.3.
    */
   tableCellIds?: number;
+  /**
+   * The number of HasTableCellListener functions registered with the Store,
+   * since v4.4.
+   */
+  hasTableCell?: number;
   /**
    * The number of RowCountListener functions registered with the Store, since
    * v4.1.0
@@ -2012,6 +2349,11 @@ export type StoreListenerStats = {
    * The number of SortedRowIdsListener functions registered with the Store.
    */
   sortedRowIds?: number;
+  /**
+   * The number of HasRowListener functions registered with the Store, since
+   * v4.4.
+   */
+  hasRow?: number;
   /**
    * The number of RowListener functions registered with the Store.
    */
@@ -2020,6 +2362,11 @@ export type StoreListenerStats = {
    * The number of CellIdsListener functions registered with the Store.
    */
   cellIds?: number;
+  /**
+   * The number of HasCellListener functions registered with the Store, since
+   * v4.4.
+   */
+  hasCell?: number;
   /**
    * The number of CellListener functions registered with the Store.
    */
@@ -2028,6 +2375,11 @@ export type StoreListenerStats = {
    * The number of InvalidCellListener functions registered with the Store.
    */
   invalidCell?: number;
+  /**
+   * The number of HasValuesListener functions registered with the Store, since
+   * v4.4.
+   */
+  hasValues?: number;
   /**
    * The number of ValuesListener functions registered with the Store, since
    * v3.0.
@@ -2038,6 +2390,11 @@ export type StoreListenerStats = {
    * v3.0.
    */
   valueIds?: number;
+  /**
+   * The number of HasValueListener functions registered with the Store, since
+   * v4.4.
+   */
+  hasValue?: number;
   /**
    * The number of ValueListener functions registered with the Store, since
    * v3.0.
@@ -2203,6 +2560,10 @@ export type StoreListenerStats = {
  * |Row|hasRow|forEachRow|
  * |Cell|hasCell|forEachCell|
  *
+ * Since v4.3.23, you can add listeners for the change of existence of part of a
+ * Store. For example, the addHasValueListener method lets you listen for a
+ * Value being added or removed.
+ *
  * Finally, the getListenerStats method describes the current state of the
  * Store's listeners for debugging purposes.
  * @example
@@ -5064,18 +5425,20 @@ export interface Store<in out Schemas extends OptionalSchemas> {
   forEachValue(valueCallback: ValueCallback<Schemas[1]>): void;
 
   /**
-   * The addTablesListener method registers a listener function with the Store
-   * that will be called whenever data in the Store changes.
+   * The addHasTablesListener method registers a listener function with the
+   * Store that will be called when Tables as a whole are added to or removed
+   * from the Store.
    *
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * addTablesListener(listener: TablesListener, mutator?: boolean): Id;
+   * addHasTablesListener(listener: HasTablesListener, mutator?: boolean): Id;
    * ```
    *
-   * The provided listener is a TablesListener function, and will be called with
-   * a reference to the Store and a GetCellChange function in case you need to
-   * inspect any changes that occurred.
+   * The provided listener is a HasTablesListener function, and will be called
+   * with a reference to the Store. It is also given a flag to indicate whether
+   * Tables now exist (having not done previously), or do not (having done so
+   * previously).
    *
    * Use the optional mutator parameter to indicate that there is code in the
    * listener that will mutate Store data. If set to `false` (or omitted), such
@@ -5084,26 +5447,98 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * (since the latter may become relevant due to changes made in the former).
    * The changes made by mutator listeners do not fire other mutating listeners,
    * though they will fire non-mutator listeners.
-   * @param listener The function that will be called whenever data in the Store
-   * changes.
+   * @param listener The function that will be called whenever Tables as a whole
+   * are added or removed.
    * @param mutator An optional boolean that indicates that the listener mutates
    * Store data.
    * @returns A unique Id for the listener that can later be used to call it
    * explicitly, or to remove it.
    * @example
-   * This example registers a listener that responds to any changes to the whole
-   * Store.
+   * This example registers a listener that responds to Tables being added or
+   * removed.
    *
    * ```js
    * const store = createStore().setTables({
    *   pets: {fido: {species: 'dog', color: 'brown'}},
    * });
-   * const listenerId = store.addTablesListener((store, getCellChange) => {
-   *   console.log('Tables changed');
-   *   console.log(getCellChange('pets', 'fido', 'color'));
+   * const listenerId = store.addHasTablesListener((store, hasTables) => {
+   *   console.log('Tables ' + (hasTables ? 'added' : 'removed'));
    * });
    *
-   * store.setCell('pets', 'fido', 'color', 'walnut');
+   * store.delTables();
+   * // -> 'Tables removed'
+   *
+   * store.setTables({species: {dog: {price: 5}}});
+   * // -> 'Tables added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to Tables being added or
+   * removed, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore();
+   * const listenerId = store.addHasTablesListener(
+   *   (store, hasTables) => store.setValue('hasTables', hasTables),
+   *   true,
+   * );
+   *
+   * store.setTables({species: {dog: {price: 5}}});
+   * console.log(store.getValues());
+   * // -> {hasTables: true}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v4.4.0
+   */
+  addHasTablesListener(
+    listener: HasTablesListener<Schemas>,
+    mutator?: boolean,
+  ): Id;
+
+  /**
+   * The addTablesListener method registers a listener function with the Store
+   * that will be called whenever data in the Store changes.
+   *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addTablesListener(listener: TablesListener, mutator?: boolean): Id;
+   * ```
+   *
+   * The provided listener is a TablesListener function, and will be called with
+   * a reference to the Store and a GetCellChange function in case you need to
+   * inspect any changes that occurred.
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   * @param listener The function that will be called whenever data in the Store
+   * changes.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to any changes to the whole
+   * Store.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addTablesListener((store, getCellChange) => {
+   *   console.log('Tables changed');
+   *   console.log(getCellChange('pets', 'fido', 'color'));
+   * });
+   *
+   * store.setCell('pets', 'fido', 'color', 'walnut');
    * // -> 'Tables changed'
    * // -> [true, 'brown', 'walnut']
    *
@@ -5203,6 +5638,119 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     mutator?: boolean,
   ): Id;
 
+  /**
+   * The addHasTableListener method registers a listener function with the Store
+   * that will be called when a Table is added to or removed from the Store.
+   *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addHasTableListener(
+   *   tableId: IdOrNull,
+   *   listener: HasTableListener,
+   *   mutator?: boolean,
+   * ): Id;
+   * ```
+   *
+   * The provided listener is a HasTableListener function, and will be called
+   * with a reference to the Store and the Id of the Table that changed. It is
+   * also given a flag to indicate whether the Table now exists (having not done
+   * previously), or does not (having done so previously).
+   *
+   * You can either listen to a single Table being added or removed (by
+   * specifying the Table Id as the method's first parameter) or changes to any
+   * Table (by providing a `null` wildcard).
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   * @param tableId The Id of the Table to listen to, or `null` as a wildcard.
+   * @param listener The function that will be called whenever the matching
+   * Table is added or removed.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to a specific Table being
+   * added or removed.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasTableListener(
+   *   'pets',
+   *   (store, tableId, hasTable) => {
+   *     console.log('pets table ' + (hasTable ? 'added' : 'removed'));
+   *   },
+   * );
+   *
+   * store.delTable('pets');
+   * // -> 'pets table removed'
+   *
+   * store.setTable('pets', {fido: {species: 'dog', color: 'brown'}});
+   * // -> 'pets table added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any Table being added or
+   * removed.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasTableListener(
+   *   null,
+   *   (store, tableId, hasTable) => {
+   *     console.log(`${tableId} table ` + (hasTable ? 'added' : 'removed'));
+   *   },
+   * );
+   *
+   * store.delTable('pets');
+   * // -> 'pets table removed'
+   * store.setTable('species', {dog: {price: 5}});
+   * // -> 'species table added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to a specific Table being
+   * added or removed, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasTableListener(
+   *   'pets',
+   *   (store, tableId) => store.setCell('meta', 'update', tableId, true),
+   *   true,
+   * );
+   *
+   * store.delTable('pets', 'fido');
+   * console.log(store.getTable('meta'));
+   * // -> {update: {pets: true}}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v4.4.0
+   */
+  addHasTableListener<
+    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+  >(
+    tableId: TableIdOrNull,
+    listener: HasTableListener<Schemas, TableIdOrNull>,
+    mutator?: boolean,
+  ): Id;
+
   /**
    * The addTableListener method registers a listener function with the Store
    * that will be called whenever data in a Table changes.
@@ -5425,6 +5973,143 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     mutator?: boolean,
   ): Id;
 
+  /**
+   * The addHasTableCellListener method registers a listener function with the
+   * Store that will be called when a Cell is added to or removed from anywhere
+   * in a Table as a whole.
+   *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addHasTableCellListener(
+   *   tableId: IdOrNull,
+   *   cellId: IdOrNull,
+   *   listener: HasTableCellListener,
+   *   mutator?: boolean,
+   * ): Id;
+   * ```
+   *
+   * The provided listener is a HasTableCellListener function, and will be
+   * called with a reference to the Store, the Id of the Table that changed, and
+   * the Id of the Table Cell that changed. It is also given a flag to indicate
+   * whether the Cell now exists anywhere in the Table (having not done
+   * previously), or does not (having done so previously).
+   *
+   * You can either listen to a single Table Cell being added or removed (by
+   * specifying the Table Id and Cell Id, as the method's first two parameters)
+   * or changes to any Table Cell (by providing `null` wildcards).
+   *
+   * Both, either, or neither of the `tableId` and `cellId` parameters can be
+   * wildcarded with `null`. You can listen to a specific Row in a specific
+   * Table, any Row in a specific Table, a specific Row in any Table, or any Row
+   * in any Table.
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   * @param tableId The Id of the Table to listen to, or `null` as a wildcard.
+   * @param cellId The Id of the Cell to listen to, or `null` as a wildcard.
+   * @param listener The function that will be called whenever the matching Cell
+   * is added to or removed from anywhere in the Table.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to a specific Cell being
+   * added to or removed from the Table as a whole.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasTableCellListener(
+   *   'pets',
+   *   'color',
+   *   (store, tableId, cellId, hasTableCell) => {
+   *     console.log(
+   *       'color cell in pets table ' + (hasTableCell ? 'added' : 'removed'),
+   *     );
+   *   },
+   * );
+   *
+   * store.delCell('pets', 'fido', 'color');
+   * // -> 'color cell in pets table removed'
+   *
+   * store.setRow('pets', 'felix', {species: 'cat', color: 'brown'});
+   * // -> 'color cell in pets table added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any Cell being
+   * added to or removed from the Table as a whole.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasTableCellListener(
+   *   null,
+   *   null,
+   *   (store, tableId, cellId, hasTableCell) => {
+   *     console.log(
+   *       `${cellId} cell in ${tableId} table ` +
+   *         (hasTableCell ? 'added' : 'removed'),
+   *     );
+   *   },
+   * );
+   *
+   * store.delCell('pets', 'fido', 'color');
+   * // -> 'color cell in pets table removed'
+   * store.setTable('species', {dog: {price: 5}});
+   * // -> 'price cell in species table added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to a specific Cell being
+   * added or removed, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasTableCellListener(
+   *   'pets',
+   *   'color',
+   *   (store, tableId, cellId) =>
+   *     store.setCell('meta', 'update', `${tableId}_${cellId}`, true),
+   *   true,
+   * );
+   *
+   * store.delRow('pets', 'fido');
+   * console.log(store.getTable('meta'));
+   * // -> {update: {pets_color: true}}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v4.4.0
+   */
+  addHasTableCellListener<
+    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+    CellIdOrNull extends
+      | (TableIdOrNull extends TableIdFromSchema<Schemas[0]>
+          ? CellIdFromSchema<Schemas[0], TableIdOrNull>
+          : AllCellIdFromSchema<Schemas[0]>)
+      | null,
+  >(
+    tableId: TableIdOrNull,
+    cellId: CellIdOrNull,
+    listener: HasTableCellListener<Schemas, TableIdOrNull, CellIdOrNull>,
+    mutator?: boolean,
+  ): Id;
+
   /**
    * The addRowCountListener method registers a listener function with the Store
    * that will be called whenever the count of Row objects in a Table change.
@@ -5884,28 +6569,29 @@ export interface Store<in out Schemas extends OptionalSchemas> {
   ): Id;
 
   /**
-   * The addRowListener method registers a listener function with the Store that
-   * will be called whenever data in a Row changes.
+   * The addHasRowListener method registers a listener function with the Store
+   * that will be called when a Row is added to or removed from the Store.
    *
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * addRowListener(
+   * addHasRowListener(
    *   tableId: IdOrNull,
    *   rowId: IdOrNull,
-   *   listener: RowListener,
+   *   listener: HasRowListener,
    *   mutator?: boolean,
    * ): Id;
    * ```
    *
-   * The provided listener is a RowListener function, and will be called with a
-   * reference to the Store, the Id of the Table that changed, the Id of the Row
-   * that changed, and a GetCellChange function in case you need to inspect any
-   * changes that occurred.
+   * The provided listener is a HasRowListener function, and will be called with
+   * a reference to the Store, the Id of the Table that changed, and the Id of
+   * the Row that changed. It is also given a flag to indicate whether the Row
+   * now exists (having not done previously), or does not (having done so
+   * previously).
    *
-   * You can either listen to a single Row (by specifying the Table Id and Row
-   * Id as the method's first two parameters) or changes to any Row (by
-   * providing `null` wildcards).
+   * You can either listen to a single Row being added or removed (by specifying
+   * the Table Id and Row Id, as the method's first two parameters) or changes
+   * to any Row (by providing `null` wildcards).
    *
    * Both, either, or neither of the `tableId` and `rowId` parameters can be
    * wildcarded with `null`. You can listen to a specific Row in a specific
@@ -5921,27 +6607,157 @@ export interface Store<in out Schemas extends OptionalSchemas> {
    * though they will fire non-mutator listeners.
    * @param tableId The Id of the Table to listen to, or `null` as a wildcard.
    * @param rowId The Id of the Row to listen to, or `null` as a wildcard.
-   * @param listener The function that will be called whenever data in the
-   * matching Row changes.
+   * @param listener The function that will be called whenever the matching Row
+   * is added or removed.
    * @param mutator An optional boolean that indicates that the listener mutates
    * Store data.
    * @returns A unique Id for the listener that can later be used to call it
    * explicitly, or to remove it.
    * @example
-   * This example registers a listener that responds to any changes to a
-   * specific Row.
+   * This example registers a listener that responds to a specific Row being
+   * added or removed.
    *
    * ```js
    * const store = createStore().setTables({
    *   pets: {fido: {species: 'dog', color: 'brown'}},
    * });
-   * const listenerId = store.addRowListener(
+   * const listenerId = store.addHasRowListener(
    *   'pets',
    *   'fido',
-   *   (store, tableId, rowId, getCellChange) => {
-   *     console.log('fido row in pets table changed');
-   *     console.log(getCellChange('pets', 'fido', 'color'));
-   *   },
+   *   (store, tableId, rowId, hasRow) => {
+   *     console.log(
+   *       'fido row in pets table ' + (hasRow ? 'added' : 'removed'),
+   *     );
+   *   },
+   * );
+   *
+   * store.delRow('pets', 'fido');
+   * // -> 'fido row in pets table removed'
+   *
+   * store.setRow('pets', 'fido', {species: 'dog', color: 'brown'});
+   * // -> 'fido row in pets table added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any Row being added or
+   * removed.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasRowListener(
+   *   null,
+   *   null,
+   *   (store, tableId, rowId, hasRow) => {
+   *     console.log(
+   *       `${rowId} row in ${tableId} table ` + (hasRow ? 'added' : 'removed'),
+   *     );
+   *   },
+   * );
+   *
+   * store.delRow('pets', 'fido');
+   * // -> 'fido row in pets table removed'
+   * store.setTable('species', {dog: {price: 5}});
+   * // -> 'dog row in species table added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to a specific Row being
+   * added or removed, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasRowListener(
+   *   'pets',
+   *   'fido',
+   *   (store, tableId, rowId) =>
+   *     store.setCell('meta', 'update', `${tableId}_${rowId}`, true),
+   *   true,
+   * );
+   *
+   * store.delRow('pets', 'fido');
+   * console.log(store.getTable('meta'));
+   * // -> {update: {pets_fido: true}}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v4.4.0
+   */
+  addHasRowListener<
+    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+    RowIdOrNull extends IdOrNull,
+  >(
+    tableId: TableIdOrNull,
+    rowId: RowIdOrNull,
+    listener: HasRowListener<Schemas, TableIdOrNull, RowIdOrNull>,
+    mutator?: boolean,
+  ): Id;
+
+  /**
+   * The addRowListener method registers a listener function with the Store that
+   * will be called whenever data in a Row changes.
+   *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addRowListener(
+   *   tableId: IdOrNull,
+   *   rowId: IdOrNull,
+   *   listener: RowListener,
+   *   mutator?: boolean,
+   * ): Id;
+   * ```
+   *
+   * The provided listener is a RowListener function, and will be called with a
+   * reference to the Store, the Id of the Table that changed, the Id of the Row
+   * that changed, and a GetCellChange function in case you need to inspect any
+   * changes that occurred.
+   *
+   * You can either listen to a single Row (by specifying the Table Id and Row
+   * Id as the method's first two parameters) or changes to any Row (by
+   * providing `null` wildcards).
+   *
+   * Both, either, or neither of the `tableId` and `rowId` parameters can be
+   * wildcarded with `null`. You can listen to a specific Row in a specific
+   * Table, any Row in a specific Table, a specific Row in any Table, or any Row
+   * in any Table.
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   * @param tableId The Id of the Table to listen to, or `null` as a wildcard.
+   * @param rowId The Id of the Row to listen to, or `null` as a wildcard.
+   * @param listener The function that will be called whenever data in the
+   * matching Row changes.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to any changes to a
+   * specific Row.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addRowListener(
+   *   'pets',
+   *   'fido',
+   *   (store, tableId, rowId, getCellChange) => {
+   *     console.log('fido row in pets table changed');
+   *     console.log(getCellChange('pets', 'fido', 'color'));
+   *   },
    * );
    *
    * store.setCell('pets', 'fido', 'color', 'walnut');
@@ -6125,6 +6941,155 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     mutator?: boolean,
   ): Id;
 
+  /**
+   * The addHasCellListener method registers a listener function with the Store
+   * that will be called when a Cell is added to or removed from the Store.
+   *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addHasCellListener(
+   *   tableId: IdOrNull,
+   *   rowId: IdOrNull,
+   *   cellId: IdOrNull,
+   *   listener: HasCellListener,
+   *   mutator?: boolean,
+   * ): Id;
+   * ```
+   *
+   * The provided listener is a HasCellListener function, and will be called
+   * with a reference to the Store, the Id of the Table that changed, the Id of
+   * the Row that changed, and the Id of the Cell that changed. It is also given
+   * a flag to indicate whether the Cell now exists (having not done
+   * previously), or does not (having done so previously).
+   *
+   * You can either listen to a single Cell being added or removed (by
+   * specifying the Table Id, Row Id, and Cell Id as the method's first three
+   * parameters) or changes to any Cell (by providing `null` wildcards).
+   *
+   * All, some, or none of the `tableId`, `rowId`, and `cellId` parameters can
+   * be wildcarded with `null`. You can listen to a specific Cell in a specific
+   * Row in a specific Table, any Cell in any Row in any Table, for example - or
+   * every other combination of wildcards.
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   * @param tableId The Id of the Table to listen to, or `null` as a wildcard.
+   * @param rowId The Id of the Row to listen to, or `null` as a wildcard.
+   * @param cellId The Id of the Cell to listen to, or `null` as a wildcard.
+   * @param listener The function that will be called whenever the matching Cell
+   * is added or removed.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to a specific Cell being
+   * added or removed.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasCellListener(
+   *   'pets',
+   *   'fido',
+   *   'color',
+   *   (store, tableId, rowId, cellId, hasCell) => {
+   *     console.log(
+   *       'color cell in fido row in pets table ' +
+   *         (hasCell ? 'added' : 'removed'),
+   *     );
+   *   },
+   * );
+   *
+   * store.delCell('pets', 'fido', 'color');
+   * // -> 'color cell in fido row in pets table removed'
+   *
+   * store.setCell('pets', 'fido', 'color', 'walnut');
+   * // -> 'color cell in fido row in pets table added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any Cell being added or
+   * removed.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasCellListener(
+   *   null,
+   *   null,
+   *   null,
+   *   (store, tableId, rowId, cellId, hasCell) => {
+   *     console.log(
+   *       `${cellId} cell in ${rowId} row in ${tableId} table ` +
+   *         (hasCell ? 'added' : 'removed'),
+   *     );
+   *   },
+   * );
+   *
+   * store.delCell('pets', 'fido', 'color');
+   * // -> 'color cell in fido row in pets table removed'
+   * store.setTable('species', {dog: {price: 5}});
+   * // -> 'price cell in dog row in species table added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to a specific Cell being
+   * added or removed, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasCellListener(
+   *   'pets',
+   *   'fido',
+   *   'color',
+   *   (store, tableId, rowId, cellId) =>
+   *     store.setCell('meta', 'update', `${tableId}_${rowId}_${cellId}`, true),
+   *   true,
+   * );
+   *
+   * store.delCell('pets', 'fido', 'color');
+   * console.log(store.getTable('meta'));
+   * // -> {update: {pets_fido_color: true}}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v4.4.0
+   */
+  addHasCellListener<
+    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+    RowIdOrNull extends IdOrNull,
+    CellIdOrNull extends
+      | (TableIdOrNull extends TableIdFromSchema<Schemas[0]>
+          ? CellIdFromSchema<Schemas[0], TableIdOrNull>
+          : AllCellIdFromSchema<Schemas[0]>)
+      | null,
+  >(
+    tableId: TableIdOrNull,
+    rowId: RowIdOrNull,
+    cellId: CellIdOrNull,
+    listener: HasCellListener<
+      Schemas,
+      TableIdOrNull,
+      RowIdOrNull,
+      CellIdOrNull
+    >,
+    mutator?: boolean,
+  ): Id;
+
   /**
    * The addCellListener method registers a listener function with the Store
    * that will be called whenever data in a Cell changes.
@@ -6264,6 +7229,78 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     mutator?: boolean,
   ): Id;
 
+  /**
+   * The addHasValuesListener method registers a listener function with the
+   * Store that will be called when Values as a whole are added to or removed
+   * from the Store.
+   *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addHasValuesListener(listener: HasValuesListener, mutator?: boolean): Id;
+   * ```
+   *
+   * The provided listener is a HasValuesListener function, and will be called
+   * with a reference to the Store. It is also given a flag to indicate whether
+   * Values now exist (having not done previously), or do not (having done so
+   * previously).
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   * @param listener The function that will be called whenever Values as a whole
+   * are added or removed.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to Values being added or
+   * removed.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * const listenerId = store.addHasValuesListener((store, hasValues) => {
+   *   console.log('Values ' + (hasValues ? 'added' : 'removed'));
+   * });
+   *
+   * store.delValues();
+   * // -> 'Values removed'
+   *
+   * store.setValue('employees', 4);
+   * // -> 'Values added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to Values being added or
+   * removed, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore();
+   * const listenerId = store.addHasValuesListener(
+   *   (store, hasValues) => store.setValue('hasValues', hasValues),
+   *   true,
+   * );
+   *
+   * store.setValue('employees', 4);
+   * console.log(store.getValues());
+   * // -> {employees: 4, hasValues: true}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v4.4.0
+   */
+  addHasValuesListener(
+    listener: HasValuesListener<Schemas>,
+    mutator?: boolean,
+  ): Id;
+
   /**
    * The addValuesListener method registers a listener function with the Store
    * that will be called whenever the Values change.
@@ -6402,6 +7439,113 @@ export interface Store<in out Schemas extends OptionalSchemas> {
     mutator?: boolean,
   ): Id;
 
+  /**
+   * The addHasValueListener method registers a listener function with the Store
+   * that will be called when a Value is added to or removed from the Store.
+   *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addHasValueListener(
+   *   valueId: IdOrNull,
+   *   listener: HasValueListener,
+   *   mutator?: boolean,
+   * ): Id;
+   * ```
+   *
+   * The provided listener is a HasValueListener function, and will be called
+   * with a reference to the Store and the Id of Value that changed. It is also
+   * given a flag to indicate whether the Value now exists (having not done
+   * previously), or does not (having done so previously).
+   *
+   * You can either listen to a single Value being added or removed (by
+   * specifying the Value Id) or any Value being added or removed (by providing
+   * a `null` wildcard).
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   * @param valueId The Id of the Value to listen to, or `null` as a wildcard.
+   * @param listener The function that will be called whenever the matching
+   * Value is added or removed.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to a specific Value being
+   * added or removed.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * const listenerId = store.addHasValueListener(
+   *   'employees',
+   *   (store, valueId, hasValue) => {
+   *     console.log('employee value ' + (hasValue ? 'added' : 'removed'));
+   *   },
+   * );
+   *
+   * store.delValue('employees');
+   * // -> 'employee value removed'
+   *
+   * store.setValue('employees', 4);
+   * // -> 'employee value added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any Value being added or
+   * removed.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * const listenerId = store.addHasValueListener(
+   *   null,
+   *   (store, valueId, hasValue) => {
+   *     console.log(valueId + ' value ' + (hasValue ? 'added' : 'removed'));
+   *   },
+   * );
+   *
+   * store.delValue('employees');
+   * // -> 'employees value removed'
+   * store.setValue('website', 'https://pets.com');
+   * // -> 'website value added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to a specific Value being
+   * added or removed, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * const listenerId = store.addHasValueListener(
+   *   'employees',
+   *   (store, valueId) => store.setValue('updated', true),
+   *   true,
+   * );
+   *
+   * store.delValue('employees');
+   * console.log(store.getValues());
+   * // -> {open: true, updated: true}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v4.4.0
+   */
+  addHasValueListener<
+    ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null,
+  >(
+    valueId: ValueIdOrNull,
+    listener: HasValueListener<Schemas, ValueIdOrNull>,
+    mutator?: boolean,
+  ): Id;
+
   /**
    * The addValueListener method registers a listener function with the Store
    * that will be called whenever data in a Value changes.