tinybase 8.1.0-beta.3 → 8.1.0-beta.4

package/@types/ui-svelte/with-schemas/index.d.ts

@@ -100,17 +100,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * The MaybeGetter type represents a value that can be provided either as a
  * plain value or as a reactive getter function.
  *
- * When a getter function is provided to a hook, the hook's internal `$effect`
- * will re-run whenever the getter's reactive dependencies change. This is the
- * mechanism that makes Svelte 5 props reactive in hooks.
+ * When a getter function is provided to a reactive function, its internal
+ * `$effect` will re-run whenever the getter's reactive dependencies change.
+ * This is the mechanism that makes Svelte 5 props reactive in these functions.
  * @category Identity
  * @since v8.1.0
  */
   MaybeGetter: <T>(t: T) => T | (() => T);
 
   /**
- * The StoreOrStoreId type is used when you need to refer to a Store in a Svelte
- * hook or component.
+ * The StoreOrStoreId type is used when you need to refer to a Store in a
+ * ui-svelte function or component.
  *
  * This has schema-based typing. The following is a simplified representation:
  *
@@ -124,7 +124,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * multiple Store objects into a context that can be used throughout the app. In
  * this case you will want to refer to a Store by its Id in that context.
  *
- * Many hooks and components in this ui-svelte module take this type as a
+ * Many functions and components in this ui-svelte module take this type as a
  * parameter or a prop, allowing you to pass in either the Store or its Id.
  * @category Identity
  * @since v8.1.0
@@ -133,7 +133,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
 
   /**
  * The MetricsOrMetricsId type is used when you need to refer to a Metrics
- * object in a Svelte hook or component.
+ * object in a ui-svelte function or component.
  *
  * This has schema-based typing. The following is a simplified representation:
  *
@@ -141,17 +141,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * Metrics | Id;
  * ```
  *
- * In some simple cases you will already have a direct reference to the Metrics
- * object.
+ * In some simple cases you will already have a direct reference to the
+ * Metrics object.
  *
  * This module also includes a Provider component that can be used to wrap
  * multiple Metrics objects into a context that can be used throughout the app.
- * In this case you will want to refer to a Metrics object by its Id in that
- * context.
+ * In this case you will want to refer to a Metrics object by its Id in
+ * that context.
  *
- * Many hooks and components in this ui-svelte module take this type as a
- * parameter or a prop, allowing you to pass in either the Metrics object or its
- * Id.
+ * Many functions and components in this ui-svelte module take this type as a
+ * parameter or a prop, allowing you to pass in either the Metrics object or
+ * its Id.
  * @category Identity
  * @since v8.1.0
  */
@@ -159,7 +159,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
 
   /**
  * The IndexesOrIndexesId type is used when you need to refer to an Indexes
- * object in a Svelte hook or component.
+ * object in a ui-svelte function or component.
  *
  * This has schema-based typing. The following is a simplified representation:
  *
@@ -167,17 +167,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * Indexes | Id;
  * ```
  *
- * In some simple cases you will already have a direct reference to the Indexes
- * object.
+ * In some simple cases you will already have a direct reference to the
+ * Indexes object.
  *
  * This module also includes a Provider component that can be used to wrap
  * multiple Indexes objects into a context that can be used throughout the app.
- * In this case you will want to refer to an Indexes object by its Id in that
- * context.
+ * In this case you will want to refer to an Indexes object by its Id in
+ * that context.
  *
- * Many hooks and components in this ui-svelte module take this type as a
- * parameter or a prop, allowing you to pass in either the Indexes object or its
- * Id.
+ * Many functions and components in this ui-svelte module take this type as a
+ * parameter or a prop, allowing you to pass in either the Indexes object or
+ * its Id.
  * @category Identity
  * @since v8.1.0
  */
@@ -185,7 +185,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
 
   /**
  * The RelationshipsOrRelationshipsId type is used when you need to refer to a
- * Relationships object in a Svelte hook or component.
+ * Relationships object in a ui-svelte function or component.
  *
  * This has schema-based typing. The following is a simplified representation:
  *
@@ -201,7 +201,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * app. In this case you will want to refer to a Relationships object by its Id
  * in that context.
  *
- * Many hooks and components in this ui-svelte module take this type as a
+ * Many functions and components in this ui-svelte module take this type as a
  * parameter or a prop, allowing you to pass in either the Relationships object
  * or its Id.
  * @category Identity
@@ -211,7 +211,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
 
   /**
  * The QueriesOrQueriesId type is used when you need to refer to a Queries
- * object in a Svelte hook or component.
+ * object in a ui-svelte function or component.
  *
  * This has schema-based typing. The following is a simplified representation:
  *
@@ -219,17 +219,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * Queries | Id;
  * ```
  *
- * In some simple cases you will already have a direct reference to the Queries
- * object.
+ * In some simple cases you will already have a direct reference to the
+ * Queries object.
  *
  * This module also includes a Provider component that can be used to wrap
  * multiple Queries objects into a context that can be used throughout the app.
- * In this case you will want to refer to a Queries object by its Id in that
- * context.
+ * In this case you will want to refer to a Queries object by its Id in
+ * that context.
  *
- * Many hooks and components in this ui-svelte module take this type as a
- * parameter or a prop, allowing you to pass in either the Queries object or its
- * Id.
+ * Many functions and components in this ui-svelte module take this type as a
+ * parameter or a prop, allowing you to pass in either the Queries object or
+ * its Id.
  * @category Identity
  * @since v8.1.0
  */
@@ -237,7 +237,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
 
   /**
  * The CheckpointsOrCheckpointsId type is used when you need to refer to a
- * Checkpoints object in a Svelte hook or component.
+ * Checkpoints object in a ui-svelte function or component.
  *
  * This has schema-based typing. The following is a simplified representation:
  *
@@ -253,7 +253,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * app. In this case you will want to refer to a Checkpoints object by its Id in
  * that context.
  *
- * Many hooks and components in this ui-svelte module take this type as a
+ * Many functions and components in this ui-svelte module take this type as a
  * parameter or a prop, allowing you to pass in either the Checkpoints object or
  * its Id.
  * @category Identity
@@ -263,7 +263,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
 
   /**
  * The PersisterOrPersisterId type is used when you need to refer to a Persister
- * object in a Svelte hook or component.
+ * object in a ui-svelte function or component.
  *
  * This has schema-based typing. The following is a simplified representation:
  *
@@ -279,7 +279,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * app. In this case you will want to refer to a Persister object by its Id in
  * that context.
  *
- * Many hooks and components in this ui-svelte module take this type as a
+ * Many functions and components in this ui-svelte module take this type as a
  * parameter or a prop, allowing you to pass in either the Persister or its Id.
  * @category Identity
  * @since v8.1.0
@@ -288,7 +288,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
 
   /**
  * The SynchronizerOrSynchronizerId type is used when you need to refer to a
- * Synchronizer object in a Svelte hook or component.
+ * Synchronizer object in a ui-svelte function or component.
  *
  * This has schema-based typing. The following is a simplified representation:
  *
@@ -304,9 +304,9 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * app. In this case you will want to refer to a Synchronizer object by its Id
  * in that context.
  *
- * Many hooks and components in this ui-svelte module take this type as a
- * parameter or a prop, allowing you to pass in either the Synchronizer or its
- * Id.
+ * Many functions and components in this ui-svelte module take this type as a
+ * parameter or a prop, allowing you to pass in either the Synchronizer or
+ * its Id.
  * @category Identity
  * @since v8.1.0
  */
@@ -536,8 +536,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   };
 
   /**
- * The CheckpointViewProps type describes the props of the CheckpointView
- * component.
+ * The CheckpointViewProps type describes the props of the
+ * CheckpointView component.
  * @category Props
  * @since v8.1.0
  */
@@ -657,8 +657,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   };
 
   /**
- * The SortedTableViewProps type describes the props of the SortedTableView
- * component.
+ * The SortedTableViewProps type describes the props of the
+ * SortedTableView component.
  * @category Props
  * @since v8.1.0
  */
@@ -872,8 +872,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   };
 
   /**
- * The RemoteRowViewProps type describes the props of the RemoteRowView
- * component.
+ * The RemoteRowViewProps type describes the props of the
+ * RemoteRowView component.
  * @category Props
  * @since v8.1.0
  */
@@ -911,8 +911,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   };
 
   /**
- * The LocalRowsViewProps type describes the props of the LocalRowsView
- * component.
+ * The LocalRowsViewProps type describes the props of the
+ * LocalRowsView component.
  * @category Props
  * @since v8.1.0
  */
@@ -956,8 +956,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   };
 
   /**
- * The LinkedRowsViewProps type describes the props of the LinkedRowsView
- * component.
+ * The LinkedRowsViewProps type describes the props of the
+ * LinkedRowsView component.
  * @category Props
  * @since v8.1.0
  */
@@ -1001,8 +1001,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   };
 
   /**
- * The ResultCellViewProps type describes the props of the ResultCellView
- * component.
+ * The ResultCellViewProps type describes the props of the
+ * ResultCellView component.
  * @category Props
  * @since v8.1.0
  */
@@ -1040,8 +1040,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   };
 
   /**
- * The ResultRowViewProps type describes the props of the ResultRowView
- * component.
+ * The ResultRowViewProps type describes the props of the
+ * ResultRowView component.
  * @category Props
  * @since v8.1.0
  */
@@ -1085,8 +1085,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   };
 
   /**
- * The ResultTableViewProps type describes the props of the ResultTableView
- * component.
+ * The ResultTableViewProps type describes the props of the
+ * ResultTableView component.
  * @category Props
  * @since v8.1.0
  */
