tinybase 4.4.0-beta.1 → 4.4.0

package/lib/types/with-schemas/ui-react.d.ts

@@ -69,6 +69,13 @@ import {
   CellIdsListener,
   CellListener,
   CellOrUndefined,
+  HasCellListener,
+  HasRowListener,
+  HasTableCellListener,
+  HasTableListener,
+  HasTablesListener,
+  HasValueListener,
+  HasValuesListener,
   MapCell,
   MapValue,
   OptionalSchemas,
@@ -524,6 +531,90 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => Store<Schemas> | undefined;
 
+  /**
+ * The useHasTables hook returns a boolean indicating whether any Table objects
+ * exist in the Store, and registers a listener so that any changes to that
+ * result will cause a re-render.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useHasTables(storeOrStoreId?: StoreOrStoreId): boolean;
+ * ```
+ *
+ * A Provider component is used to wrap part of an application in a context, and
+ * it can contain a default Store or a set of Store objects named by Id. The
+ * useHasTables hook lets you indicate which Store to get data for: omit the
+ * optional parameter for the default context Store, provide an Id for a named
+ * context Store, or provide a Store explicitly by reference.
+ *
+ * When first rendered, this hook will create a listener so that changes to the
+ * Tables will cause a re-render. When the component containing this hook is
+ * unmounted, the listener will be automatically removed.
+ * @param storeOrStoreId The Store to be accessed: omit for the default context
+ * Store, provide an Id for a named context Store, or provide an explicit
+ * reference.
+ * @returns Whether any Tables exist.
+ * @example
+ * This example creates a Store outside the application, which is used in the
+ * useHasTables hook by reference. A change to the data in the Store re-renders
+ * the component.
+ *
+ * ```jsx
+ * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ * const App = () => <span>{JSON.stringify(useHasTables(store))}</span>;
+ *
+ * const app = document.createElement('div');
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>true</span>'
+ *
+ * store.delTable('pets'); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>false</span>'
+ * ```
+ * @example
+ * This example creates a Provider context into which a default Store is
+ * provided. A component within it then uses the useHasTables hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => <span>{JSON.stringify(useHasTables())}</span>;
+ *
+ * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ * const app = document.createElement('div');
+ * ReactDOMClient.createRoot(app).render(<App store={store} />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>true</span>'
+ * ```
+ * @example
+ * This example creates a Provider context into which a Store is provided, named
+ * by Id. A component within it then uses the useHasTables hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider storesById={{petStore: store}}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => <span>{JSON.stringify(useHasTables('petStore'))}</span>;
+ *
+ * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ * const app = document.createElement('div');
+ * ReactDOMClient.createRoot(app).render(<App store={store} />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>true</span>'
+ * ```
+ * @category Store hooks
+ * @since v4.4.0
+ */
+  useHasTables: (storeOrStoreId?: StoreOrStoreId<Schemas>) => boolean;
+
   /**
  * The useTables hook returns a Tables object containing the tabular data of a
  * Store, and registers a listener so that any changes to that result will cause
@@ -690,6 +781,101 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => TableIdFromSchema<Schemas[0]>[];
 
+  /**
+ * The useHasTable hook returns a boolean indicating whether a given Table
+ * exists in the Store, and registers a listener so that any changes to that
+ * result will cause a re-render.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useHasTable(
+ *   tableId: Id,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): boolean;
+ * ```
+ *
+ * A Provider component is used to wrap part of an application in a context, and
+ * it can contain a default Store or a set of Store objects named by Id. The
+ * useHasTable hook lets you indicate which Store to get data for: omit the
+ * optional parameter for the default context Store, provide an Id for a named
+ * context Store, or provide a Store explicitly by reference.
+ *
+ * When first rendered, this hook will create a listener so that changes to the
+ * Table will cause a re-render. When the component containing this hook is
+ * unmounted, the listener will be automatically removed.
+ * @param tableId The Id of the Table in the Store.
+ * @param storeOrStoreId The Store to be accessed: omit for the default context
+ * Store, provide an Id for a named context Store, or provide an explicit
+ * reference.
+ * @returns Whether a Table with that Id exists.
+ * @example
+ * This example creates a Store outside the application, which is used in the
+ * useHasTable hook by reference. A change to the data in the Store re-renders
+ * the component.
+ *
+ * ```jsx
+ * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ * const App = () => (
+ *   <span>{JSON.stringify(useHasTable('pets', store))}</span>
+ * );
+ *
+ * const app = document.createElement('div');
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>true</span>'
+ *
+ * store.delTable('pets'); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>false</span>'
+ * ```
+ * @example
+ * This example creates a Provider context into which a default Store is
+ * provided. A component within it then uses the useHasTable hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => <span>{JSON.stringify(useHasTable('pets'))}</span>;
+ *
+ * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ * const app = document.createElement('div');
+ * ReactDOMClient.createRoot(app).render(<App store={store} />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>true</span>'
+ * ```
+ * @example
+ * This example creates a Provider context into which a Store is provided, named
+ * by Id. A component within it then uses the useHasTable hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider storesById={{petStore: store}}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => (
+ *   <span>{JSON.stringify(useHasTable('pets', 'petStore'))}</span>
+ * );
+ *
+ * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ * const app = document.createElement('div');
+ * ReactDOMClient.createRoot(app).render(<App store={store} />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>true</span>'
+ * ```
+ * @category Store hooks
+ * @since v4.4.0
+ */
+  useHasTable: <TableId extends TableIdFromSchema<Schemas[0]>>(
+    tableId: TableId,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => boolean;
+
   /**
  * The useTable hook returns an object containing the data of a single Table in
  * a Store, and registers a listener so that any changes to that result will
@@ -872,6 +1058,108 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => CellIdFromSchema<Schemas[0], TableId>[];
 
+  /**
+ * The useHasTableCell hook returns a boolean indicating whether a given Cell
+ * exists anywhere in a Table, not just in a specific Row, and registers a
+ * listener so that any changes to that result will cause a re-render.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useHasTableCell(
+ *   tableId: Id,
+ *   cellId: Id,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): boolean;
+ * ```
+ *
+ * A Provider component is used to wrap part of an application in a context, and
+ * it can contain a default Store or a set of Store objects named by Id. The
+ * useHasTableCell hook lets you indicate which Store to get data for: omit the
+ * optional parameter for the default context Store, provide an Id for a named
+ * context Store, or provide a Store explicitly by reference.
+ *
+ * When first rendered, this hook will create a listener so that changes to the
+ * Table will cause a re-render. When the component containing this hook is
+ * unmounted, the listener will be automatically removed.
+ * @param tableId The Id of the Table in the Store.
+ * @param cellId The Id of the Cell in the Table.
+ * @param storeOrStoreId The Store to be accessed: omit for the default context
+ * Store, provide an Id for a named context Store, or provide an explicit
+ * reference.
+ * @returns Whether a Cell with that Id exists anywhere in that Table.
+ * @example
+ * This example creates a Store outside the application, which is used in the
+ * useHasTableCell hook by reference. A change to the data in the Store
+ * re-renders the component.
+ *
+ * ```jsx
+ * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ * const App = () => (
+ *   <span>{JSON.stringify(useHasTableCell('pets', 'legs', store))}</span>
+ * );
+ *
+ * const app = document.createElement('div');
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>false</span>'
+ *
+ * store.setRow('pets', 'felix', {color: 'black', legs: 4}); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>true</span>'
+ * ```
+ * @example
+ * This example creates a Provider context into which a default Store is
+ * provided. A component within it then uses the useHasTableCell hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => (
+ *   <span>{JSON.stringify(useHasTableCell('pets', 'legs'))}</span>
+ * );
+ *
+ * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ * const app = document.createElement('div');
+ * ReactDOMClient.createRoot(app).render(<App store={store} />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>false</span>'
+ * ```
+ * @example
+ * This example creates a Provider context into which a Store is provided, named
+ * by Id. A component within it then uses the useHasTableCell hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider storesById={{petStore: store}}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => (
+ *   <span>
+ *     {JSON.stringify(useHasTableCell('pets', 'legs', 'petStore'))}
+ *   </span>
+ * );
+ *
+ * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ * const app = document.createElement('div');
+ * ReactDOMClient.createRoot(app).render(<App store={store} />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>false</span>'
+ * ```
+ * @category Store hooks
+ * @since v4.4.0
+ */
+  useHasTableCell: <TableId extends TableIdFromSchema<Schemas[0]>>(
+    tableId: TableId,
+    cellId: CellIdFromSchema<Schemas[0], TableId>,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => boolean;
+
   /**
  * The useRowCount hook returns the count of the Row objects in a given Table,
  * and registers a listener so that any changes to that result will cause a
@@ -1184,25 +1472,25 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => Ids;
 
   /**
- * The useRow hook returns an object containing the data of a single Row in a
- * given Table, and registers a listener so that any changes to that result will
+ * The useHasRow hook returns a boolean indicating whether a given Row exists in
+ * the Store, and registers a listener so that any changes to that result will
  * cause a re-render.
  *
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * useRow(
+ * useHasRow(
  *   tableId: Id,
  *   rowId: Id,
  *   storeOrStoreId?: StoreOrStoreId,
- * ): Row;
+ * ): boolean;
  * ```
  *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Store or a set of Store objects named by Id. The
- * useRow hook lets you indicate which Store to get data for: omit the final
- * optional final parameter for the default context Store, provide an Id for a
- * named context Store, or provide a Store explicitly by reference.
+ * useHasRow hook lets you indicate which Store to get data for: omit the
+ * optional parameter for the default context Store, provide an Id for a named
+ * context Store, or provide a Store explicitly by reference.
  *
  * When first rendered, this hook will create a listener so that changes to the
  * Row will cause a re-render. When the component containing this hook is
@@ -1212,26 +1500,126 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param storeOrStoreId The Store to be accessed: omit for the default context
  * Store, provide an Id for a named context Store, or provide an explicit
  * reference.
- * @returns An object containing the entire data of the Row.
+ * @returns Whether a Row with that Id exists in that Table.
  * @example
  * This example creates a Store outside the application, which is used in the
- * useRow hook by reference. A change to the data in the Store re-renders the
- * component.
+ * useHasRow hook by reference. A change to the data in the Store re-renders
+ * the component.
  *
  * ```jsx
  * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
  * const App = () => (
- *   <span>{JSON.stringify(useRow('pets', 'fido', store))}</span>
+ *   <span>{JSON.stringify(useHasRow('pets', 'felix', store))}</span>
  * );
  *
  * const app = document.createElement('div');
- * ReactDOMClient.createRoot(app).render(<App />); // !act
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App />); // !act
  * console.log(app.innerHTML);
- * // -> '<span>{"color":"brown"}</span>'
+ * // -> '<span>false</span>'
  *
- * store.setCell('pets', 'fido', 'color', 'walnut'); // !act
+ * store.setCell('pets', 'felix', 'color', 'black'); // !act
  * console.log(app.innerHTML);
- * // -> '<span>{"color":"walnut"}</span>'
+ * // -> '<span>true</span>'
+ * ```
+ * @example
+ * This example creates a Provider context into which a default Store is
+ * provided. A component within it then uses the useHasRow hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => (
+ *   <span>{JSON.stringify(useHasRow('pets', 'felix'))}</span>
+ * );
+ *
+ * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ * const app = document.createElement('div');
+ * ReactDOMClient.createRoot(app).render(<App store={store} />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>false</span>'
+ * ```
+ * @example
+ * This example creates a Provider context into which a Store is provided, named
+ * by Id. A component within it then uses the useHasRow hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider storesById={{petStore: store}}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => (
+ *   <span>{JSON.stringify(useHasRow('pets', 'felix', 'petStore'))}</span>
+ * );
+ *
+ * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ * const app = document.createElement('div');
+ * ReactDOMClient.createRoot(app).render(<App store={store} />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>false</span>'
+ * ```
+ * @category Store hooks
+ * @since v4.4.0
+ */
+  useHasRow: <TableId extends TableIdFromSchema<Schemas[0]>>(
+    tableId: TableId,
+    rowId: Id,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => boolean;
+
+  /**
+ * The useRow hook returns an object containing the data of a single Row in a
+ * given Table, and registers a listener so that any changes to that result will
+ * cause a re-render.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useRow(
+ *   tableId: Id,
+ *   rowId: Id,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): Row;
+ * ```
+ *
+ * A Provider component is used to wrap part of an application in a context, and
+ * it can contain a default Store or a set of Store objects named by Id. The
+ * useRow hook lets you indicate which Store to get data for: omit the final
+ * optional final parameter for the default context Store, provide an Id for a
+ * named context Store, or provide a Store explicitly by reference.
+ *
+ * When first rendered, this hook will create a listener so that changes to the
+ * Row will cause a re-render. When the component containing this hook is
+ * unmounted, the listener will be automatically removed.
+ * @param tableId The Id of the Table in the Store.
+ * @param rowId The Id of the Row in the Table.
+ * @param storeOrStoreId The Store to be accessed: omit for the default context
+ * Store, provide an Id for a named context Store, or provide an explicit
+ * reference.
+ * @returns An object containing the entire data of the Row.
+ * @example
+ * This example creates a Store outside the application, which is used in the
+ * useRow hook by reference. A change to the data in the Store re-renders the
+ * component.
+ *
+ * ```jsx
+ * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ * const App = () => (
+ *   <span>{JSON.stringify(useRow('pets', 'fido', store))}</span>
+ * );
+ *
+ * const app = document.createElement('div');
+ * ReactDOMClient.createRoot(app).render(<App />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>{"color":"brown"}</span>'
+ *
+ * store.setCell('pets', 'fido', 'color', 'walnut'); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>{"color":"walnut"}</span>'
  * ```
  * @example
  * This example creates a Provider context into which a default Store is
@@ -1377,6 +1765,114 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => CellIdFromSchema<Schemas[0], TableId>[];
 
+  /**
+ * The useHasCell hook returns a boolean indicating whether a given Cell exists
+ * in a given Row in a given Table, and registers a listener so that any changes
+ * to that result will cause a re-render.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useHasCell(
+ *   tableId: Id,
+ *   rowId: Id,
+ *   cellId: Id,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): boolean;
+ * ```
+ *
+ * A Provider component is used to wrap part of an application in a context, and
+ * it can contain a default Store or a set of Store objects named by Id. The
+ * useHasCell hook lets you indicate which Store to get data for: omit the
+ * optional parameter for the default context Store, provide an Id for a named
+ * context Store, or provide a Store explicitly by reference.
+ *
+ * When first rendered, this hook will create a listener so that changes to the
+ * Cell will cause a re-render. When the component containing this hook is
+ * unmounted, the listener will be automatically removed.
+ * @param tableId The Id of the Table in the Store.
+ * @param rowId The Id of the Row in the Table.
+ * @param cellId The Id of the Cell in the Row.
+ * @param storeOrStoreId The Store to be accessed: omit for the default context
+ * Store, provide an Id for a named context Store, or provide an explicit
+ * reference.
+ * @returns Whether a Cell with that Id exists in that Row in that Table.
+ * @example
+ * This example creates a Store outside the application, which is used in the
+ * useHasCell hook by reference. A change to the data in the Store re-renders
+ * the component.
+ *
+ * ```jsx
+ * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ * const App = () => (
+ *   <span>{JSON.stringify(useHasCell('pets', 'fido', 'legs', store))}</span>
+ * );
+ *
+ * const app = document.createElement('div');
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>false</span>'
+ *
+ * store.setCell('pets', 'fido', 'legs', 4); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>true</span>'
+ * ```
+ * @example
+ * This example creates a Provider context into which a default Store is
+ * provided. A component within it then uses the useHasCell hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => (
+ *   <span>{JSON.stringify(useHasCell('pets', 'fido', 'legs'))}</span>
+ * );
+ *
+ * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ * const app = document.createElement('div');
+ * ReactDOMClient.createRoot(app).render(<App store={store} />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>false</span>'
+ * ```
+ * @example
+ * This example creates a Provider context into which a Store is provided, named
+ * by Id. A component within it then uses the useHasCell hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider storesById={{petStore: store}}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => (
+ *   <span>
+ *     {JSON.stringify(useHasCell('pets', 'fido', 'legs', 'petStore'))}
+ *   </span>
+ * );
+ *
+ * const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ * const app = document.createElement('div');
+ * ReactDOMClient.createRoot(app).render(<App store={store} />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>false</span>'
+ * ```
+ * @category Store hooks
+ * @since v4.4.0
+ */
+  useHasCell: <
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    CellId extends CellIdFromSchema<Schemas[0], TableId>,
+  >(
+    tableId: TableId,
+    rowId: Id,
+    cellId: CellId,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => boolean;
+
   /**
  * The useCell hook returns an object containing the value of a single Cell in a
  * given Row, in a given Table, and registers a listener so that any changes to
@@ -1477,6 +1973,90 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => NoInfer<CellOrUndefined<Schemas[0], TableId, CellId>>;
 
+  /**
+ * The useHasValues hook returns a boolean indicating whether any Values exist
+ * in the Store, and registers a listener so that any changes to that result
+ * will cause a re-render.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useHasValues(storeOrStoreId?: StoreOrStoreId): boolean;
+ * ```
+ *
+ * A Provider component is used to wrap part of an application in a context, and
+ * it can contain a default Store or a set of Store objects named by Id. The
+ * useHasValues hook lets you indicate which Store to get data for: omit the
+ * optional parameter for the default context Store, provide an Id for a named
+ * context Store, or provide a Store explicitly by reference.
+ *
+ * When first rendered, this hook will create a listener so that changes to the
+ * Values will cause a re-render. When the component containing this hook is
+ * unmounted, the listener will be automatically removed.
+ * @param storeOrStoreId The Store to be accessed: omit for the default context
+ * Store, provide an Id for a named context Store, or provide an explicit
+ * reference.
+ * @returns Whether any Values exist.
+ * @example
+ * This example creates a Store outside the application, which is used in the
+ * useHasValues hook by reference. A change to the data in the Store re-renders
+ * the component.
+ *
+ * ```jsx
+ * const store = createStore().setValue('open', true);
+ * const App = () => <span>{JSON.stringify(useHasValues(store))}</span>;
+ *
+ * const app = document.createElement('div');
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>true</span>'
+ *
+ * store.delValue('open'); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>false</span>'
+ * ```
+ * @example
+ * This example creates a Provider context into which a default Store is
+ * provided. A component within it then uses the useHasValues hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => <span>{JSON.stringify(useHasValues())}</span>;
+ *
+ * const store = createStore().setValue('open', true);
+ * const app = document.createElement('div');
+ * ReactDOMClient.createRoot(app).render(<App store={store} />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>true</span>'
+ * ```
+ * @example
+ * This example creates a Provider context into which a Store is provided, named
+ * by Id. A component within it then uses the useHasValues hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider storesById={{petStore: store}}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => <span>{JSON.stringify(useHasValues('petStore'))}</span>;
+ *
+ * const store = createStore().setValue('open', true);
+ * const app = document.createElement('div');
+ * ReactDOMClient.createRoot(app).render(<App store={store} />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>true</span>'
+ * ```
+ * @category Store hooks
+ * @since v4.4.0
+ */
+  useHasValues: (storeOrStoreId?: StoreOrStoreId<Schemas>) => boolean;
+
   /**
  * The useValues hook returns a Values object containing the keyed value data of
  * a Store, and registers a listener so that any changes to that result will
@@ -1644,6 +2224,101 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => ValueIdFromSchema<Schemas[1]>[];
 
+  /**
+ * The useHasValue hook returns a boolean indicating whether a given Value
+ * exists in the Store, and registers a listener so that any changes to that
+ * result will cause a re-render.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useHasValue(
+ *   valueId: Id,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): boolean;
+ * ```
+ *
+ * A Provider component is used to wrap part of an application in a context, and
+ * it can contain a default Store or a set of Store objects named by Id. The
+ * useHasValue hook lets you indicate which Store to get data for: omit the
+ * optional parameter for the default context Store, provide an Id for a named
+ * context Store, or provide a Store explicitly by reference.
+ *
+ * When first rendered, this hook will create a listener so that changes to the
+ * Value will cause a re-render. When the component containing this hook is
+ * unmounted, the listener will be automatically removed.
+ * @param valueId The Id of the Value in the Store.
+ * @param storeOrStoreId The Store to be accessed: omit for the default context
+ * Store, provide an Id for a named context Store, or provide an explicit
+ * reference.
+ * @returns Whether a Value with that Id exists in the Store.
+ * @example
+ * This example creates a Store outside the application, which is used in the
+ * useHasValue hook by reference. A change to the data in the Store re-renders
+ * the component.
+ *
+ * ```jsx
+ * const store = createStore().setValue('open', true);
+ * const App = () => (
+ *   <span>{JSON.stringify(useHasValue('employees', store))}</span>
+ * );
+ *
+ * const app = document.createElement('div');
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>false</span>'
+ *
+ * store.setValue('employees', 3); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>true</span>'
+ * ```
+ * @example
+ * This example creates a Provider context into which a default Store is
+ * provided. A component within it then uses the useHasValue hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => <span>{JSON.stringify(useHasValue('employees'))}</span>;
+ *
+ * const store = createStore().setValue('open', true);
+ * const app = document.createElement('div');
+ * ReactDOMClient.createRoot(app).render(<App store={store} />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>false</span>'
+ * ```
+ * @example
+ * This example creates a Provider context into which a Store is provided, named
+ * by Id. A component within it then uses the useHasValue hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider storesById={{petStore: store}}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => (
+ *   <span>{JSON.stringify(useHasValue('employees', 'petStore'))}</span>
+ * );
+ *
+ * const store = createStore().setValue('open', true);
+ * const app = document.createElement('div');
+ * ReactDOMClient.createRoot(app).render(<App store={store} />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>false</span>'
+ * ```
+ * @category Store hooks
+ * @since v4.4.0
+ */
+  useHasValue: <ValueId extends ValueIdFromSchema<Schemas[1]>>(
+    valueId: ValueId,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => boolean;
+
   /**
  * The useValue hook returns an object containing the data of a single Value in
  * a Store, and registers a listener so that any changes to that result will
@@ -3174,27 +3849,102 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * };
  *
  * const app = document.createElement('div');
- * ReactDOMClient.createRoot(app).render(<App />); // !act
- * const span = app.querySelector('span');
- * console.log(span.innerHTML);
- * // -> '{"open":true,"employees":3}'
+ * ReactDOMClient.createRoot(app).render(<App />); // !act
+ * const span = app.querySelector('span');
+ * console.log(span.innerHTML);
+ * // -> '{"open":true,"employees":3}'
+ *
+ * // User clicks the <span> element:
+ * // -> span MouseEvent('click', {bubbles: true})
+ * // -> 'Deleted'
+ *
+ * console.log(span.innerHTML);
+ * // -> '{"employees":3}'
+ * ```
+ * @category Store hooks
+ * @since v3.0.0
+ */
+  useDelValueCallback: <ValueId extends ValueIdFromSchema<Schemas[1]>>(
+    valueId: ValueId,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (store: Store<Schemas>) => void,
+    thenDeps?: React.DependencyList,
+  ) => Callback;
+
+  /**
+ * The useHasTablesListener hook 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
+ * useHasTablesListener(
+ *   listener: HasTablesListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
+ * This hook is useful for situations where a component needs to register its
+ * own specific listener to do more than simply tracking the value (which is
+ * more easily done with the useHasTables hook).
+ *
+ * Unlike the addHasTablesListener method, which returns a listener Id and
+ * requires you to remove it manually, the useHasTablesListener hook manages
+ * this lifecycle for you: when the listener changes (per its `listenerDeps`
+ * dependencies) or the component unmounts, the listener on the underlying Store
+ * will be deleted.
+ * @param listener The function that will be called whenever Tables as a whole
+ * are added or removed.
+ * @param listenerDeps An optional array of dependencies for the `listener`
+ * function, which, if any change, result in the re-registration of the
+ * listener. This parameter defaults to an empty array.
+ * @param mutator An optional boolean that indicates that the listener mutates
+ * Store data.
+ * @param storeOrStoreId The Store to register the listener with: omit for the
+ * default context Store, provide an Id for a named context Store, or provide an
+ * explicit reference.
+ * @example
+ * This example uses the useHasTablesListener hook to create a listener that is
+ * scoped to a single component. When the component is unmounted, the listener
+ * is removed from the Store.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => {
+ *   useHasTablesListener(() => console.log('Tables existence changed'));
+ *   return <span>App</span>;
+ * };
+ *
+ * const store = createStore();
+ * const app = document.createElement('div');
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App store={store} />); // !act
+ * console.log(store.getListenerStats().hasTables);
+ * // -> 1
  *
- * // User clicks the <span> element:
- * // -> span MouseEvent('click', {bubbles: true})
- * // -> 'Deleted'
+ * store.setCell('pets', 'fido', 'color', 'brown'); // !act
+ * // -> 'Tables existence changed'
  *
- * console.log(span.innerHTML);
- * // -> '{"employees":3}'
+ * root.unmount(); // !act
+ * console.log(store.getListenerStats().hasTables);
+ * // -> 0
  * ```
  * @category Store hooks
- * @since v3.0.0
+ * @since v4.4.0
  */
-  useDelValueCallback: <ValueId extends ValueIdFromSchema<Schemas[1]>>(
-    valueId: ValueId,
+  useHasTablesListener: (
+    listener: HasTablesListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
-    then?: (store: Store<Schemas>) => void,
-    thenDeps?: React.DependencyList,
-  ) => Callback;
+  ) => void;
 
   /**
  * The useTablesListener hook registers a listener function with a Store that
@@ -3341,6 +4091,90 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => void;
 
+  /**
+ * The useHasTableListener hook 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
+ * useHasTableListener(
+ *   tableId: IdOrNull,
+ *   listener: HasTableListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
+ * This hook is useful for situations where a component needs to register its
+ * own specific listener to do more than simply tracking the value (which is
+ * more easily done with the useHasTable hook).
+ *
+ * You can either listen to a single Table (by specifying its Id as the method's
+ * first parameter) or changes to any Table (by providing a `null` wildcard).
+ *
+ * Unlike the addHasTableListener method, which returns a listener Id and
+ * requires you to remove it manually, the useHasTableListener hook manages this
+ * lifecycle for you: when the listener changes (per its `listenerDeps`
+ * dependencies) or the component unmounts, the listener on the underlying Store
+ * will be deleted.
+ * @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 listenerDeps An optional array of dependencies for the `listener`
+ * function, which, if any change, result in the re-registration of the
+ * listener. This parameter defaults to an empty array.
+ * @param mutator An optional boolean that indicates that the listener mutates
+ * Store data.
+ * @param storeOrStoreId The Store to register the listener with: omit for the
+ * default context Store, provide an Id for a named context Store, or provide an
+ * explicit reference.
+ * @example
+ * This example uses the useHasTableListener hook to create a listener that is
+ * scoped to a single component. When the component is unmounted, the listener
+ * is removed from the Store.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => {
+ *   useHasTableListener('pets', () =>
+ *     console.log('Table existence changed'),
+ *   );
+ *   return <span>App</span>;
+ * };
+ *
+ * const store = createStore();
+ * const app = document.createElement('div');
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App store={store} />); // !act
+ * console.log(store.getListenerStats().hasTable);
+ * // -> 1
+ *
+ * store.setCell('pets', 'fido', 'color', 'walnut'); // !act
+ * // -> 'Table existence changed'
+ *
+ * root.unmount(); // !act
+ * console.log(store.getListenerStats().hasTable);
+ * // -> 0
+ * ```
+ * @category Store hooks
+ * @since v4.4.0
+ */
+  useHasTableListener: <
+    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+  >(
+    tableId: TableIdOrNull,
+    listener: HasTableListener<Schemas, TableIdOrNull>,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
+
   /**
  * The useTableListener hook registers a listener function with a Store that
  * will be called whenever data in a Table changes.
@@ -3503,6 +4337,100 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => void;
 
+  /**
+ * The useHasTableCellListener hook 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
+ * useHasTableCellListener(
+ *   tableId: IdOrNull,
+ *   cellId: IdOrNull,
+ *   listener: HasTableCellListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
+ * This hook is useful for situations where a component needs to register its
+ * own specific listener to do more than simply tracking the value (which is
+ * more easily done with the useHasTableCell hook).
+ *
+ * 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).
+ *
+ * Unlike the addHasTableCellIds method, which returns a listener Id and
+ * requires you to remove it manually, the useHasTableCellListener hook manages
+ * this lifecycle for you: when the listener changes (per its `listenerDeps`
+ * dependencies) or the component unmounts, the listener on the underlying Store
+ * will be deleted.
+ * @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 listenerDeps An optional array of dependencies for the `listener`
+ * function, which, if any change, result in the re-registration of the
+ * listener. This parameter defaults to an empty array.
+ * @param mutator An optional boolean that indicates that the listener mutates
+ * Store data.
+ * @param storeOrStoreId The Store to register the listener with: omit for the
+ * default context Store, provide an Id for a named context Store, or provide an
+ * explicit reference.
+ * @example
+ * This example uses the useHasTableCellListener hook to create a listener that
+ * is scoped to a single component. When the component is unmounted, the
+ * listener is removed from the Store.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => {
+ *   useHasTableCellListener('pets', 'color', () =>
+ *     console.log('Table Cell existence changed'),
+ *   );
+ *   return <span>App</span>;
+ * };
+ *
+ * const store = createStore();
+ * const app = document.createElement('div');
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App store={store} />); // !act
+ * console.log(store.getListenerStats().hasTableCell);
+ * // -> 1
+ *
+ * store.setRow('pets', 'fido', {color: 'brown'}); // !act
+ * // -> 'Table Cell existence changed'
+ *
+ * root.unmount(); // !act
+ * console.log(store.getListenerStats().hasTableCell);
+ * // -> 0
+ * ```
+ * @category Store hooks
+ * @since v4.4.0
+ */
+  useHasTableCellListener: <
+    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>,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
+
   /**
  * The useRowCountListener hook registers a listener function with a Store that
  * will be called whenever the count of the Row objects in a Table changes.
@@ -3712,9 +4640,120 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * default context Store, provide an Id for a named context Store, or provide an
  * explicit reference.
  * @example
- * This example uses the useSortedRowIdsListener hook to create a listener that
- * is scoped to a single component. When the component is unmounted, the
- * listener is removed from the Store.
+ * This example uses the useSortedRowIdsListener hook to create a listener that
+ * is scoped to a single component. When the component is unmounted, the
+ * listener is removed from the Store.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => {
+ *   useSortedRowIdsListener('pets', 'species', false, 0, undefined, () =>
+ *     console.log('Sorted Row Ids changed'),
+ *   );
+ *   return <span>App</span>;
+ * };
+ *
+ * const store = createStore().setTables({
+ *   pets: {
+ *     fido: {species: 'dog'},
+ *     felix: {species: 'cat'},
+ *   },
+ * });
+ * const app = document.createElement('div');
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App store={store} />); // !act
+ * console.log(store.getListenerStats().sortedRowIds);
+ * // -> 1
+ *
+ * store.setRow('pets', 'cujo', {species: 'wolf'}); // !act
+ * // -> 'Sorted Row Ids changed'
+ *
+ * root.unmount(); // !act
+ * console.log(store.getListenerStats().sortedRowIds);
+ * // -> 0
+ * ```
+ * @category Store hooks
+ * @since v2.0.0
+ */
+  useSortedRowIdsListener: <
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    CellIdOrUndefined extends CellIdFromSchema<Schemas[0], TableId> | undefined,
+    Descending extends boolean,
+    Offset extends number,
+    Limit extends number | undefined,
+  >(
+    tableId: TableId,
+    cellId: CellIdOrUndefined,
+    descending: Descending,
+    offset: Offset,
+    limit: Limit,
+    listener: SortedRowIdsListener<
+      Schemas,
+      TableId,
+      CellIdOrUndefined,
+      Descending,
+      Offset,
+      Limit
+    >,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
+
+  /**
+ * The useHasRowListener hook 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
+ * useHasRowListener(
+ *   tableId: IdOrNull,
+ *   rowId: IdOrNull,
+ *   listener: HasRowListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
+ * This hook is useful for situations where a component needs to register its
+ * own specific listener to do more than simply tracking the value (which is
+ * more easily done with the useHasRow hook).
+ *
+ * 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 Table,
+ * any Row in a specific Table, a specific Row in any Table, or any Row in any
+ * Table.
+ *
+ * Unlike the addHasRowListener method, which returns a listener Id and requires
+ * you to remove it manually, the useHasRowListener hook manages this lifecycle
+ * for you: when the listener changes (per its `listenerDeps` dependencies) or
+ * the component unmounts, the listener on the underlying Store will be deleted.
+ * @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 the matching Row
+ * is added or removed.
+ * @param listenerDeps An optional array of dependencies for the `listener`
+ * function, which, if any change, result in the re-registration of the
+ * listener. This parameter defaults to an empty array.
+ * @param mutator An optional boolean that indicates that the listener mutates
+ * Store data.
+ * @param storeOrStoreId The Store to register the listener with: omit for the
+ * default context Store, provide an Id for a named context Store, or provide an
+ * explicit reference.
+ * @example
+ * This example uses the useHasRowListener hook to create a listener that is
+ * scoped to a single component. When the component is unmounted, the listener
+ * is removed from the Store.
  *
  * ```jsx
  * const App = ({store}) => (
@@ -3723,54 +4762,36 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  *   </Provider>
  * );
  * const Pane = () => {
- *   useSortedRowIdsListener('pets', 'species', false, 0, undefined, () =>
- *     console.log('Sorted Row Ids changed'),
+ *   useHasRowListener('pets', 'fido', () =>
+ *     console.log('Row existence changed'),
  *   );
  *   return <span>App</span>;
  * };
  *
- * const store = createStore().setTables({
- *   pets: {
- *     fido: {species: 'dog'},
- *     felix: {species: 'cat'},
- *   },
- * });
+ * const store = createStore();
  * const app = document.createElement('div');
  * const root = ReactDOMClient.createRoot(app);
  * root.render(<App store={store} />); // !act
- * console.log(store.getListenerStats().sortedRowIds);
+ * console.log(store.getListenerStats().hasRow);
  * // -> 1
  *
- * store.setRow('pets', 'cujo', {species: 'wolf'}); // !act
- * // -> 'Sorted Row Ids changed'
+ * store.setCell('pets', 'fido', 'color', 'walnut'); // !act
+ * // -> 'Row existence changed'
  *
  * root.unmount(); // !act
- * console.log(store.getListenerStats().sortedRowIds);
+ * console.log(store.getListenerStats().hasRow);
  * // -> 0
  * ```
  * @category Store hooks
- * @since v2.0.0
+ * @since v4.4.0
  */
-  useSortedRowIdsListener: <
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    CellIdOrUndefined extends CellIdFromSchema<Schemas[0], TableId> | undefined,
-    Descending extends boolean,
-    Offset extends number,
-    Limit extends number | undefined,
+  useHasRowListener: <
+    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+    RowIdOrNull extends IdOrNull,
   >(
-    tableId: TableId,
-    cellId: CellIdOrUndefined,
-    descending: Descending,
-    offset: Offset,
-    limit: Limit,
-    listener: SortedRowIdsListener<
-      Schemas,
-      TableId,
-      CellIdOrUndefined,
-      Descending,
-      Offset,
-      Limit
-    >,
+    tableId: TableIdOrNull,
+    rowId: RowIdOrNull,
+    listener: HasRowListener<Schemas, TableIdOrNull, RowIdOrNull>,
     listenerDeps?: React.DependencyList,
     mutator?: boolean,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
@@ -3959,6 +4980,113 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => void;
 
+  /**
+ * The useHasCellListener hook 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
+ * useHasCellListener(
+ *   tableId: IdOrNull,
+ *   rowId: IdOrNull,
+ *   cellId: IdOrNull,
+ *   listener: HasCellListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
+ * This hook is useful for situations where a component needs to register its
+ * own specific listener to do more than simply tracking the value (which is
+ * more easily done with the useHasCell hook).
+ *
+ * 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.
+ *
+ * Unlike the addHasCellListener method, which returns a listener Id and
+ * requires you to remove it manually, the useHasCellListener hook manages this
+ * lifecycle for you: when the listener changes (per its `listenerDeps`
+ * dependencies) or the component unmounts, the listener on the underlying Store
+ * will be deleted.
+ * @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 listenerDeps An optional array of dependencies for the `listener`
+ * function, which, if any change, result in the re-registration of the
+ * listener. This parameter defaults to an empty array.
+ * @param mutator An optional boolean that indicates that the listener mutates
+ * Store data.
+ * @param storeOrStoreId The Store to register the listener with: omit for the
+ * default context Store, provide an Id for a named context Store, or provide an
+ * explicit reference.
+ * @example
+ * This example uses the useHasCellListener hook to create a listener that is
+ * scoped to a single component. When the component is unmounted, the listener
+ * is removed from the Store.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => {
+ *   useHasCellListener('pets', 'fido', 'color', () =>
+ *     console.log('Cell existence changed'),
+ *   );
+ *   return <span>App</span>;
+ * };
+ *
+ * const store = createStore();
+ * const app = document.createElement('div');
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App store={store} />); // !act
+ * console.log(store.getListenerStats().hasCell);
+ * // -> 1
+ *
+ * store.setCell('pets', 'fido', 'color', 'brown'); // !act
+ * // -> 'Cell existence changed'
+ *
+ * root.unmount(); // !act
+ * console.log(store.getListenerStats().hasCell);
+ * // -> 0
+ * ```
+ * @category Store hooks
+ * @since v4.4.0
+ */
+  useHasCellListener: <
+    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
+    >,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
+
   /**
  * The useCellListener hook registers a listener function with a Store that will
  * be called whenever data in a Cell changes.
@@ -4059,6 +5187,81 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => void;
 
+  /**
+ * The useHasValuesListener hook 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
+ * useHasValuesListener(
+ *   listener: HasValuesListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
+ * This hook is useful for situations where a component needs to register its
+ * own specific listener to do more than simply tracking the value (which is
+ * more easily done with the useHasValues hook).
+ *
+ * Unlike the addHasValuesListener method, which returns a listener Id and
+ * requires you to remove it manually, the useHasValuesListener hook manages
+ * this lifecycle for you: when the listener changes (per its `listenerDeps`
+ * dependencies) or the component unmounts, the listener on the underlying Store
+ * will be deleted.
+ * @param listener The function that will be called whenever Values as a whole
+ * are added or removed.
+ * @param listenerDeps An optional array of dependencies for the `listener`
+ * function, which, if any change, result in the re-registration of the
+ * listener. This parameter defaults to an empty array.
+ * @param mutator An optional boolean that indicates that the listener mutates
+ * Store data.
+ * @param storeOrStoreId The Store to register the listener with: omit for the
+ * default context Store, provide an Id for a named context Store, or provide an
+ * explicit reference.
+ * @example
+ * This example uses the useHasValuesListener hook to create a listener that is
+ * scoped to a single component. When the component is unmounted, the listener
+ * is removed from the Store.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => {
+ *   useHasValuesListener(() => console.log('Values existence changed'));
+ *   return <span>App</span>;
+ * };
+ *
+ * const store = createStore();
+ * const app = document.createElement('div');
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App store={store} />); // !act
+ * console.log(store.getListenerStats().hasValues);
+ * // -> 1
+ *
+ * store.setValue('open', true); // !act
+ * // -> 'Values existence changed'
+ *
+ * root.unmount(); // !act
+ * console.log(store.getListenerStats().hasValues);
+ * // -> 0
+ * ```
+ * @category Store hooks
+ * @since v4.4.0
+ */
+  useHasValuesListener: (
+    listener: HasValuesListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
+
   /**
  * The useValuesListener hook registers a listener function with a Store that
  * will be called whenever keyed value data in it changes.
@@ -4206,6 +5409,91 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => void;
 
+  /**
+ * The useHasValueListener hook 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
+ * useHasValueListener(
+ *   valueId: IdOrNull,
+ *   listener: HasValueListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
+ * This hook is useful for situations where a component needs to register its
+ * own specific listener to do more than simply tracking the value (which is
+ * more easily done with the useHasValue hook).
+ *
+ * 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).
+ *
+ * Unlike the addHasValueListener method, which returns a listener Id and
+ * requires you to remove it manually, the useHasValueListener hook manages this
+ * lifecycle for you: when the listener changes (per its `listenerDeps`
+ * dependencies) or the component unmounts, the listener on the underlying Store
+ * will be deleted.
+ * @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 listenerDeps An optional array of dependencies for the `listener`
+ * function, which, if any change, result in the re-registration of the
+ * listener. This parameter defaults to an empty array.
+ * @param mutator An optional boolean that indicates that the listener mutates
+ * Store data.
+ * @param storeOrStoreId The Store to register the listener with: omit for the
+ * default context Store, provide an Id for a named context Store, or provide an
+ * explicit reference.
+ * @example
+ * This example uses the useHasValueListener hook to create a listener that is
+ * scoped to a single component. When the component is unmounted, the listener
+ * is removed from the Store.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => {
+ *   useHasValueListener('open', () =>
+ *     console.log('Value existence changed'),
+ *   );
+ *   return <span>App</span>;
+ * };
+ *
+ * const store = createStore();
+ * const app = document.createElement('div');
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App store={store} />); // !act
+ * console.log(store.getListenerStats().hasValue);
+ * // -> 1
+ *
+ * store.setValue('open', false); // !act
+ * // -> 'Value existence changed'
+ *
+ * root.unmount(); // !act
+ * console.log(store.getListenerStats().hasValue);
+ * // -> 0
+ * ```
+ * @category Store hooks
+ * @since v4.4.0
+ */
+  useHasValueListener: <
+    ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null,
+  >(
+    valueId: ValueIdOrNull,
+    listener: HasValueListener<Schemas, ValueIdOrNull>,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
+
   /**
  * The useValueListener hook registers a listener function with a Store that
  * will be called whenever data in a Value changes.