tinybase 4.4.0-beta.1 → 4.4.0

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

@@ -28,6 +28,13 @@ import {
   CellIdsListener,
   CellListener,
   CellOrUndefined,
+  HasCellListener,
+  HasRowListener,
+  HasTableCellListener,
+  HasTableListener,
+  HasTablesListener,
+  HasValueListener,
+  HasValuesListener,
   MapCell,
   MapValue,
   Row,
@@ -420,6 +427,84 @@ export function useStoreOrStoreById(
   storeOrStoreId?: StoreOrStoreId,
 ): Store | 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.
+ *
+ * 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
+ */
+export function useHasTables(storeOrStoreId?: StoreOrStoreId): 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
@@ -572,6 +657,92 @@ export function useTables(storeOrStoreId?: StoreOrStoreId): Tables;
  */
 export function useTableIds(storeOrStoreId?: StoreOrStoreId): Ids;
 
+/**
+ * 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.
+ *
+ * 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
+ */
+export function useHasTable(
+  tableId: Id,
+  storeOrStoreId?: StoreOrStoreId,
+): 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
@@ -736,6 +907,98 @@ export function useTableCellIds(
   storeOrStoreId?: StoreOrStoreId,
 ): Ids;
 
+/**
+ * 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.
+ *
+ * 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
+ */
+export function useHasTableCell(
+  tableId: Id,
+  cellId: Id,
+  storeOrStoreId?: StoreOrStoreId,
+): 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
@@ -1014,15 +1277,15 @@ export function useSortedRowIds(
 ): 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.
  *
  * 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
@@ -1032,30 +1295,31 @@ export function useSortedRowIds(
  * @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 useRow hook.
+ * provided. A component within it then uses the useHasRow hook.
  *
  * ```jsx
  * const App = ({store}) => (
@@ -1063,17 +1327,19 @@ export function useSortedRowIds(
  *     <Pane />
  *   </Provider>
  * );
- * const Pane = () => <span>{JSON.stringify(useRow('pets', 'fido'))}</span>;
+ * 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>{"color":"brown"}</span>'
+ * // -> '<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 useRow hook.
+ * by Id. A component within it then uses the useHasRow hook.
  *
  * ```jsx
  * const App = ({store}) => (
@@ -1082,36 +1348,123 @@ export function useSortedRowIds(
  *   </Provider>
  * );
  * const Pane = () => (
- *   <span>{JSON.stringify(useRow('pets', 'fido', 'petStore'))}</span>
+ *   <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>{"color":"brown"}</span>'
+ * // -> '<span>false</span>'
  * ```
  * @category Store hooks
+ * @since v4.4.0
  */
-export function useRow(
+export function useHasRow(
   tableId: Id,
   rowId: Id,
   storeOrStoreId?: StoreOrStoreId,
-): Row;
+): boolean;
 
 /**
- * The useCellIds hook returns the Ids of every Cell in a given Row, in a given
- * Table, and registers a listener so that any changes to that result will cause
- * a re-render.
+ * 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.
  *
  * 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
- * useCellIds hook lets you indicate which Store to get data for: omit 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
- * Cell Ids will cause a re-render. When the component containing this hook is
+ * 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
+ * provided. A component within it then uses the useRow hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => <span>{JSON.stringify(useRow('pets', 'fido'))}</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>{"color":"brown"}</span>'
+ * ```
+ * @example
+ * This example creates a Provider context into which a Store is provided, named
+ * by Id. A component within it then uses the useRow hook.
+ *
+ * ```jsx
+ * const App = ({store}) => (
+ *   <Provider storesById={{petStore: store}}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => (
+ *   <span>{JSON.stringify(useRow('pets', 'fido', '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>{"color":"brown"}</span>'
+ * ```
+ * @category Store hooks
+ */
+export function useRow(
+  tableId: Id,
+  rowId: Id,
+  storeOrStoreId?: StoreOrStoreId,
+): Row;
+
+/**
+ * The useCellIds hook returns the Ids of every Cell in a given Row, in a given
+ * Table, and registers a listener so that any changes to that result will cause
+ * a re-render.
+ *
+ * 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
+ * useCellIds hook lets you indicate which Store to get data for: omit the
+ * 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
+ * Cell Ids 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.
@@ -1187,6 +1540,100 @@ export function useCellIds(
   storeOrStoreId?: StoreOrStoreId,
 ): Ids;
 
+/**
+ * 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.
+ *
+ * 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
+ */
+export function useHasCell(
+  tableId: Id,
+  rowId: Id,
+  cellId: Id,
+  storeOrStoreId?: StoreOrStoreId,
+): 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
@@ -1273,6 +1720,84 @@ export function useCell(
   storeOrStoreId?: StoreOrStoreId,
 ): CellOrUndefined;
 
+/**
+ * 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.
+ *
+ * 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
+ */
+export function useHasValues(storeOrStoreId?: StoreOrStoreId): 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
@@ -1426,6 +1951,92 @@ export function useValues(storeOrStoreId?: StoreOrStoreId): Values;
  */
 export function useValueIds(storeOrStoreId?: StoreOrStoreId): Ids;
 
+/**
+ * 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.
+ *
+ * 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
+ */
+export function useHasValue(
+  valueId: Id,
+  storeOrStoreId?: StoreOrStoreId,
+): 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
@@ -2728,6 +3339,70 @@ export function useDelValueCallback(
   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 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
+ *
+ * store.setCell('pets', 'fido', 'color', 'brown'); // !act
+ * // -> 'Tables existence changed'
+ *
+ * root.unmount(); // !act
+ * console.log(store.getListenerStats().hasTables);
+ * // -> 0
+ * ```
+ * @category Store hooks
+ * @since v4.4.0
+ */
+export function useHasTablesListener(
+  listener: HasTablesListener,
+  listenerDeps?: React.DependencyList,
+  mutator?: boolean,
+  storeOrStoreId?: StoreOrStoreId,
+): void;
+
 /**
  * The useTablesListener hook registers a listener function with a Store that
  * will be called whenever tabular data in it changes.
@@ -2851,6 +3526,76 @@ export function useTableIdsListener(
   storeOrStoreId?: StoreOrStoreId,
 ): 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 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
+ */
+export function useHasTableListener(
+  tableId: IdOrNull,
+  listener: HasTableListener,
+  listenerDeps?: React.DependencyList,
+  mutator?: boolean,
+  storeOrStoreId?: StoreOrStoreId,
+): void;
+
 /**
  * The useTableListener hook registers a listener function with a Store that
  * will be called whenever data in a Table changes.
@@ -2889,7 +3634,75 @@ export function useTableIdsListener(
  *   </Provider>
  * );
  * const Pane = () => {
- *   useTableListener('pets', () => console.log('Table changed'));
+ *   useTableListener('pets', () => console.log('Table changed'));
+ *   return <span>App</span>;
+ * };
+ *
+ * const store = createStore().setTables({pets: {fido: {color: 'brown'}}});
+ * const app = document.createElement('div');
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App store={store} />); // !act
+ * console.log(store.getListenerStats().table);
+ * // -> 1
+ *
+ * store.setCell('pets', 'fido', 'color', 'walnut'); // !act
+ * // -> 'Table changed'
+ *
+ * root.unmount(); // !act
+ * console.log(store.getListenerStats().table);
+ * // -> 0
+ * ```
+ * @category Store hooks
+ */
+export function useTableListener(
+  tableId: IdOrNull,
+  listener: TableListener,
+  listenerDeps?: React.DependencyList,
+  mutator?: boolean,
+  storeOrStoreId?: StoreOrStoreId,
+): void;
+
+/**
+ * The useTableCellIdsListener hook registers a listener function with a Store
+ * that will be called whenever the Cell Ids that appear anywhere in a Table
+ * change.
+ *
+ * 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 useTableCellIds 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 `null`).
+ *
+ * Unlike the addTableCellIdsListener method, which returns a listener Id and
+ * requires you to remove it manually, the useTableCellIdsListener 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 Cell Ids that
+ * appear anywhere in a Table change.
+ * @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 useTableCellIdsListener 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 = () => {
+ *   useTableCellIdsListener('pets', () => console.log('Cell Ids changed'));
  *   return <span>App</span>;
  * };
  *
@@ -2897,46 +3710,48 @@ export function useTableIdsListener(
  * const app = document.createElement('div');
  * const root = ReactDOMClient.createRoot(app);
  * root.render(<App store={store} />); // !act
- * console.log(store.getListenerStats().table);
+ * console.log(store.getListenerStats().tableCellIds);
  * // -> 1
  *
- * store.setCell('pets', 'fido', 'color', 'walnut'); // !act
- * // -> 'Table changed'
+ * store.setRow('pets', 'felix', {species: 'cat'}); // !act
+ * // -> 'Cell Ids changed'
  *
  * root.unmount(); // !act
- * console.log(store.getListenerStats().table);
+ * console.log(store.getListenerStats().rowIds);
  * // -> 0
  * ```
  * @category Store hooks
  */
-export function useTableListener(
+export function useTableCellIdsListener(
   tableId: IdOrNull,
-  listener: TableListener,
+  listener: TableCellIdsListener,
   listenerDeps?: React.DependencyList,
   mutator?: boolean,
   storeOrStoreId?: StoreOrStoreId,
 ): void;
 
 /**
- * The useTableCellIdsListener hook registers a listener function with a Store
- * that will be called whenever the Cell Ids that appear anywhere in a Table
- * change.
+ * 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 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 useTableCellIds hook).
+ * more easily done with the useHasTableCell 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 `null`).
+ * 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 addTableCellIdsListener method, which returns a listener Id and
- * requires you to remove it manually, the useTableCellIdsListener hook manages
+ * 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 listener The function that will be called whenever the Cell Ids that
- * appear anywhere in a Table change.
+ * @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.
@@ -2946,7 +3761,7 @@ export function useTableListener(
  * default context Store, provide an Id for a named context Store, or provide an
  * explicit reference.
  * @example
- * This example uses the useTableCellIdsListener hook to create a listener that
+ * 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.
  *
@@ -2957,29 +3772,33 @@ export function useTableListener(
  *   </Provider>
  * );
  * const Pane = () => {
- *   useTableCellIdsListener('pets', () => console.log('Cell Ids changed'));
+ *   useHasTableCellListener('pets', 'color', () =>
+ *     console.log('Table Cell existence changed'),
+ *   );
  *   return <span>App</span>;
  * };
  *
- * const store = createStore().setTables({pets: {fido: {color: 'brown'}}});
+ * const store = createStore();
  * const app = document.createElement('div');
  * const root = ReactDOMClient.createRoot(app);
  * root.render(<App store={store} />); // !act
- * console.log(store.getListenerStats().tableCellIds);
+ * console.log(store.getListenerStats().hasTableCell);
  * // -> 1
  *
- * store.setRow('pets', 'felix', {species: 'cat'}); // !act
- * // -> 'Cell Ids changed'
+ * store.setRow('pets', 'fido', {color: 'brown'}); // !act
+ * // -> 'Table Cell existence changed'
  *
  * root.unmount(); // !act
- * console.log(store.getListenerStats().rowIds);
+ * console.log(store.getListenerStats().hasTableCell);
  * // -> 0
  * ```
  * @category Store hooks
+ * @since v4.4.0
  */
-export function useTableCellIdsListener(
+export function useHasTableCellListener(
   tableId: IdOrNull,
-  listener: TableCellIdsListener,
+  cellId: IdOrNull,
+  listener: HasTableCellListener,
   listenerDeps?: React.DependencyList,
   mutator?: boolean,
   storeOrStoreId?: StoreOrStoreId,
@@ -3201,6 +4020,83 @@ export function useSortedRowIdsListener(
   storeOrStoreId?: StoreOrStoreId,
 ): 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 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}) => (
+ *   <Provider store={store}>
+ *     <Pane />
+ *   </Provider>
+ * );
+ * const Pane = () => {
+ *   useHasRowListener('pets', 'fido', () =>
+ *     console.log('Row 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().hasRow);
+ * // -> 1
+ *
+ * store.setCell('pets', 'fido', 'color', 'walnut'); // !act
+ * // -> 'Row existence changed'
+ *
+ * root.unmount(); // !act
+ * console.log(store.getListenerStats().hasRow);
+ * // -> 0
+ * ```
+ * @category Store hooks
+ * @since v4.4.0
+ */
+export function useHasRowListener(
+  tableId: IdOrNull,
+  rowId: IdOrNull,
+  listener: HasRowListener,
+  listenerDeps?: React.DependencyList,
+  mutator?: boolean,
+  storeOrStoreId?: StoreOrStoreId,
+): void;
+
 /**
  * The useRowListener hook registers a listener function with a Store that will
  * be called whenever data in a Row changes.
@@ -3352,6 +4248,86 @@ export function useCellIdsListener(
   storeOrStoreId?: StoreOrStoreId,
 ): 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 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
+ */
+export function useHasCellListener(
+  tableId: IdOrNull,
+  rowId: IdOrNull,
+  cellId: IdOrNull,
+  listener: HasCellListener,
+  listenerDeps?: React.DependencyList,
+  mutator?: boolean,
+  storeOrStoreId?: StoreOrStoreId,
+): void;
+
 /**
  * The useCellListener hook registers a listener function with a Store that will
  * be called whenever data in a Cell changes.
@@ -3430,6 +4406,70 @@ export function useCellListener(
   storeOrStoreId?: StoreOrStoreId,
 ): 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 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
+ */
+export function useHasValuesListener(
+  listener: HasValuesListener,
+  listenerDeps?: React.DependencyList,
+  mutator?: boolean,
+  storeOrStoreId?: StoreOrStoreId,
+): void;
+
 /**
  * The useValuesListener hook registers a listener function with a Store that
  * will be called whenever keyed value data in it changes.
@@ -3555,6 +4595,77 @@ export function useValueIdsListener(
   storeOrStoreId?: StoreOrStoreId,
 ): 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 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
+ */
+export function useHasValueListener(
+  valueId: IdOrNull,
+  listener: HasValueListener,
+  listenerDeps?: React.DependencyList,
+  mutator?: boolean,
+  storeOrStoreId?: StoreOrStoreId,
+): void;
+
 /**
  * The useValueListener hook registers a listener function with a Store that
  * will be called whenever data in a Value changes.