@@ -1320,8 +1320,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
 
   /**
  * The ValueView component renders the value of a single Value in a Store, and
- * registers a listener so that any changes to that result will cause a
- * re-render.
+ * registers a listener so that any changes to that result will cause
+ * a re-render.
  * @param props The props for this component.
  * @returns A rendering of the Value, or nothing if not present.
  * @category Component
@@ -1331,8 +1331,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
 
   /**
  * The RowView component renders the contents of a single Row in a given Table,
- * and registers a listener so that any changes to that result will cause a
- * re-render.
+ * and registers a listener so that any changes to that result will cause
+ * a re-render.
  * @param props The props for this component.
  * @returns A rendering of the Row, or nothing if not present.
  * @category Component
@@ -1363,8 +1363,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
 
   /**
  * The TablesView component renders the contents of all Tables in a Store, and
- * registers a listener so that any changes to that result will cause a
- * re-render.
+ * registers a listener so that any changes to that result will cause
+ * a re-render.
  * @param props The props for this component.
  * @returns A rendering of all Tables.
  * @category Component
@@ -1405,8 +1405,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
 
   /**
  * The SliceView component renders the Row Ids in a named Slice in an Index, and
- * registers a listener so that any changes to that result will cause a
- * re-render.
+ * registers a listener so that any changes to that result will cause
+ * a re-render.
  * @param props The props for this component.
  * @returns A rendering of the Rows in the Slice.
  * @category Component
@@ -1438,8 +1438,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
 
   /**
  * The LinkedRowsView component renders the Rows in a linked list Relationship,
- * and registers a listener so that any changes to that result will cause a
- * re-render.
+ * and registers a listener so that any changes to that result will cause
+ * a re-render.
  * @param props The props for this component.
  * @returns A rendering of the linked Row Ids.
  * @category Component
@@ -1544,144 +1544,144 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   >;
 
   /**
- * The useHasTables hook returns a reactive object indicating whether any Tables
- * exist in the Store, and registers a listener so that any changes to that
- * result will update `.current`.
+ * The createHasTables function returns a reactive object indicating whether any
+ * Tables exist in the Store, and registers a listener so that any changes to
+ * that result will update `.current`.
  * @param storeOrStoreId The Store to use, or its Id in a Provider context.
  * @returns A reactive object with a `current` boolean property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useHasTables: (
+  createHasTables: (
     storeOrStoreId?: MaybeGetter<StoreOrStoreId<Schemas> | undefined>,
   ) => {
     readonly current: boolean;
   };
 
   /**
- * The useTables hook returns a reactive object reflecting the Tables in the
- * Store, and registers a listener so that any changes to those Tables will
+ * The createTables function returns a reactive object reflecting the Tables in
+ * the Store, and registers a listener so that any changes to those Tables will
  * update `.current`.
  * @param storeOrStoreId The Store to use, or its Id in a Provider context.
  * @returns A reactive object with a `current` Tables property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useTables: (
+  createTables: (
     storeOrStoreId?: MaybeGetter<StoreOrStoreId<Schemas> | undefined>,
   ) => {
     readonly current: Tables<Schemas[0]>;
   };
 
   /**
- * The useTableIds hook returns a reactive object reflecting the Ids of the
- * Tables in a Store, and registers a listener so that any changes to those Ids
- * will update `.current`.
+ * The createTableIds function returns a reactive object reflecting the Ids of
+ * the Tables in a Store, and registers a listener so that any changes to those
+ * Ids will update `.current`.
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useTableIds: (storeOrStoreId?: StoreOrStoreId<Schemas>) => {
+  createTableIds: (storeOrStoreId?: StoreOrStoreId<Schemas>) => {
     readonly current: TableIdFromSchema<Schemas[0]>[];
   };
 
   /**
- * The useHasTable hook returns a reactive object indicating whether a Table
- * exists in the Store, and registers a listener so that any changes to that
- * result will update `.current`.
+ * The createHasTable function returns a reactive object indicating whether a
+ * Table exists in the Store, and registers a listener so that any changes to
+ * that result will update `.current`.
  * @param tableId The Id of the Table (or a getter returning it).
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` boolean property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useHasTable: <TableId extends TableIdFromSchema<Schemas[0]>>(
+  createHasTable: <TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: MaybeGetter<TableId>,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => {readonly current: boolean};
 
   /**
- * The useTable hook returns a reactive object reflecting a Table in a Store,
- * and registers a listener so that any changes to that Table will update
- * `.current`.
+ * The createTable function returns a reactive object reflecting a Table in a
+ * Store, and registers a listener so that any changes to that Table will
+ * update `.current`.
  * @param tableId The Id of the Table (or a getter returning it).
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` Table property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useTable: <TableId extends TableIdFromSchema<Schemas[0]>>(
+  createTable: <TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: MaybeGetter<TableId>,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => {readonly current: Table<Schemas[0], TableId>};
 
   /**
- * The useTableCellIds hook returns a reactive object reflecting the Ids of all
- * Cells used across a Table, and registers a listener so that any changes to
- * those Ids will update `.current`.
+ * The createTableCellIds function returns a reactive object reflecting the Ids
+ * of all Cells used across a Table, and registers a listener so that any
+ * changes to those Ids will update `.current`.
  * @param tableId The Id of the Table (or a getter returning it).
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useTableCellIds: <TableId extends TableIdFromSchema<Schemas[0]>>(
+  createTableCellIds: <TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: MaybeGetter<TableId>,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => {readonly current: CellIdFromSchema<Schemas[0], TableId>[]};
 
   /**
- * The useHasTableCell hook returns a reactive object indicating whether a
- * particular Cell is used anywhere in a Table, and registers a listener so that
- * any changes to that result will update `.current`.
+ * The createHasTableCell function returns a reactive object indicating whether
+ * a particular Cell is used anywhere in a Table, and registers a listener so
+ * that any changes to that result will update `.current`.
  * @param tableId The Id of the Table (or a getter returning it).
  * @param cellId The Id of the Cell (or a getter returning it).
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` boolean property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useHasTableCell: <TableId extends TableIdFromSchema<Schemas[0]>>(
+  createHasTableCell: <TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: MaybeGetter<TableId>,
     cellId: MaybeGetter<CellIdFromSchema<Schemas[0], TableId>>,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => {readonly current: boolean};
 
   /**
- * The useRowCount hook returns a reactive object reflecting the number of Rows
- * in a Table, and registers a listener so that any changes will update
- * `.current`.
+ * The createRowCount function returns a reactive object reflecting the number
+ * of Rows in a Table, and registers a listener so that any changes will
+ * update `.current`.
  * @param tableId The Id of the Table (or a getter returning it).
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` number property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useRowCount: (
+  createRowCount: (
     tableId: MaybeGetter<TableIdFromSchema<Schemas[0]>>,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => {readonly current: number};
 
   /**
- * The useRowIds hook returns a reactive object reflecting the Ids of the Rows
- * in a Table, and registers a listener so that any changes will update
- * `.current`.
+ * The createRowIds function returns a reactive object reflecting the Ids of the
+ * Rows in a Table, and registers a listener so that any changes will
+ * update `.current`.
  * @param tableId The Id of the Table (or a getter returning it).
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useRowIds: (
+  createRowIds: (
     tableId: MaybeGetter<TableIdFromSchema<Schemas[0]>>,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => {readonly current: Ids};
 
   /**
- * The useSortedRowIds hook returns a reactive object reflecting the sorted Row
- * Ids in a Table, and registers a listener so that any changes will update
- * `.current`.
+ * The createSortedRowIds function returns a reactive object reflecting the
+ * sorted Row Ids in a Table, and registers a listener so that any changes will
+ * update `.current`.
  * @param tableId The Id of the Table (or a getter returning it).
  * @param cellId The Id of the Cell to sort by (or a getter returning it).
  * @param descending Whether to sort descending (or a getter returning it).
@@ -1689,10 +1689,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param limit The maximum number of Rows to return (or a getter returning it).
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useSortedRowIds: <TableId extends TableIdFromSchema<Schemas[0]>>(
+  createSortedRowIds: <TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: MaybeGetter<TableId>,
     cellId?: MaybeGetter<CellIdFromSchema<Schemas[0], TableId> | undefined>,
     descending?: MaybeGetter<boolean>,
@@ -1702,68 +1702,69 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => {readonly current: Ids};
 
   /**
- * The useHasRow hook returns a reactive object indicating whether a Row exists
- * in a Table, and registers a listener so that any changes to that result will
- * update `.current`.
+ * The createHasRow function returns a reactive object indicating whether a Row
+ * exists in a Table, and registers a listener so that any changes to that
+ * result will update `.current`.
  * @param tableId The Id of the Table (or a getter returning it).
  * @param rowId The Id of the Row (or a getter returning it).
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` boolean property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useHasRow: (
+  createHasRow: (
     tableId: MaybeGetter<TableIdFromSchema<Schemas[0]>>,
     rowId: MaybeGetter<Id>,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => {readonly current: boolean};
 
   /**
- * The useRow hook returns a reactive object reflecting a Row in a Table, and
- * registers a listener so that any changes to that Row will update `.current`.
+ * The createRow function returns a reactive object reflecting a Row in a Table,
+ * and registers a listener so that any changes to that Row will
+ * update `.current`.
  * @param tableId The Id of the Table (or a getter returning it).
  * @param rowId The Id of the Row (or a getter returning it).
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` Row property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useRow: <TableId extends TableIdFromSchema<Schemas[0]>>(
+  createRow: <TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: MaybeGetter<TableId>,
     rowId: MaybeGetter<Id>,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => {readonly current: Row<Schemas[0], TableId>};
 
   /**
- * The useCellIds hook returns a reactive object reflecting the Ids of the Cells
- * in a Row, and registers a listener so that any changes will update
- * `.current`.
+ * The createCellIds function returns a reactive object reflecting the Ids of
+ * the Cells in a Row, and registers a listener so that any changes will
+ * update `.current`.
  * @param tableId The Id of the Table (or a getter returning it).
  * @param rowId The Id of the Row (or a getter returning it).
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useCellIds: <TableId extends TableIdFromSchema<Schemas[0]>>(
+  createCellIds: <TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: MaybeGetter<TableId>,
     rowId: MaybeGetter<Id>,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => {readonly current: CellIdFromSchema<Schemas[0], TableId>[]};
 
   /**
- * The useHasCell hook returns a reactive object indicating whether a Cell
- * exists in a Row in a Table, and registers a listener so that any changes to
- * that result will update `.current`.
+ * The createHasCell function returns a reactive object indicating whether a
+ * Cell exists in a Row in a Table, and registers a listener so that any changes
+ * to that result will update `.current`.
  * @param tableId The Id of the Table (or a getter returning it).
  * @param rowId The Id of the Row (or a getter returning it).
  * @param cellId The Id of the Cell (or a getter returning it).
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` boolean property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useHasCell: <
+  createHasCell: <
     TableId extends TableIdFromSchema<Schemas[0]>,
     CellId extends CellIdFromSchema<Schemas[0], TableId>,
   >(
@@ -1774,61 +1775,41 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => {readonly current: boolean};
 
   /**
- * The useCell hook returns a reactive object reflecting the value of a Cell in
- * a Row in a Table, and registers a listener so that any changes to that Cell
- * will update `.current`.
- * @param tableId The Id of the Table (or a getter returning it).
- * @param rowId The Id of the Row (or a getter returning it).
- * @param cellId The Id of the Cell (or a getter returning it).
- * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
- * @returns A reactive object with a `current` CellOrUndefined property.
- * @example
- * This example uses the useCell hook to display a Cell value reactively.
+ * The createCell function returns a reactive object reflecting the value of a
+ * Cell in a Row in a Table, and registers a listener so that any changes to
+ * that Cell will update `.current`.
  *
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * useCell(
+ * createCell(
  *   tableId: MaybeGetter<Id>,
  *   rowId: MaybeGetter<Id>,
  *   cellId: MaybeGetter<Id>,
  *   storeOrStoreId?: MaybeGetter<StoreOrStoreId | undefined>,
- * ): {readonly current: CellOrUndefined};
+ * ): {get current(): CellOrUndefined; set current(v: Cell)};
  * ```
  *
- * ```ts
- * // In a .svelte file:
- * // const store = createStore().setCell('pets', 'cat', 'name', 'Fido');
- * // const name = useCell('pets', 'cat', 'name', store);
- * // $: console.log(name.current); // 'Fido'
- * ```
- * @category Hook
- * @since v8.1.0
- */
-  useCell: <
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    CellId extends CellIdFromSchema<Schemas[0], TableId>,
-  >(
-    tableId: MaybeGetter<TableId>,
-    rowId: MaybeGetter<Id>,
-    cellId: MaybeGetter<CellId>,
-    storeOrStoreId?: StoreOrStoreId<Schemas>,
-  ) => {
-    readonly current: NoInfer<CellOrUndefined<Schemas[0], TableId, CellId>>;
-  };
-
-  /**
- * The useBindableCell hook returns a reactive object reflecting the value of a
- * Cell, with a settable `current` property that writes back to the Store.
+ * Since Cells are mutable leaf values in a Store, the returned object's
+ * `current` property can also be assigned to write back to the Store.
  * @param tableId The Id of the Table (or a getter returning it).
  * @param rowId The Id of the Row (or a getter returning it).
  * @param cellId The Id of the Cell (or a getter returning it).
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with gettable and settable `current`.
- * @category Hook
+ * @example
+ * This example uses the createCell function to display a Cell value reactively.
+ *
+ * ```ts
+ * // In a .svelte file:
+ * // const store = createStore().setCell('pets', 'cat', 'name', 'Fido');
+ * // const name = createCell('pets', 'cat', 'name', store);
+ * // $: console.log(name.current); // 'Fido'
+ * ```
+ * @category Getter
  * @since v8.1.0
  */
-  useBindableCell: <
+  createCell: <
     TableId extends TableIdFromSchema<Schemas[0]>,
     CellId extends CellIdFromSchema<Schemas[0], TableId>,
   >(
@@ -1842,89 +1823,86 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   };
 
   /**
- * The useHasValues hook returns a reactive object indicating whether any Values
- * exist in the Store, and registers a listener so that any changes to that
- * result will update `.current`.
+ * The createHasValues function returns a reactive object indicating whether any
+ * Values exist in the Store, and registers a listener so that any changes to
+ * that result will update `.current`.
  * @param storeOrStoreId The Store to use, or its Id in a Provider context.
  * @returns A reactive object with a `current` boolean property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useHasValues: (
+  createHasValues: (
     storeOrStoreId?: MaybeGetter<StoreOrStoreId<Schemas> | undefined>,
   ) => {
     readonly current: boolean;
   };
 
   /**
- * The useValues hook returns a reactive object reflecting the Values in the
- * Store, and registers a listener so that any changes will update `.current`.
+ * The createValues function returns a reactive object reflecting the Values in
+ * the Store, and registers a listener so that any changes will
+ * update `.current`.
  * @param storeOrStoreId The Store to use, or its Id in a Provider context.
  * @returns A reactive object with a `current` Values property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useValues: (
+  createValues: (
     storeOrStoreId?: MaybeGetter<StoreOrStoreId<Schemas> | undefined>,
   ) => {
     readonly current: Values<Schemas[1]>;
   };
 
   /**
- * The useValueIds hook returns a reactive object reflecting the Ids of the
- * Values in a Store, and registers a listener so that any changes will update
- * `.current`.
+ * The createValueIds function returns a reactive object reflecting the Ids of
+ * the Values in a Store, and registers a listener so that any changes will
+ * update `.current`.
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useValueIds: (storeOrStoreId?: StoreOrStoreId<Schemas>) => {
+  createValueIds: (storeOrStoreId?: StoreOrStoreId<Schemas>) => {
     readonly current: ValueIdFromSchema<Schemas[1]>[];
   };
 
   /**
- * The useHasValue hook returns a reactive object indicating whether a Value
- * exists in the Store, and registers a listener so that any changes to that
- * result will update `.current`.
+ * The createHasValue function returns a reactive object indicating whether a
+ * Value exists in the Store, and registers a listener so that any changes to
+ * that result will update `.current`.
  * @param valueId The Id of the Value (or a getter returning it).
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` boolean property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useHasValue: <ValueId extends ValueIdFromSchema<Schemas[1]>>(
+  createHasValue: <ValueId extends ValueIdFromSchema<Schemas[1]>>(
     valueId: MaybeGetter<ValueId>,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => {readonly current: boolean};
 
   /**
- * The useValue hook returns a reactive object reflecting the value of a Value
- * in a Store, and registers a listener so that any changes to that Value will
- * update `.current`.
- * @param valueId The Id of the Value (or a getter returning it).
- * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
- * @returns A reactive object with a `current` ValueOrUndefined property.
- * @category Hook
- * @since v8.1.0
- */
-  useValue: <ValueId extends ValueIdFromSchema<Schemas[1]>>(
-    valueId: MaybeGetter<ValueId>,
-    storeOrStoreId?: StoreOrStoreId<Schemas>,
-  ) => {
-    readonly current: NoInfer<DefaultedValueFromSchema<Schemas[1], ValueId>>;
-  };
-
-  /**
- * The useBindableValue hook returns a reactive object reflecting the value of a
- * Value, with a settable `current` property that writes back to the Store.
+ * The createValue function returns a reactive object reflecting the value of a
+ * Value in a Store, and registers a listener so that any changes to that Value
+ * will update `.current`.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * createValue(
+ *   valueId: MaybeGetter<Id>,
+ *   storeOrStoreId?: MaybeGetter<StoreOrStoreId | undefined>,
+ * ): {get current(): ValueOrUndefined; set current(v: Value)};
+ * ```
+ *
+ * Since Values are mutable leaf values in a Store, the returned object's
+ * `current` property can also be assigned to write back to the Store.
  * @param valueId The Id of the Value (or a getter returning it).
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with gettable and settable `current`.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useBindableValue: <ValueId extends ValueIdFromSchema<Schemas[1]>>(
+  createValue: <ValueId extends ValueIdFromSchema<Schemas[1]>>(
     valueId: MaybeGetter<ValueId>,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => {
@@ -1933,132 +1911,132 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   };
 
   /**
- * The useStore hook returns the default Store from the current Provider context
- * (or a named Store if an Id is provided).
+ * The getStore function returns the default Store from the current Provider
+ * context (or a named Store if an Id is provided).
  * @param id An optional Id of a named Store in the Provider context.
  * @returns The Store, or `undefined` if not found.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useStore: (id?: Id) => Store<Schemas> | undefined;
+  getStore: (id?: Id) => Store<Schemas> | undefined;
 
   /**
- * The useStoreOrStoreById hook is used to get a reference to a Store object
- * from a Provider context, or have it passed directly.
+ * The resolveStore function is used to get a reference to a Store object from a
+ * Provider context, or have it passed directly.
  * @param storeOrStoreId The Store, its Id, or a getter returning either.
  * @returns A getter function returning the Store, or `undefined`.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useStoreOrStoreById: (
+  resolveStore: (
     storeOrStoreId?: MaybeGetter<StoreOrStoreId<Schemas> | undefined>,
   ) => () => Store<Schemas> | undefined;
 
   /**
- * The useStoreIds hook returns a reactive object with the Ids of all Stores
- * registered in the current Provider context.
+ * The createStoreIds function returns a reactive object with the Ids of all
+ * Stores registered in the current Provider context.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useStoreIds: () => {readonly current: Ids};
+  createStoreIds: () => {readonly current: Ids};
 
   /**
- * The useMetrics hook returns the default Metrics object from the current
+ * The getMetrics function returns the default Metrics object from the current
  * Provider context (or a named one if an Id is provided).
  * @param id An optional Id of a named Metrics object in the Provider context.
  * @returns The Metrics object, or `undefined` if not found.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useMetrics: (id?: Id) => Metrics<Schemas> | undefined;
+  getMetrics: (id?: Id) => Metrics<Schemas> | undefined;
 
   /**
- * The useMetricsOrMetricsById hook is used to get a reference to a Metrics
- * object from a Provider context, or have it passed directly.
+ * The resolveMetrics function is used to get a reference to a Metrics object
+ * from a Provider context, or have it passed directly.
  * @param metricsOrMetricsId The Metrics object, its Id, or a getter returning
  * either.
  * @returns A getter function returning the Metrics object, or `undefined`.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useMetricsOrMetricsById: (
+  resolveMetrics: (
     metricsOrMetricsId?: MaybeGetter<MetricsOrMetricsId<Schemas> | undefined>,
   ) => () => Metrics<Schemas> | undefined;
 
   /**
- * The useMetricsIds hook returns a reactive object with the Ids of all Metrics
- * objects registered in the current Provider context.
+ * The createMetricsIds function returns a reactive object with the Ids of all
+ * Metrics objects registered in the current Provider context.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useMetricsIds: () => {readonly current: Ids};
+  createMetricsIds: () => {readonly current: Ids};
 
   /**
- * The useMetricIds hook returns a reactive object reflecting the Ids of the
- * Metrics in a Metrics object, and registers a listener so that any changes
+ * The createMetricIds function returns a reactive object reflecting the Ids of
+ * the Metrics in a Metrics object, and registers a listener so that any changes
  * will update `.current`.
  * @param metricsOrMetricsId The Metrics object to use, or its Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useMetricIds: (
+  createMetricIds: (
     metricsOrMetricsId?: MaybeGetter<MetricsOrMetricsId<Schemas> | undefined>,
   ) => {
     readonly current: Ids;
   };
 
   /**
- * The useMetric hook returns a reactive object reflecting the value of a named
- * Metric in a Metrics object, and registers a listener so that any changes to
- * that Metric will update `.current`.
+ * The createMetric function returns a reactive object reflecting the value of a
+ * named Metric in a Metrics object, and registers a listener so that any
+ * changes to that Metric will update `.current`.
  * @param metricId The Id of the Metric (or a getter returning it).
  * @param metricsOrMetricsId The Metrics object to use (plain or getter), or its
  * Id.
  * @returns A reactive object with a `current` number | undefined property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useMetric: (
+  createMetric: (
     metricId: MaybeGetter<Id>,
     metricsOrMetricsId?: MetricsOrMetricsId<Schemas>,
   ) => {readonly current: number | undefined};
 
   /**
- * The useIndexes hook returns the default Indexes object from the current
+ * The getIndexes function returns the default Indexes object from the current
  * Provider context (or a named one if an Id is provided).
  * @param id An optional Id of a named Indexes object in the Provider context.
  * @returns The Indexes object, or `undefined` if not found.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useIndexes: (id?: Id) => Indexes<Schemas> | undefined;
+  getIndexes: (id?: Id) => Indexes<Schemas> | undefined;
 
   /**
- * The useIndexesOrIndexesById hook is used to get a reference to an Indexes
- * object from a Provider context, or have it passed directly.
+ * The resolveIndexes function is used to get a reference to an Indexes object
+ * from a Provider context, or have it passed directly.
  * @param indexesOrIndexesId The Indexes object, its Id, or a getter returning
  * either.
  * @returns A getter function returning the Indexes object, or `undefined`.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useIndexesOrIndexesById: (
+  resolveIndexes: (
     indexesOrIndexesId?: MaybeGetter<IndexesOrIndexesId<Schemas> | undefined>,
   ) => () => Indexes<Schemas> | undefined;
 
   /**
- * The useIndexStoreTableId hook returns the Store and table Id for a given
+ * The getIndexStoreTableId function returns the Store and table Id for a given
  * Indexes object and index Id.
  * @param indexesOrId The Indexes object, its Id, or a getter returning either.
  * @param indexId The Id of the index, or a getter returning it.
  * @returns An object with `store` and `tableId` getter properties.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useIndexStoreTableId: (
+  getIndexStoreTableId: (
     indexesOrId: MaybeGetter<IndexesOrIndexesId<Schemas> | undefined>,
     indexId: MaybeGetter<Id>,
   ) => {
@@ -2067,177 +2045,177 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   };
 
   /**
- * The useIndexesIds hook returns a reactive object with the Ids of all Indexes
- * objects registered in the current Provider context.
+ * The createIndexesIds function returns a reactive object with the Ids of all
+ * Indexes objects registered in the current Provider context.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useIndexesIds: () => {readonly current: Ids};
+  createIndexesIds: () => {readonly current: Ids};
 
   /**
- * The useIndexIds hook returns a reactive object reflecting the Ids of the
- * Indexes in an Indexes object, and registers a listener so that any changes
- * will update `.current`.
+ * The createIndexIds function returns a reactive object reflecting the Ids of
+ * the Indexes in an Indexes object, and registers a listener so that any
+ * changes will update `.current`.
  * @param indexesOrIndexesId The Indexes object to use, or its Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useIndexIds: (
+  createIndexIds: (
     indexesOrIndexesId?: MaybeGetter<IndexesOrIndexesId<Schemas> | undefined>,
   ) => {
     readonly current: Ids;
   };
 
   /**
- * The useSliceIds hook returns a reactive object reflecting the Ids of the
- * Slices in an Index, and registers a listener so that any changes will update
- * `.current`.
+ * The createSliceIds function returns a reactive object reflecting the Ids of
+ * the Slices in an Index, and registers a listener so that any changes will
+ * update `.current`.
  * @param indexId The Id of the Index (or a getter returning it).
  * @param indexesOrIndexesId The Indexes object to use (plain or getter), or its
  * Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useSliceIds: (
+  createSliceIds: (
     indexId: MaybeGetter<Id>,
     indexesOrIndexesId?: IndexesOrIndexesId<Schemas>,
   ) => {readonly current: Ids};
 
   /**
- * The useSliceRowIds hook returns a reactive object reflecting the Ids of the
- * Rows in a Slice, and registers a listener so that any changes will update
- * `.current`.
+ * The createSliceRowIds function returns a reactive object reflecting the Ids
+ * of the Rows in a Slice, and registers a listener so that any changes will
+ * update `.current`.
  * @param indexId The Id of the Index (or a getter returning it).
  * @param sliceId The Id of the Slice (or a getter returning it).
  * @param indexesOrIndexesId The Indexes object to use (plain or getter), or its
  * Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useSliceRowIds: (
+  createSliceRowIds: (
     indexId: MaybeGetter<Id>,
     sliceId: MaybeGetter<Id>,
     indexesOrIndexesId?: IndexesOrIndexesId<Schemas>,
   ) => {readonly current: Ids};
 
   /**
- * The useQueries hook returns the default Queries object from the current
+ * The getQueries function returns the default Queries object from the current
  * Provider context (or a named one if an Id is provided).
  * @param id An optional Id of a named Queries object in the Provider context.
  * @returns The Queries object, or `undefined` if not found.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useQueries: (id?: Id) => Queries<Schemas> | undefined;
+  getQueries: (id?: Id) => Queries<Schemas> | undefined;
 
   /**
- * The useQueriesOrQueriesById hook is used to get a reference to a Queries
- * object from a Provider context, or have it passed directly.
+ * The resolveQueries function is used to get a reference to a Queries object
+ * from a Provider context, or have it passed directly.
  * @param queriesOrQueriesId The Queries object, its Id, or a getter returning
  * either.
  * @returns A getter function returning the Queries object, or `undefined`.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useQueriesOrQueriesById: (
+  resolveQueries: (
     queriesOrQueriesId?: MaybeGetter<QueriesOrQueriesId<Schemas> | undefined>,
   ) => () => Queries<Schemas> | undefined;
 
   /**
- * The useQueriesIds hook returns a reactive object with the Ids of all Queries
- * objects registered in the current Provider context.
+ * The createQueriesIds function returns a reactive object with the Ids of all
+ * Queries objects registered in the current Provider context.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useQueriesIds: () => {readonly current: Ids};
+  createQueriesIds: () => {readonly current: Ids};
 
   /**
- * The useQueryIds hook returns a reactive object reflecting the Ids of the
- * Queries in a Queries object, and registers a listener so that any changes
+ * The createQueryIds function returns a reactive object reflecting the Ids of
+ * the Queries in a Queries object, and registers a listener so that any changes
  * will update `.current`.
  * @param queriesOrQueriesId The Queries object to use, or its Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useQueryIds: (
+  createQueryIds: (
     queriesOrQueriesId?: MaybeGetter<QueriesOrQueriesId<Schemas> | undefined>,
   ) => {
     readonly current: Ids;
   };
 
   /**
- * The useResultTable hook returns a reactive object reflecting a result Table
- * in a Queries object, and registers a listener so that any changes to that
- * result will update `.current`.
+ * The createResultTable function returns a reactive object reflecting a result
+ * Table in a Queries object, and registers a listener so that any changes to
+ * that result will update `.current`.
  * @param queryId The Id of the Query (or a getter returning it).
  * @param queriesOrQueriesId The Queries object to use (plain or getter), or its
  * Id.
  * @returns A reactive object with a `current` Table property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useResultTable: (
+  createResultTable: (
     queryId: MaybeGetter<Id>,
     queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
   ) => {readonly current: ResultTable};
 
   /**
- * The useResultTableCellIds hook returns a reactive object reflecting the Ids
- * of all Cells used across a result Table, and registers a listener so that any
- * changes will update `.current`.
+ * The createResultTableCellIds function returns a reactive object reflecting
+ * the Ids of all Cells used across a result Table, and registers a listener so
+ * that any changes will update `.current`.
  * @param queryId The Id of the Query (or a getter returning it).
  * @param queriesOrQueriesId The Queries object to use (plain or getter), or its
  * Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useResultTableCellIds: (
+  createResultTableCellIds: (
     queryId: MaybeGetter<Id>,
     queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
   ) => {readonly current: Ids};
 
   /**
- * The useResultRowCount hook returns a reactive object reflecting the number of
- * Rows in a result Table, and registers a listener so that any changes will
- * update `.current`.
+ * The createResultRowCount function returns a reactive object reflecting the
+ * number of Rows in a result Table, and registers a listener so that any
+ * changes will update `.current`.
  * @param queryId The Id of the Query (or a getter returning it).
  * @param queriesOrQueriesId The Queries object to use (plain or getter), or its
  * Id.
  * @returns A reactive object with a `current` number property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useResultRowCount: (
+  createResultRowCount: (
     queryId: MaybeGetter<Id>,
     queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
   ) => {readonly current: number};
 
   /**
- * The useResultRowIds hook returns a reactive object reflecting the Ids of the
- * Rows in a result Table, and registers a listener so that any changes will
- * update `.current`.
+ * The createResultRowIds function returns a reactive object reflecting the Ids
+ * of the Rows in a result Table, and registers a listener so that any changes
+ * will update `.current`.
  * @param queryId The Id of the Query (or a getter returning it).
  * @param queriesOrQueriesId The Queries object to use (plain or getter), or its
  * Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useResultRowIds: (
+  createResultRowIds: (
     queryId: MaybeGetter<Id>,
     queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
   ) => {readonly current: Ids};
 
   /**
- * The useResultSortedRowIds hook returns a reactive object reflecting the
- * sorted Row Ids in a result Table, and registers a listener so that any
+ * The createResultSortedRowIds function returns a reactive object reflecting
+ * the sorted Row Ids in a result Table, and registers a listener so that any
  * changes will update `.current`.
  * @param queryId The Id of the Query (or a getter returning it).
  * @param cellId The Id of the Cell to sort by (or a getter returning it).
@@ -2247,10 +2225,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param queriesOrQueriesId The Queries object to use (plain or getter), or its
  * Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useResultSortedRowIds: (
+  createResultSortedRowIds: (
     queryId: MaybeGetter<Id>,
     cellId?: MaybeGetter<Id | undefined>,
     descending?: MaybeGetter<boolean>,
@@ -2260,44 +2238,44 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => {readonly current: Ids};
 
   /**
- * The useResultRow hook returns a reactive object reflecting a result Row in a
- * result Table, and registers a listener so that any changes will update
- * `.current`.
+ * The createResultRow function returns a reactive object reflecting a result
+ * Row in a result Table, and registers a listener so that any changes will
+ * update `.current`.
  * @param queryId The Id of the Query (or a getter returning it).
  * @param rowId The Id of the Row (or a getter returning it).
  * @param queriesOrQueriesId The Queries object to use (plain or getter), or its
  * Id.
  * @returns A reactive object with a `current` Row property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useResultRow: (
+  createResultRow: (
     queryId: MaybeGetter<Id>,
     rowId: MaybeGetter<Id>,
     queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
   ) => {readonly current: ResultRow};
 
   /**
- * The useResultCellIds hook returns a reactive object reflecting the Ids of the
- * Cells in a result Row, and registers a listener so that any changes will
- * update `.current`.
+ * The createResultCellIds function returns a reactive object reflecting the Ids
+ * of the Cells in a result Row, and registers a listener so that any changes
+ * will update `.current`.
  * @param queryId The Id of the Query (or a getter returning it).
  * @param rowId The Id of the Row (or a getter returning it).
  * @param queriesOrQueriesId The Queries object to use (plain or getter), or its
  * Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useResultCellIds: (
+  createResultCellIds: (
     queryId: MaybeGetter<Id>,
     rowId: MaybeGetter<Id>,
     queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
   ) => {readonly current: Ids};
 
   /**
- * The useResultCell hook returns a reactive object reflecting the value of a
- * Cell in a result Row, and registers a listener so that any changes will
+ * The createResultCell function returns a reactive object reflecting the value
+ * of a Cell in a result Row, and registers a listener so that any changes will
  * update `.current`.
  * @param queryId The Id of the Query (or a getter returning it).
  * @param rowId The Id of the Row (or a getter returning it).
@@ -2305,10 +2283,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param queriesOrQueriesId The Queries object to use (plain or getter), or its
  * Id.
  * @returns A reactive object with a `current` Cell | undefined property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useResultCell: (
+  createResultCell: (
     queryId: MaybeGetter<Id>,
     rowId: MaybeGetter<Id>,
     cellId: MaybeGetter<Id>,
@@ -2316,44 +2294,44 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => {readonly current: ResultCell | undefined};
 
   /**
- * The useRelationships hook returns the default Relationships object from the
- * current Provider context (or a named one if an Id is provided).
+ * The getRelationships function returns the default Relationships object from
+ * the current Provider context (or a named one if an Id is provided).
  * @param id An optional Id of a named Relationships object in the Provider
  * context.
  * @returns The Relationships object, or `undefined` if not found.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useRelationships: (id?: Id) => Relationships<Schemas> | undefined;
+  getRelationships: (id?: Id) => Relationships<Schemas> | undefined;
 
   /**
- * The useRelationshipsOrRelationshipsById hook is used to get a reference to a
+ * The resolveRelationships function is used to get a reference to a
  * Relationships object from a Provider context, or have it passed directly.
  * @param relationshipsOrRelationshipsId The Relationships object, its Id, or a
  * getter returning either.
  * @returns A getter function returning the Relationships object, or
  * `undefined`.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useRelationshipsOrRelationshipsById: (
+  resolveRelationships: (
     relationshipsOrRelationshipsId?: MaybeGetter<
       RelationshipsOrRelationshipsId<Schemas> | undefined
     >,
   ) => () => Relationships<Schemas> | undefined;
 
   /**
- * The useRelationshipsStoreTableIds hook returns the Store, local table Id, and
- * remote table Id for a given Relationships object and relationship Id.
+ * The getRelationshipsStoreTableIds function returns the Store, local table Id,
+ * and remote table Id for a given Relationships object and relationship Id.
  * @param relationshipsOrId The Relationships object, its Id, or a getter
  * returning either.
  * @param relationshipId The Id of the relationship, or a getter returning it.
  * @returns An object with `store`, `localTableId`, and `remoteTableId` getter
  * properties.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useRelationshipsStoreTableIds: (
+  getRelationshipsStoreTableIds: (
     relationshipsOrId: MaybeGetter<
       RelationshipsOrRelationshipsId<Schemas> | undefined
     >,
@@ -2365,221 +2343,221 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   };
 
   /**
- * The useRelationshipsIds hook returns a reactive object with the Ids of all
- * Relationships objects registered in the current Provider context.
+ * The createRelationshipsIds function returns a reactive object with the Ids of
+ * all Relationships objects registered in the current Provider context.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useRelationshipsIds: () => {readonly current: Ids};
+  createRelationshipsIds: () => {readonly current: Ids};
 
   /**
- * The useRelationshipIds hook returns a reactive object reflecting the Ids of
- * the Relationships in a Relationships object, and registers a listener so that
- * any changes will update `.current`.
+ * The createRelationshipIds function returns a reactive object reflecting the
+ * Ids of the Relationships in a Relationships object, and registers a listener
+ * so that any changes will update `.current`.
  * @param relationshipsOrRelationshipsId The Relationships object to use, or its
  * Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useRelationshipIds: (
+  createRelationshipIds: (
     relationshipsOrRelationshipsId?: MaybeGetter<
       RelationshipsOrRelationshipsId<Schemas> | undefined
     >,
   ) => {readonly current: Ids};
 
   /**
- * The useRemoteRowId hook returns a reactive object reflecting the remote Row
- * Id for a given local Row in a Relationship, and registers a listener so that
- * any changes will update `.current`.
+ * The createRemoteRowId function returns a reactive object reflecting the
+ * remote Row Id for a given local Row in a Relationship, and registers a
+ * listener so that any changes will update `.current`.
  * @param relationshipId The Id of the Relationship (or a getter returning it).
  * @param localRowId The Id of the local Row (or a getter returning it).
  * @param relationshipsOrRelationshipsId The Relationships object to use (plain
  * or getter), or its Id.
  * @returns A reactive object with a `current` Id | undefined property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useRemoteRowId: (
+  createRemoteRowId: (
     relationshipId: MaybeGetter<Id>,
     localRowId: MaybeGetter<Id>,
     relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId<Schemas>,
   ) => {readonly current: Id | undefined};
 
   /**
- * The useLocalRowIds hook returns a reactive object reflecting the local Row
- * Ids for a given remote Row in a Relationship, and registers a listener so
+ * The createLocalRowIds function returns a reactive object reflecting the local
+ * Row Ids for a given remote Row in a Relationship, and registers a listener so
  * that any changes will update `.current`.
  * @param relationshipId The Id of the Relationship (or a getter returning it).
  * @param remoteRowId The Id of the remote Row (or a getter returning it).
  * @param relationshipsOrRelationshipsId The Relationships object to use (plain
  * or getter), or its Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useLocalRowIds: (
+  createLocalRowIds: (
     relationshipId: MaybeGetter<Id>,
     remoteRowId: MaybeGetter<Id>,
     relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId<Schemas>,
   ) => {readonly current: Ids};
 
   /**
- * The useLinkedRowIds hook returns a reactive object reflecting the linked Row
- * Ids in a Relationship, and registers a listener so that any changes will
- * update `.current`.
+ * The createLinkedRowIds function returns a reactive object reflecting the
+ * linked Row Ids in a Relationship, and registers a listener so that any
+ * changes will update `.current`.
  * @param relationshipId The Id of the Relationship (or a getter returning it).
  * @param firstRowId The Id of the first Row (or a getter returning it).
  * @param relationshipsOrRelationshipsId The Relationships object to use (plain
  * or getter), or its Id.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useLinkedRowIds: (
+  createLinkedRowIds: (
     relationshipId: MaybeGetter<Id>,
     firstRowId: MaybeGetter<Id>,
     relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId<Schemas>,
   ) => {readonly current: Ids};
 
   /**
- * The useCheckpoints hook returns the default Checkpoints object from the
+ * The getCheckpoints function returns the default Checkpoints object from the
  * current Provider context (or a named one if an Id is provided).
  * @param id An optional Id of a named Checkpoints object in the Provider
  * context.
  * @returns The Checkpoints object, or `undefined` if not found.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useCheckpoints: (id?: Id) => Checkpoints<Schemas> | undefined;
+  getCheckpoints: (id?: Id) => Checkpoints<Schemas> | undefined;
 
   /**
- * The useCheckpointsOrCheckpointsById hook is used to get a reference to a
- * Checkpoints object from a Provider context, or have it passed directly.
+ * The resolveCheckpoints function is used to get a reference to a Checkpoints
+ * object from a Provider context, or have it passed directly.
  * @param checkpointsOrCheckpointsId The Checkpoints object, its Id, or a getter
  * returning either.
  * @returns A getter function returning the Checkpoints object, or `undefined`.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useCheckpointsOrCheckpointsById: (
+  resolveCheckpoints: (
     checkpointsOrCheckpointsId?: MaybeGetter<
       CheckpointsOrCheckpointsId<Schemas> | undefined
     >,
   ) => () => Checkpoints<Schemas> | undefined;
 
   /**
- * The useCheckpointsIds hook returns a reactive object with the Ids of all
- * Checkpoints objects registered in the current Provider context.
+ * The createCheckpointsIds function returns a reactive object with the Ids of
+ * all Checkpoints objects registered in the current Provider context.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useCheckpointsIds: () => {readonly current: Ids};
+  createCheckpointsIds: () => {readonly current: Ids};
 
   /**
- * The useCheckpointIds hook returns a reactive object reflecting the
+ * The createCheckpointIds function returns a reactive object reflecting the
  * CheckpointIds (backward, current, forward) in a Checkpoints object, and
  * registers a listener so that any changes will update `.current`.
  * @param checkpointsOrCheckpointsId The Checkpoints object to use (plain or
  * getter), or its Id.
  * @returns A reactive object with a `current` CheckpointIds property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useCheckpointIds: (
+  createCheckpointIds: (
     checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId<Schemas>,
   ) => {readonly current: CheckpointIds};
 
   /**
- * The useCheckpoint hook returns a reactive object reflecting the label of a
- * checkpoint, and registers a listener so that any changes will update
- * `.current`.
+ * The createCheckpoint function returns a reactive object reflecting the label
+ * of a checkpoint, and registers a listener so that any changes will
+ * update `.current`.
  * @param checkpointId The Id of the checkpoint (or a getter returning it).
  * @param checkpointsOrCheckpointsId The Checkpoints object to use (plain or
  * getter), or its Id.
  * @returns A reactive object with a `current` string | undefined property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useCheckpoint: (
+  createCheckpoint: (
     checkpointId: MaybeGetter<Id>,
     checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId<Schemas>,
   ) => {readonly current: string | undefined};
 
   /**
- * The useGoBackwardCallback hook returns a callback function that, when called,
- * moves the Checkpoints object backward to the previous checkpoint.
+ * The createGoBackwardCallback function returns a callback function that, when
+ * called, moves the Checkpoints object backward to the previous checkpoint.
  * @param checkpointsOrCheckpointsId The Checkpoints object to use, or its Id.
  * @returns A callback function.
- * @category Hook
+ * @category Callback
  * @since v8.1.0
  */
-  useGoBackwardCallback: (
+  createGoBackwardCallback: (
     checkpointsOrCheckpointsId?: MaybeGetter<
       CheckpointsOrCheckpointsId<Schemas> | undefined
     >,
   ) => () => void;
 
   /**
- * The useGoForwardCallback hook returns a callback function that, when called,
- * moves the Checkpoints object forward to the next checkpoint.
+ * The createGoForwardCallback function returns a callback function that, when
+ * called, moves the Checkpoints object forward to the next checkpoint.
  * @param checkpointsOrCheckpointsId The Checkpoints object to use, or its Id.
  * @returns A callback function.
- * @category Hook
+ * @category Callback
  * @since v8.1.0
  */
-  useGoForwardCallback: (
+  createGoForwardCallback: (
     checkpointsOrCheckpointsId?: MaybeGetter<
       CheckpointsOrCheckpointsId<Schemas> | undefined
     >,
   ) => () => void;
 
   /**
- * The usePersister hook returns the default Persister from the current Provider
- * context (or a named one if an Id is provided).
+ * The getPersister function returns the default Persister from the current
+ * Provider context (or a named one if an Id is provided).
  * @param id An optional Id of a named Persister in the Provider context.
  * @returns The Persister, or `undefined` if not found.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  usePersister: (id?: Id) => AnyPersister<Schemas> | undefined;
+  getPersister: (id?: Id) => AnyPersister<Schemas> | undefined;
 
   /**
- * The usePersisterOrPersisterById hook is used to get a reference to a
- * Persister object from a Provider context, or have it passed directly.
+ * The resolvePersister function is used to get a reference to a Persister
+ * object from a Provider context, or have it passed directly.
  * @param persisterOrPersisterId The Persister object, its Id, or a getter
  * returning either.
  * @returns A getter function returning the Persister object, or `undefined`.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  usePersisterOrPersisterById: (
+  resolvePersister: (
     persisterOrPersisterId?: MaybeGetter<
       PersisterOrPersisterId<Schemas> | undefined
     >,
   ) => () => AnyPersister<Schemas> | undefined;
 
   /**
- * The usePersisterIds hook returns a reactive object with the Ids of all
+ * The createPersisterIds function returns a reactive object with the Ids of all
  * Persisters registered in the current Provider context.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  usePersisterIds: () => {readonly current: Ids};
+  createPersisterIds: () => {readonly current: Ids};
 
   /**
- * The usePersisterStatus hook returns a reactive object reflecting the status
- * of a Persister, and registers a listener so that any changes will update
- * `.current`.
+ * The createPersisterStatus function returns a reactive object reflecting the
+ * status of a Persister, and registers a listener so that any changes will
+ * update `.current`.
  * @param persisterOrPersisterId The Persister to use, or its Id.
  * @returns A reactive object with a `current` Status property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  usePersisterStatus: (
+  createPersisterStatus: (
     persisterOrPersisterId?: MaybeGetter<
       PersisterOrPersisterId<Schemas> | undefined
     >,
@@ -2588,106 +2566,105 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   };
 
   /**
- * The useSynchronizer hook returns the default Synchronizer from the current
- * Provider context (or a named one if an Id is provided).
+ * The getSynchronizer function returns the default Synchronizer from the
+ * current Provider context (or a named one if an Id is provided).
  * @param id An optional Id of a named Synchronizer in the Provider context.
  * @returns The Synchronizer, or `undefined` if not found.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useSynchronizer: (id?: Id) => Synchronizer<Schemas> | undefined;
+  getSynchronizer: (id?: Id) => Synchronizer<Schemas> | undefined;
 
   /**
- * The useSynchronizerOrSynchronizerById hook is used to get a reference to a
- * Synchronizer object from a Provider context, or have it passed directly.
+ * The resolveSynchronizer function is used to get a reference to a Synchronizer
+ * object from a Provider context, or have it passed directly.
  * @param synchronizerOrSynchronizerId The Synchronizer object, its Id, or a
  * getter returning either.
  * @returns A getter function returning the Synchronizer object, or `undefined`.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useSynchronizerOrSynchronizerById: (
+  resolveSynchronizer: (
     synchronizerOrSynchronizerId?: MaybeGetter<
       SynchronizerOrSynchronizerId<Schemas> | undefined
     >,
   ) => () => Synchronizer<Schemas> | undefined;
 
   /**
- * The useSynchronizerIds hook returns a reactive object with the Ids of all
- * Synchronizers registered in the current Provider context.
+ * The createSynchronizerIds function returns a reactive object with the Ids of
+ * all Synchronizers registered in the current Provider context.
  * @returns A reactive object with a `current` Ids property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useSynchronizerIds: () => {readonly current: Ids};
+  createSynchronizerIds: () => {readonly current: Ids};
 
   /**
- * The useSynchronizerStatus hook returns a reactive object reflecting the
- * status of a Synchronizer, and registers a listener so that any changes will
- * update `.current`.
+ * The createSynchronizerStatus function returns a reactive object reflecting
+ * the status of a Synchronizer, and registers a listener so that any changes
+ * will update `.current`.
  * @param synchronizerOrSynchronizerId The Synchronizer to use, or its Id.
  * @returns A reactive object with a `current` Status property.
- * @category Hook
+ * @category Getter
  * @since v8.1.0
  */
-  useSynchronizerStatus: (
+  createSynchronizerStatus: (
     synchronizerOrSynchronizerId?: MaybeGetter<
       SynchronizerOrSynchronizerId<Schemas> | undefined
     >,
   ) => {readonly current: Status};
 
   /**
- * The useHasTablesListener hook registers a listener that is called whenever
- * any Tables are added to or removed from the Store. The listener is tied to
- * the component's `$effect` lifecycle and is removed when the component
- * unmounts.
+ * The onHasTables function registers a listener that is called whenever any
+ * Tables are added to or removed from the Store. The listener is tied to the
+ * component's `$effect` lifecycle and is removed when the component unmounts.
  * @param listener The function to call when table presence changes.
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useHasTablesListener: (
+  onHasTables: (
     listener: HasTablesListener<Schemas>,
     mutator?: boolean,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => void;
 
   /**
- * The useTablesListener hook registers a listener that is called whenever
- * tabular data in the Store changes.
+ * The onTables function registers a listener that is called whenever tabular
+ * data in the Store changes.
  * @param listener The function to call when Tables change.
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useTablesListener: (
+  onTables: (
     listener: TablesListener<Schemas>,
     mutator?: boolean,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => void;
 
   /**
- * The useTableIdsListener hook registers a listener that is called whenever the
- * set of Table Ids in the Store changes.
+ * The onTableIds function registers a listener that is called whenever the set
+ * of Table Ids in the Store changes.
  * @param listener The function to call when Table Ids change.
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useTableIdsListener: (
+  onTableIds: (
     listener: TableIdsListener<Schemas>,
     mutator?: boolean,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => void;
 
   /**
- * The useHasTableListener hook registers a listener that is called whenever a
+ * The onHasTable function registers a listener that is called whenever a
  * specified Table is added to or removed from the Store.
  * @param tableId The Id of the Table to listen to, or `null` to listen to any
  * Table.
@@ -2695,12 +2672,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useHasTableListener: <
-    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
-  >(
+  onHasTable: <TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null>(
     tableId: MaybeGetter<TableIdOrNull>,
     listener: HasTableListener<Schemas, TableIdOrNull>,
     mutator?: boolean,
@@ -2708,20 +2683,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useTableListener hook registers a listener that is called whenever data
- * in a specified Table changes.
+ * The onTable function registers a listener that is called whenever data in a
+ * specified Table changes.
  * @param tableId The Id of the Table to listen to, or `null` to listen to any
  * Table.
  * @param listener The function to call when the Table changes.
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useTableListener: <
-    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
-  >(
+  onTable: <TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null>(
     tableId: MaybeGetter<TableIdOrNull>,
     listener: TableListener<Schemas, TableIdOrNull>,
     mutator?: boolean,
@@ -2729,20 +2702,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useTableCellIdsListener hook registers a listener that is called whenever
- * the Cell Ids used across a Table change.
+ * The onTableCellIds function registers a listener that is called whenever the
+ * Cell Ids used across a Table change.
  * @param tableId The Id of the Table to listen to, or `null` to listen to any
  * Table.
  * @param listener The function to call when Cell Ids change.
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useTableCellIdsListener: <
-    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
-  >(
+  onTableCellIds: <TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null>(
     tableId: MaybeGetter<TableIdOrNull>,
     listener: TableCellIdsListener<Schemas, TableIdOrNull>,
     mutator?: boolean,
@@ -2750,8 +2721,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useHasTableCellListener hook registers a listener that is called whenever
- * a specified Cell Id is added to or removed from across a Table.
+ * The onHasTableCell function registers a listener that is called whenever a
+ * specified Cell Id is added to or removed from across a Table.
  * @param tableId The Id of the Table to listen to, or `null` to listen to any
  * Table.
  * @param cellId The Id of the Cell to listen to, or `null` to listen to any
@@ -2760,10 +2731,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useHasTableCellListener: <
+  onHasTableCell: <
     TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
     CellIdOrNull extends
       | (TableIdOrNull extends TableIdFromSchema<Schemas[0]>
@@ -2779,7 +2750,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useRowCountListener hook registers a listener that is called whenever the
+ * The onRowCount function registers a listener that is called whenever the
  * count of Rows in a Table changes.
  * @param tableId The Id of the Table to listen to, or `null` to listen to any
  * Table.
@@ -2787,12 +2758,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useRowCountListener: <
-    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
-  >(
+  onRowCount: <TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null>(
     tableId: MaybeGetter<TableIdOrNull>,
     listener: RowCountListener<Schemas, TableIdOrNull>,
     mutator?: boolean,
@@ -2800,20 +2769,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useRowIdsListener hook registers a listener that is called whenever the
- * Row Ids in a Table change.
+ * The onRowIds function registers a listener that is called whenever the Row
+ * Ids in a Table change.
  * @param tableId The Id of the Table to listen to, or `null` to listen to any
  * Table.
  * @param listener The function to call when Row Ids change.
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useRowIdsListener: <
-    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
-  >(
+  onRowIds: <TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null>(
     tableId: MaybeGetter<TableIdOrNull>,
     listener: RowIdsListener<Schemas, TableIdOrNull>,
     mutator?: boolean,
@@ -2821,8 +2788,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useSortedRowIdsListener hook registers a listener that is called whenever
- * the sorted Row Ids in a Table change.
+ * The onSortedRowIds function registers a listener that is called whenever the
+ * sorted Row Ids in a Table change.
  * @param tableId The Id of the Table to listen to.
  * @param cellId The Id of the Cell to sort by, or `undefined` for default
  * order.
@@ -2833,10 +2800,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useSortedRowIdsListener: <
+  onSortedRowIds: <
     TableId extends TableIdFromSchema<Schemas[0]>,
     CellIdOrUndefined extends CellIdFromSchema<Schemas[0], TableId> | undefined,
   >(
@@ -2851,7 +2818,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useHasRowListener hook registers a listener that is called whenever a
+ * The onHasRow function registers a listener that is called whenever a
  * specified Row is added to or removed from a Table.
  * @param tableId The Id of the Table to listen to, or `null` to listen to any
  * Table.
@@ -2860,10 +2827,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useHasRowListener: <
+  onHasRow: <
     TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
     RowIdOrNull extends IdOrNull,
   >(
@@ -2875,8 +2842,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useRowListener hook registers a listener that is called whenever data in
- * a specified Row changes.
+ * The onRow function registers a listener that is called whenever data in a
+ * specified Row changes.
  * @param tableId The Id of the Table to listen to, or `null` to listen to any
  * Table.
  * @param rowId The Id of the Row to listen to, or `null` to listen to any Row.
@@ -2884,10 +2851,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useRowListener: <
+  onRow: <
     TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
     RowIdOrNull extends IdOrNull,
   >(
@@ -2899,8 +2866,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useCellIdsListener hook registers a listener that is called whenever the
- * Cell Ids in a Row change.
+ * The onCellIds function registers a listener that is called whenever the Cell
+ * Ids in a Row change.
  * @param tableId The Id of the Table to listen to, or `null` to listen to any
  * Table.
  * @param rowId The Id of the Row to listen to, or `null` to listen to any Row.
@@ -2908,10 +2875,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useCellIdsListener: <
+  onCellIds: <
     TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
     RowIdOrNull extends IdOrNull,
   >(
@@ -2923,7 +2890,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useHasCellListener hook registers a listener that is called whenever a
+ * The onHasCell function registers a listener that is called whenever a
  * specified Cell is added to or removed from a Row.
  * @param tableId The Id of the Table to listen to, or `null` to listen to any
  * Table.
@@ -2934,10 +2901,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useHasCellListener: <
+  onHasCell: <
     TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
     RowIdOrNull extends IdOrNull,
     CellIdOrNull extends
@@ -2960,8 +2927,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useCellListener hook registers a listener that is called whenever the
- * value of a specified Cell changes.
+ * The onCell function registers a listener that is called whenever the value of
+ * a specified Cell changes.
  * @param tableId The Id of the Table to listen to, or `null` to listen to any
  * Table.
  * @param rowId The Id of the Row to listen to, or `null` to listen to any Row.
@@ -2971,10 +2938,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useCellListener: <
+  onCell: <
     TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
     RowIdOrNull extends IdOrNull,
     CellIdOrNull extends
@@ -2992,55 +2959,55 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useHasValuesListener hook registers a listener that is called whenever
- * any Values are added to or removed from the Store.
+ * The onHasValues function registers a listener that is called whenever any
+ * Values are added to or removed from the Store.
  * @param listener The function to call when value presence changes.
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useHasValuesListener: (
+  onHasValues: (
     listener: HasValuesListener<Schemas>,
     mutator?: boolean,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => void;
 
   /**
- * The useValuesListener hook registers a listener that is called whenever any
- * Values in the Store change.
+ * The onValues function registers a listener that is called whenever any Values
+ * in the Store change.
  * @param listener The function to call when Values change.
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useValuesListener: (
+  onValues: (
     listener: ValuesListener<Schemas>,
     mutator?: boolean,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => void;
 
   /**
- * The useValueIdsListener hook registers a listener that is called whenever the
+ * The onValueIds function registers a listener that is called whenever the
  * Value Ids in the Store change.
  * @param listener The function to call when Value Ids change.
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useValueIdsListener: (
+  onValueIds: (
     listener: ValueIdsListener<Schemas>,
     mutator?: boolean,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => void;
 
   /**
- * The useHasValueListener hook registers a listener that is called whenever a
+ * The onHasValue function registers a listener that is called whenever a
  * specified Value is added to or removed from the Store.
  * @param valueId The Id of the Value to listen to, or `null` to listen to any
  * Value.
@@ -3048,12 +3015,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useHasValueListener: <
-    ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null,
-  >(
+  onHasValue: <ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null>(
     valueId: MaybeGetter<ValueIdOrNull>,
     listener: HasValueListener<Schemas, ValueIdOrNull>,
     mutator?: boolean,
@@ -3061,20 +3026,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useValueListener hook registers a listener that is called whenever the
- * value of a specified Value changes.
+ * The onValue function registers a listener that is called whenever the value
+ * of a specified Value changes.
  * @param valueId The Id of the Value to listen to, or `null` to listen to any
  * Value.
  * @param listener The function to call when the Value changes.
  * @param mutator An optional boolean indicating the listener mutates Store
  * data.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useValueListener: <
-    ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null,
-  >(
+  onValue: <ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null>(
     valueId: MaybeGetter<ValueIdOrNull>,
     listener: ValueListener<Schemas, ValueIdOrNull>,
     mutator?: boolean,
@@ -3082,89 +3045,89 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useStartTransactionListener hook registers a listener that is called at
- * the start of every Store transaction.
+ * The onStartTransaction function registers a listener that is called at the
+ * start of every Store transaction.
  * @param listener The function to call at transaction start.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useStartTransactionListener: (
+  onStartTransaction: (
     listener: TransactionListener<Schemas>,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => void;
 
   /**
- * The useWillFinishTransactionListener hook registers a listener called just
- * before a Store transaction completes.
+ * The onWillFinishTransaction function registers a listener called just before
+ * a Store transaction completes.
  * @param listener The function to call before transaction end.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useWillFinishTransactionListener: (
+  onWillFinishTransaction: (
     listener: TransactionListener<Schemas>,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => void;
 
   /**
- * The useDidFinishTransactionListener hook registers a listener called just
- * after a Store transaction completes.
+ * The onDidFinishTransaction function registers a listener called just after a
+ * Store transaction completes.
  * @param listener The function to call after transaction end.
  * @param storeOrStoreId The Store to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useDidFinishTransactionListener: (
+  onDidFinishTransaction: (
     listener: TransactionListener<Schemas>,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => void;
 
   /**
- * The useMetricListener hook registers a listener that is called whenever a
+ * The onMetric function registers a listener that is called whenever a
  * specified Metric value changes.
  * @param metricId The Id of the Metric to listen to, or `null` to listen to any
  * Metric.
  * @param listener The function to call when the Metric changes.
  * @param metricsOrMetricsId The Metrics object to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useMetricListener: (
+  onMetric: (
     metricId: MaybeGetter<IdOrNull>,
     listener: MetricListener<Schemas>,
     metricsOrMetricsId?: MetricsOrMetricsId<Schemas>,
   ) => void;
 
   /**
- * The useSliceIdsListener hook registers a listener that is called whenever the
+ * The onSliceIds function registers a listener that is called whenever the
  * Slice Ids in an Index change.
  * @param indexId The Id of the Index to listen to, or `null` to listen to any
  * Index.
  * @param listener The function to call when Slice Ids change.
  * @param indexesOrIndexesId The Indexes object to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useSliceIdsListener: (
+  onSliceIds: (
     indexId: MaybeGetter<IdOrNull>,
     listener: SliceIdsListener<Schemas>,
     indexesOrIndexesId?: IndexesOrIndexesId<Schemas>,
   ) => void;
 
   /**
- * The useSliceRowIdsListener hook registers a listener that is called whenever
- * the Row Ids in a Slice change.
+ * The onSliceRowIds function registers a listener that is called whenever the
+ * Row Ids in a Slice change.
  * @param indexId The Id of the Index to listen to, or `null` to listen to any
  * Index.
  * @param sliceId The Id of the Slice to listen to, or `null` to listen to any
  * Slice.
  * @param listener The function to call when Slice Row Ids change.
  * @param indexesOrIndexesId The Indexes object to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useSliceRowIdsListener: (
+  onSliceRowIds: (
     indexId: MaybeGetter<IdOrNull>,
     sliceId: MaybeGetter<IdOrNull>,
     listener: SliceRowIdsListener<Schemas>,
@@ -3172,8 +3135,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useRemoteRowIdListener hook registers a listener that is called whenever
- * the remote Row Id for a local Row changes.
+ * The onRemoteRowId function registers a listener that is called whenever the
+ * remote Row Id for a local Row changes.
  * @param relationshipId The Id of the Relationship, or `null` to listen to any
  * Relationship.
  * @param localRowId The Id of the local Row, or `null` to listen to any local
@@ -3181,10 +3144,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param listener The function to call when the remote Row Id changes.
  * @param relationshipsOrRelationshipsId The Relationships object to use, or its
  * Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useRemoteRowIdListener: (
+  onRemoteRowId: (
     relationshipId: MaybeGetter<IdOrNull>,
     localRowId: MaybeGetter<IdOrNull>,
     listener: RemoteRowIdListener<Schemas>,
@@ -3192,8 +3155,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useLocalRowIdsListener hook registers a listener that is called whenever
- * the local Row Ids for a remote Row change.
+ * The onLocalRowIds function registers a listener that is called whenever the
+ * local Row Ids for a remote Row change.
  * @param relationshipId The Id of the Relationship, or `null` to listen to any
  * Relationship.
  * @param remoteRowId The Id of the remote Row, or `null` to listen to any
@@ -3201,10 +3164,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param listener The function to call when local Row Ids change.
  * @param relationshipsOrRelationshipsId The Relationships object to use, or its
  * Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useLocalRowIdsListener: (
+  onLocalRowIds: (
     relationshipId: MaybeGetter<IdOrNull>,
     remoteRowId: MaybeGetter<IdOrNull>,
     listener: LocalRowIdsListener<Schemas>,
@@ -3212,17 +3175,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useLinkedRowIdsListener hook registers a listener that is called whenever
- * the linked Row Ids for a first Row change.
+ * The onLinkedRowIds function registers a listener that is called whenever the
+ * linked Row Ids for a first Row change.
  * @param relationshipId The Id of the Relationship.
  * @param firstRowId The Id of the first Row.
  * @param listener The function to call when linked Row Ids change.
  * @param relationshipsOrRelationshipsId The Relationships object to use, or its
  * Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useLinkedRowIdsListener: (
+  onLinkedRowIds: (
     relationshipId: MaybeGetter<Id>,
     firstRowId: MaybeGetter<Id>,
     listener: LinkedRowIdsListener<Schemas>,
@@ -3230,71 +3193,71 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useResultTableListener hook registers a listener that is called whenever
- * the result Table of a query changes.
+ * The onResultTable function registers a listener that is called whenever the
+ * result Table of a query changes.
  * @param queryId The Id of the query to listen to, or `null` to listen to any
  * query.
  * @param listener The function to call when the result Table changes.
  * @param queriesOrQueriesId The Queries object to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useResultTableListener: (
+  onResultTable: (
     queryId: MaybeGetter<IdOrNull>,
     listener: ResultTableListener<Schemas>,
     queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
   ) => void;
 
   /**
- * The useResultTableCellIdsListener hook registers a listener that is called
+ * The onResultTableCellIds function registers a listener that is called
  * whenever the Cell Ids across a result Table change.
  * @param queryId The Id of the query to listen to, or `null` to listen to any
  * query.
  * @param listener The function to call when Cell Ids change.
  * @param queriesOrQueriesId The Queries object to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useResultTableCellIdsListener: (
+  onResultTableCellIds: (
     queryId: MaybeGetter<IdOrNull>,
     listener: ResultTableCellIdsListener<Schemas>,
     queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
   ) => void;
 
   /**
- * The useResultRowCountListener hook registers a listener that is called
- * whenever the count of result Rows changes.
+ * The onResultRowCount function registers a listener that is called whenever
+ * the count of result Rows changes.
  * @param queryId The Id of the query to listen to, or `null` to listen to any
  * query.
  * @param listener The function to call when the count changes.
  * @param queriesOrQueriesId The Queries object to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useResultRowCountListener: (
+  onResultRowCount: (
     queryId: MaybeGetter<IdOrNull>,
     listener: ResultRowCountListener<Schemas>,
     queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
   ) => void;
 
   /**
- * The useResultRowIdsListener hook registers a listener that is called whenever
- * the result Row Ids of a query change.
+ * The onResultRowIds function registers a listener that is called whenever the
+ * result Row Ids of a query change.
  * @param queryId The Id of the query to listen to, or `null` to listen to any
  * query.
  * @param listener The function to call when result Row Ids change.
  * @param queriesOrQueriesId The Queries object to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useResultRowIdsListener: (
+  onResultRowIds: (
     queryId: MaybeGetter<IdOrNull>,
     listener: ResultRowIdsListener<Schemas>,
     queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
   ) => void;
 
   /**
- * The useResultSortedRowIdsListener hook registers a listener that is called
+ * The onResultSortedRowIds function registers a listener that is called
  * whenever the sorted result Row Ids change.
  * @param queryId The Id of the query to listen to.
  * @param cellId The Id of the Cell to sort by, or `undefined` for default
@@ -3304,10 +3267,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param limit The maximum number of Rows to include, or `undefined` for all.
  * @param listener The function to call when sorted Row Ids change.
  * @param queriesOrQueriesId The Queries object to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useResultSortedRowIdsListener: (
+  onResultSortedRowIds: (
     queryId: MaybeGetter<Id>,
     cellId: MaybeGetter<Id | undefined>,
     descending: MaybeGetter<boolean>,
@@ -3318,7 +3281,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useResultRowListener hook registers a listener that is called whenever a
+ * The onResultRow function registers a listener that is called whenever a
  * result Row changes.
  * @param queryId The Id of the query to listen to, or `null` to listen to any
  * query.
@@ -3326,10 +3289,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * any result Row.
  * @param listener The function to call when the result Row changes.
  * @param queriesOrQueriesId The Queries object to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useResultRowListener: (
+  onResultRow: (
     queryId: MaybeGetter<IdOrNull>,
     rowId: MaybeGetter<IdOrNull>,
     listener: ResultRowListener<Schemas>,
@@ -3337,18 +3300,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useResultCellIdsListener hook registers a listener that is called
- * whenever the Cell Ids in a result Row change.
+ * The onResultCellIds function registers a listener that is called whenever the
+ * Cell Ids in a result Row change.
  * @param queryId The Id of the query to listen to, or `null` to listen to any
  * query.
  * @param rowId The Id of the result Row to listen to, or `null` to listen to
  * any result Row.
  * @param listener The function to call when Cell Ids change.
  * @param queriesOrQueriesId The Queries object to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useResultCellIdsListener: (
+  onResultCellIds: (
     queryId: MaybeGetter<IdOrNull>,
     rowId: MaybeGetter<IdOrNull>,
     listener: ResultCellIdsListener<Schemas>,
@@ -3356,8 +3319,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useResultCellListener hook registers a listener that is called whenever
- * the value of a result Cell changes.
+ * The onResultCell function registers a listener that is called whenever the
+ * value of a result Cell changes.
  * @param queryId The Id of the query to listen to, or `null` to listen to any
  * query.
  * @param rowId The Id of the result Row to listen to, or `null` to listen to
@@ -3366,10 +3329,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * any result Cell.
  * @param listener The function to call when the result Cell changes.
  * @param queriesOrQueriesId The Queries object to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useResultCellListener: (
+  onResultCell: (
     queryId: MaybeGetter<IdOrNull>,
     rowId: MaybeGetter<IdOrNull>,
     cellId: MaybeGetter<IdOrNull>,
@@ -3378,23 +3341,23 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useParamValuesListener hook registers a listener that is called whenever
- * the parameter values for a query change.
+ * The onParamValues function registers a listener that is called whenever the
+ * parameter values for a query change.
  * @param queryId The Id of the query to listen to, or `null` to listen to any
  * query.
  * @param listener The function to call when parameter values change.
  * @param queriesOrQueriesId The Queries object to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useParamValuesListener: (
+  onParamValues: (
     queryId: MaybeGetter<IdOrNull>,
     listener: ParamValuesListener<Schemas>,
     queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
   ) => void;
 
   /**
- * The useParamValueListener hook registers a listener that is called whenever a
+ * The onParamValue function registers a listener that is called whenever a
  * specific parameter value for a query changes.
  * @param queryId The Id of the query to listen to, or `null` to listen to any
  * query.
@@ -3402,10 +3365,10 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * any parameter.
  * @param listener The function to call when the parameter value changes.
  * @param queriesOrQueriesId The Queries object to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useParamValueListener: (
+  onParamValue: (
     queryId: MaybeGetter<IdOrNull>,
     paramId: MaybeGetter<IdOrNull>,
     listener: ParamValueListener<Schemas>,
@@ -3413,43 +3376,43 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useCheckpointIdsListener hook registers a listener that is called
- * whenever the Checkpoint Ids change.
+ * The onCheckpointIds function registers a listener that is called whenever the
+ * Checkpoint Ids change.
  * @param listener The function to call when Checkpoint Ids change.
  * @param checkpointsOrCheckpointsId The Checkpoints object to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useCheckpointIdsListener: (
+  onCheckpointIds: (
     listener: CheckpointIdsListener<Schemas>,
     checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId<Schemas>,
   ) => void;
 
   /**
- * The useCheckpointListener hook registers a listener that is called whenever
- * the label of a specified Checkpoint changes.
+ * The onCheckpoint function registers a listener that is called whenever the
+ * label of a specified Checkpoint changes.
  * @param checkpointId The Id of the Checkpoint to listen to, or `null` to
  * listen to any Checkpoint.
  * @param listener The function to call when the Checkpoint label changes.
  * @param checkpointsOrCheckpointsId The Checkpoints object to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useCheckpointListener: (
+  onCheckpoint: (
     checkpointId: MaybeGetter<IdOrNull>,
     listener: CheckpointListener<Schemas>,
     checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId<Schemas>,
   ) => void;
 
   /**
- * The usePersisterStatusListener hook registers a listener that is called
- * whenever the status of a Persister changes.
+ * The onPersisterStatus function registers a listener that is called whenever
+ * the status of a Persister changes.
  * @param listener The function to call when the status changes.
  * @param persisterOrPersisterId The Persister to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  usePersisterStatusListener: (
+  onPersisterStatus: (
     listener: StatusListener<Schemas>,
     persisterOrPersisterId?: MaybeGetter<
       PersisterOrPersisterId<Schemas> | undefined
@@ -3457,14 +3420,14 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   ) => void;
 
   /**
- * The useSynchronizerStatusListener hook registers a listener that is called
+ * The onSynchronizerStatus function registers a listener that is called
  * whenever the status of a Synchronizer changes.
  * @param listener The function to call when the status changes.
  * @param synchronizerOrSynchronizerId The Synchronizer to use, or its Id.
- * @category Hook
+ * @category Listener
  * @since v8.1.0
  */
-  useSynchronizerStatusListener: (
+  onSynchronizerStatus: (
     listener: StatusListener<Schemas>,
     synchronizerOrSynchronizerId?: MaybeGetter<
       SynchronizerOrSynchronizerId<Schemas> | undefined
@@ -3481,8 +3444,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * provideStore(storeId: Id, store: Store): void;
  * ```
  *
- * This function must be called inside a Svelte component's `<script>` block
- * that is a descendant of a Provider component.
+ * The provideStore function must be called inside a Svelte component's
+ * `<script>` block that is a descendant of a Provider component.
  * @param storeId The Id to register the Store under.
  * @param store The Store to register.
  * @category Provider