tinybase 3.1.0-beta.4 → 3.1.0

package/lib/{cjs-es6 → types/with-schemas}/ui-react.d.ts

@@ -23,12 +23,56 @@
  * @module ui-react
  */
 
+import {
+  AllCellIdFromSchema,
+  CellIdFromSchema,
+  DefaultedValueFromSchema,
+  NoInfer,
+  TableIdFromSchema,
+  ValueIdFromSchema,
+} from './internal/store';
+import {
+  BackwardCheckpointsProps,
+  CellProps,
+  CheckpointProps,
+  CheckpointsOrCheckpointsId,
+  ComponentReturnType,
+  CurrentCheckpointProps,
+  ExtraProps,
+  ForwardCheckpointsProps,
+  IndexProps,
+  IndexesOrIndexesId,
+  LinkedRowsProps,
+  LocalRowsProps,
+  MetricProps,
+  MetricsOrMetricsId,
+  ProviderProps,
+  QueriesOrQueriesId,
+  RelationshipsOrRelationshipsId,
+  RemoteRowProps,
+  ResultCellProps,
+  ResultRowProps,
+  ResultSortedTableProps,
+  ResultTableProps,
+  RowProps,
+  SliceProps,
+  SortedTableProps,
+  StoreOrStoreId,
+  TableProps,
+  TablesProps,
+  UndoOrRedoInformation,
+  ValueProps,
+  ValuesProps,
+} from './internal/ui-react';
 import {Callback, Id, IdOrNull, Ids, ParameterizedCallback} from './common.d';
 import {
   Cell,
   CellIdsListener,
   CellListener,
+  CellOrUndefined,
   MapCell,
+  MapValue,
+  OptionalSchemas,
   Row,
   RowIdsListener,
   RowListener,
@@ -51,7 +95,6 @@ import {
   CheckpointListener,
   Checkpoints,
 } from './checkpoints.d';
-import {ComponentType, ReactElement} from 'react';
 import {Indexes, SliceIdsListener, SliceRowIdsListener} from './indexes.d';
 import {
   LinkedRowIdsListener,
@@ -62,18 +105,29 @@ import {
 import {MetricListener, Metrics} from './metrics.d';
 import {
   Queries,
+  ResultCell,
   ResultCellIdsListener,
   ResultCellListener,
+  ResultRow,
   ResultRowIdsListener,
   ResultRowListener,
+  ResultTable,
   ResultTableListener,
 } from './queries.d';
 import {Persister} from './persisters.d';
+import {ReactElement} from 'react';
 
-/**
+export type WithSchemas<Schemas extends OptionalSchemas> = {
+  /**
  * The StoreOrStoreId type is used when you need to refer to a Store in a React
  * hook or component.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * Store | Id;
+ * ```
+ *
  * In some simple cases you will already have a direct reference to the Store.
  *
  * This module also includes a Provider component that can be used to wrap
@@ -85,12 +139,18 @@ import {Persister} from './persisters.d';
  *
  * @category Identity
  */
-export type StoreOrStoreId = Store | Id;
+  StoreOrStoreId: StoreOrStoreId<Schemas>;
 
-/**
+  /**
  * The MetricsOrMetricsId type is used when you need to refer to a Metrics
  * object in a React hook or component.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * Metrics | Id;
+ * ```
+ *
  * In some simple cases you will already have a direct reference to the Metrics
  * object.
  *
@@ -104,12 +164,18 @@ export type StoreOrStoreId = Store | Id;
  *
  * @category Identity
  */
-export type MetricsOrMetricsId = Metrics | Id;
+  MetricsOrMetricsId: MetricsOrMetricsId<Schemas>;
 
-/**
+  /**
  * The IndexesOrIndexesId type is used when you need to refer to a Indexes
  * object in a React hook or component.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * Indexes | Id;
+ * ```
+ *
  * In some simple cases you will already have a direct reference to the Indexes
  * object.
  *
@@ -123,12 +189,18 @@ export type MetricsOrMetricsId = Metrics | Id;
  *
  * @category Identity
  */
-export type IndexesOrIndexesId = Indexes | Id;
+  IndexesOrIndexesId: IndexesOrIndexesId<Schemas>;
 
-/**
+  /**
  * The RelationshipsOrRelationshipsId type is used when you need to refer to a
  * Relationships object in a React hook or component.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * Relationships | Id;
+ * ```
+ *
  * In some simple cases you will already have a direct reference to the
  * Relationships object.
  *
@@ -142,12 +214,18 @@ export type IndexesOrIndexesId = Indexes | Id;
  *
  * @category Identity
  */
-export type RelationshipsOrRelationshipsId = Relationships | Id;
+  RelationshipsOrRelationshipsId: RelationshipsOrRelationshipsId<Schemas>;
 
-/**
+  /**
  * The QueriesOrQueriesId type is used when you need to refer to a Queries
  * object in a React hook or component.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * Queries | Id;
+ * ```
+ *
  * In some simple cases you will already have a direct reference to the Queries
  * object.
  *
@@ -162,12 +240,18 @@ export type RelationshipsOrRelationshipsId = Relationships | Id;
  * @category Identity
  * @since v2.0.0
  */
-export type QueriesOrQueriesId = Queries | Id;
+  QueriesOrQueriesId: QueriesOrQueriesId<Schemas>;
 
-/**
+  /**
  * The CheckpointsOrCheckpointsId type is used when you need to refer to a
  * Checkpoints object in a React hook or component.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * Checkpoints | Id;
+ * ```
+ *
  * In some simple cases you will already have a direct reference to the
  * Checkpoints object.
  *
@@ -181,9 +265,9 @@ export type QueriesOrQueriesId = Queries | Id;
  *
  * @category Identity
  */
-export type CheckpointsOrCheckpointsId = Checkpoints | Id;
+  CheckpointsOrCheckpointsId: CheckpointsOrCheckpointsId<Schemas>;
 
-/**
+  /**
  * The UndoOrRedoInformation type is an array that you can fetch from a
  * Checkpoints object to that indicates if and how you can move the state of the
  * underlying Store forward or backward.
@@ -194,12 +278,21 @@ export type CheckpointsOrCheckpointsId = Checkpoints | Id;
  *
  * @category Checkpoints
  */
-export type UndoOrRedoInformation = [boolean, Callback, Id | undefined, string];
+  UndoOrRedoInformation: UndoOrRedoInformation;
 
-/**
+  /**
  * The useCreateStore hook is used to create a Store within a React application
  * with convenient memoization.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCreateStore(
+ *   create: () => Store,
+ *   createDeps?: React.DependencyList,
+ * ): Store;
+ * ```
+ *
  * It is possible to create a Store outside of the React app with the regular
  * createStore function and pass it in, but you may prefer to create it within
  * the app, perhaps inside the top-level component. To defend against a new
@@ -277,15 +370,21 @@ export type UndoOrRedoInformation = [boolean, Callback, Id | undefined, string];
  * ```
  * @category Store hooks
  */
-export function useCreateStore(
-  create: () => Store,
-  createDeps?: React.DependencyList,
-): Store;
+  useCreateStore: (
+    create: () => Store<Schemas>,
+    createDeps?: React.DependencyList,
+  ) => Store<Schemas>;
 
-/**
+  /**
  * The useStore hook is used to get a reference to a Store from within a
  * Provider component context.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useStore(id?: Id): Store | undefined;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context. It
  * can contain a default Store (or a set of Store objects named by Id) that can
  * be easily accessed without having to be passed down as props through every
@@ -341,13 +440,19 @@ export function useCreateStore(
  * ```
  * @category Store hooks
  */
-export function useStore(id?: Id): Store | undefined;
+  useStore: (id?: Id) => Store<Schemas> | undefined;
 
-/**
+  /**
  * The useTables hook returns a Tables object containing the tabular data of a
  * Store, and registers a listener so that any changes to that result will cause
  * a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useTables(storeOrStoreId?: StoreOrStoreId): Tables;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Store or a set of Store objects named by Id. The
  * useTables hook lets you indicate which Store to get data for: omit the
@@ -419,12 +524,18 @@ export function useStore(id?: Id): Store | undefined;
  * ```
  * @category Store hooks
  */
-export function useTables(storeOrStoreId?: StoreOrStoreId): Tables;
+  useTables: (storeOrStoreId?: StoreOrStoreId<Schemas>) => Tables<Schemas[0]>;
 
-/**
+  /**
  * The useTableIds hook returns the Ids of every Table in a Store, and registers
  * a listener so that any changes to that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useTableIds(storeOrStoreId?: StoreOrStoreId): Ids;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Store or a set of Store objects named by Id. The
  * useTableIds hook lets you indicate which Store to get data for: omit the
@@ -495,13 +606,21 @@ export function useTables(storeOrStoreId?: StoreOrStoreId): Tables;
  * ```
  * @category Store hooks
  */
-export function useTableIds(storeOrStoreId?: StoreOrStoreId): Ids;
+  useTableIds: (
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => TableIdFromSchema<Schemas[0]>[];
 
-/**
+  /**
  * The useTable hook returns an object containing the data of a single Table in
  * a Store, and registers a listener so that any changes to that result will
  * cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useTable(tableId: Id, storeOrStoreId?: StoreOrStoreId): Table;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Store or a set of Store objects named by Id. The
  * useTable hook lets you indicate which Store to get data for: omit the final
@@ -575,13 +694,22 @@ export function useTableIds(storeOrStoreId?: StoreOrStoreId): Ids;
  * ```
  * @category Store hooks
  */
-export function useTable(tableId: Id, storeOrStoreId?: StoreOrStoreId): Table;
+  useTable: <TableId extends TableIdFromSchema<Schemas[0]>>(
+    tableId: TableId,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => Table<Schemas[0], TableId>;
 
-/**
+  /**
  * The useRowIds hook returns the Ids of every Row in a given Table, and
  * registers a listener so that any changes to that result will cause a
  * re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useRowIds(tableId: Id, storeOrStoreId?: StoreOrStoreId): Ids;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Store or a set of Store objects named by Id. The
  * useRowIds hook lets you indicate which Store to get data for: omit the
@@ -655,13 +783,29 @@ export function useTable(tableId: Id, storeOrStoreId?: StoreOrStoreId): Table;
  * ```
  * @category Store hooks
  */
-export function useRowIds(tableId: Id, storeOrStoreId?: StoreOrStoreId): Ids;
+  useRowIds: (
+    tableId: TableIdFromSchema<Schemas[0]>,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => Ids;
 
-/**
+  /**
  * The useSortedRowIds hook returns the sorted (and optionally, paginated) Ids
  * of every Row in a given Table, and registers a listener so that any changes
  * to that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useSortedRowIds(
+ *   tableId: Id,
+ *   cellId?: Id,
+ *   descending?: boolean,
+ *   offset?: number,
+ *   limit?: number,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): Ids;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Store or a set of Store objects named by Id. The
  * useSortedRowIds hook lets you indicate which Store to get data for: omit the
@@ -766,20 +910,33 @@ export function useRowIds(tableId: Id, storeOrStoreId?: StoreOrStoreId): Ids;
  * @category Store hooks
  * @since v2.0.0
  */
-export function useSortedRowIds(
-  tableId: Id,
-  cellId?: Id,
-  descending?: boolean,
-  offset?: number,
-  limit?: number,
-  storeOrStoreId?: StoreOrStoreId,
-): Ids;
+  useSortedRowIds: <
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    CellId extends CellIdFromSchema<Schemas[0], TableId>,
+  >(
+    tableId: TableId,
+    cellId?: CellId,
+    descending?: boolean,
+    offset?: number,
+    limit?: number,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => Ids;
 
-/**
+  /**
  * The useRow hook returns an object containing the data of a single Row in a
  * given Table, and registers a listener so that any changes to that result will
  * cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useRow(
+ *   tableId: Id,
+ *   rowId: Id,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): Row;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Store or a set of Store objects named by Id. The
  * useRow hook lets you indicate which Store to get data for: omit the final
@@ -856,17 +1013,27 @@ export function useSortedRowIds(
  * ```
  * @category Store hooks
  */
-export function useRow(
-  tableId: Id,
-  rowId: Id,
-  storeOrStoreId?: StoreOrStoreId,
-): Row;
+  useRow: <TableId extends TableIdFromSchema<Schemas[0]>>(
+    tableId: TableId,
+    rowId: Id,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => Row<Schemas[0], TableId>;
 
-/**
+  /**
  * The useCellIds hook returns the Ids of every Cell in a given Row, in a given
  * Table, and registers a listener so that any changes to that result will cause
  * a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCellIds(
+ *   tableId: Id,
+ *   rowId: Id,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): Ids;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Store or a set of Store objects named by Id. The
  * useCellIds hook lets you indicate which Store to get data for: omit the
@@ -945,17 +1112,31 @@ export function useRow(
  * ```
  * @category Store hooks
  */
-export function useCellIds(
-  tableId: Id,
-  rowId: Id,
-  storeOrStoreId?: StoreOrStoreId,
-): Ids;
+  useCellIds: <
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    Ids extends CellIdFromSchema<Schemas[0], TableId>[],
+  >(
+    tableId: TableId,
+    rowId: Id,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => Ids;
 
-/**
+  /**
  * The useCell hook returns an object containing the value of a single Cell in a
  * given Row, in a given Table, and registers a listener so that any changes to
  * that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCell(
+ *   tableId: Id,
+ *   rowId: Id,
+ *   cellId: Id,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): CellOrUndefined;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Store or a set of Store objects named by Id. The
  * useCell hook lets you indicate which Store to get data for: omit the final
@@ -1031,18 +1212,27 @@ export function useCellIds(
  * ```
  * @category Store hooks
  */
-export function useCell(
-  tableId: Id,
-  rowId: Id,
-  cellId: Id,
-  storeOrStoreId?: StoreOrStoreId,
-): Cell | undefined;
+  useCell: <
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    CellId extends CellIdFromSchema<Schemas[0], TableId>,
+  >(
+    tableId: TableId,
+    rowId: Id,
+    cellId: CellId,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => NoInfer<CellOrUndefined<Schemas[0], TableId, CellId>>;
 
-/**
+  /**
  * The useValues hook returns a Values object containing the keyed value data of
  * a Store, and registers a listener so that any changes to that result will
  * cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useValues(storeOrStoreId?: StoreOrStoreId): Values;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Store or a set of Store objects named by Id. The
  * useValues hook lets you indicate which Store to get data for: omit the
@@ -1114,12 +1304,18 @@ export function useCell(
  * @category Store hooks
  * @since v3.0.0
  */
-export function useValues(storeOrStoreId?: StoreOrStoreId): Values;
+  useValues: (storeOrStoreId?: StoreOrStoreId<Schemas>) => Values<Schemas[1]>;
 
-/**
+  /**
  * The useValueIds hook returns the Ids of every Value in a Store, and registers
  * a listener so that any changes to that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useValueIds(storeOrStoreId?: StoreOrStoreId): Ids;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Store or a set of Store objects named by Id. The
  * useValueIds hook lets you indicate which Store to get data for: omit the
@@ -1191,13 +1387,24 @@ export function useValues(storeOrStoreId?: StoreOrStoreId): Values;
  * @category Store hooks
  * @since v3.0.0
  */
-export function useValueIds(storeOrStoreId?: StoreOrStoreId): Ids;
+  useValueIds: (
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => ValueIdFromSchema<Schemas[1]>[];
 
-/**
+  /**
  * The useValue hook returns an object containing the data of a single Value in
  * a Store, and registers a listener so that any changes to that result will
  * cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useValue(
+ *   valueId: Id,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): ValueOrUndefined;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Store or a set of Store objects named by Id. The
  * useValue hook lets you indicate which Store to get data for: omit the final
@@ -1272,12 +1479,27 @@ export function useValueIds(storeOrStoreId?: StoreOrStoreId): Ids;
  * @category Store hooks
  * @since v3.0.0
  */
-export function useValue(valueId: Id, storeOrStoreId?: StoreOrStoreId): Value;
+  useValue: <ValueId extends ValueIdFromSchema<Schemas[1]>>(
+    valueId: ValueId,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => DefaultedValueFromSchema<Schemas[1], ValueId>;
 
-/**
+  /**
  * The useSetTablesCallback hook returns a parameterized callback that can be
  * used to set the tabular data of a Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useSetTablesCallback<Parameter>(
+ *   getTables: (parameter: Parameter, store: Store) => Tables,
+ *   getTablesDeps?: React.DependencyList,
+ *   storeOrStoreId?: StoreOrStoreId,
+ *   then?: (store: Store, tables: Tables) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): ParameterizedCallback<Parameter>;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * mutate the data in the Store. In this case, the parameter will likely be the
  * event, so that you can use data from it as part of the mutation.
@@ -1349,18 +1571,34 @@ export function useValue(valueId: Id, storeOrStoreId?: StoreOrStoreId): Value;
  * ```
  * @category Store hooks
  */
-export function useSetTablesCallback<Parameter>(
-  getTables: (parameter: Parameter, store: Store) => Tables,
-  getTablesDeps?: React.DependencyList,
-  storeOrStoreId?: StoreOrStoreId,
-  then?: (store: Store, tables: Tables) => void,
-  thenDeps?: React.DependencyList,
-): ParameterizedCallback<Parameter>;
+  useSetTablesCallback: <Parameter, SetTables = Tables<Schemas[0], true>>(
+    getTables: (
+      parameter: Parameter,
+      store: Store<Schemas>,
+    ) => NoInfer<SetTables>,
+    getTablesDeps?: React.DependencyList,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (store: Store<Schemas>, tables: SetTables) => void,
+    thenDeps?: React.DependencyList,
+  ) => ParameterizedCallback<Parameter>;
 
-/**
+  /**
  * The useSetTableCallback hook returns a parameterized callback that can be
  * used to set the data of a single Table in a Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useSetTableCallback<Parameter>(
+ *   tableId: Id,
+ *   getTable: (parameter: Parameter, store: Store) => Table,
+ *   getTableDeps?: React.DependencyList,
+ *   storeOrStoreId?: StoreOrStoreId,
+ *   then?: (store: Store, table: Table) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): ParameterizedCallback<Parameter>;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * mutate the data in the Store. In this case, the parameter will likely be the
  * event, so that you can use data from it as part of the mutation.
@@ -1434,19 +1672,40 @@ export function useSetTablesCallback<Parameter>(
  * ```
  * @category Store hooks
  */
-export function useSetTableCallback<Parameter>(
-  tableId: Id,
-  getTable: (parameter: Parameter, store: Store) => Table,
-  getTableDeps?: React.DependencyList,
-  storeOrStoreId?: StoreOrStoreId,
-  then?: (store: Store, table: Table) => void,
-  thenDeps?: React.DependencyList,
-): ParameterizedCallback<Parameter>;
+  useSetTableCallback: <
+    Parameter,
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    SetTable = Table<Schemas[0], TableId, true>,
+  >(
+    tableId: TableId,
+    getTable: (
+      parameter: Parameter,
+      store: Store<Schemas>,
+    ) => NoInfer<SetTable>,
+    getTableDeps?: React.DependencyList,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (store: Store<Schemas>, table: SetTable) => void,
+    thenDeps?: React.DependencyList,
+  ) => ParameterizedCallback<Parameter>;
 
-/**
+  /**
  * The useSetRowCallback hook returns a parameterized callback that can be used
  * to set the data of a single Row in a Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useSetRowCallback<Parameter>(
+ *   tableId: Id,
+ *   rowId: Id,
+ *   getRow: (parameter: Parameter, store: Store) => Row,
+ *   getRowDeps?: React.DependencyList,
+ *   storeOrStoreId?: StoreOrStoreId,
+ *   then?: (store: Store, row: Row) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): ParameterizedCallback<Parameter>;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * mutate the data in the Store. In this case, the parameter will likely be the
  * event, so that you can use data from it as part of the mutation.
@@ -1522,20 +1781,37 @@ export function useSetTableCallback<Parameter>(
  * ```
  * @category Store hooks
  */
-export function useSetRowCallback<Parameter>(
-  tableId: Id,
-  rowId: Id,
-  getRow: (parameter: Parameter, store: Store) => Row,
-  getRowDeps?: React.DependencyList,
-  storeOrStoreId?: StoreOrStoreId,
-  then?: (store: Store, row: Row) => void,
-  thenDeps?: React.DependencyList,
-): ParameterizedCallback<Parameter>;
+  useSetRowCallback: <
+    Parameter,
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    SetRow = Row<Schemas[0], TableId, true>,
+  >(
+    tableId: TableId,
+    rowId: Id,
+    getRow: (parameter: Parameter, store: Store<Schemas>) => NoInfer<SetRow>,
+    getRowDeps?: React.DependencyList,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (store: Store<Schemas>, row: SetRow) => void,
+    thenDeps?: React.DependencyList,
+  ) => ParameterizedCallback<Parameter>;
 
-/**
+  /**
  * The useAddRowCallback hook returns a parameterized callback that can be used
  * to create a new Row in a Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useAddRowCallback<Parameter>(
+ *   tableId: Id,
+ *   getRow: (parameter: Parameter, store: Store) => Row,
+ *   getRowDeps?: React.DependencyList,
+ *   storeOrStoreId?: StoreOrStoreId,
+ *   then?: (rowId: Id | undefined, store: Store, row: Row) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): ParameterizedCallback<Parameter>;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * mutate the data in the Store. In this case, the parameter will likely be the
  * event, so that you can use data from it as part of the mutation.
@@ -1609,20 +1885,38 @@ export function useSetRowCallback<Parameter>(
  * ```
  * @category Store hooks
  */
-export function useAddRowCallback<Parameter>(
-  tableId: Id,
-  getRow: (parameter: Parameter, store: Store) => Row,
-  getRowDeps?: React.DependencyList,
-  storeOrStoreId?: StoreOrStoreId,
-  then?: (rowId: Id | undefined, store: Store, row: Row) => void,
-  thenDeps?: React.DependencyList,
-): ParameterizedCallback<Parameter>;
+  useAddRowCallback: <
+    Parameter,
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    AddRow = Row<Schemas[0], TableId, true>,
+  >(
+    tableId: TableId,
+    getRow: (parameter: Parameter, store: Store<Schemas>) => NoInfer<AddRow>,
+    getRowDeps?: React.DependencyList,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (rowId: Id | undefined, store: Store<Schemas>, row: AddRow) => void,
+    thenDeps?: React.DependencyList,
+  ) => ParameterizedCallback<Parameter>;
 
-/**
+  /**
  * The useSetPartialRowCallback hook returns a parameterized callback that can
  * be used to set partial data of a single Row in the Store, leaving other Cell
  * values unaffected.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useSetPartialRowCallback<Parameter>(
+ *   tableId: Id,
+ *   rowId: Id,
+ *   getPartialRow: (parameter: Parameter, store: Store) => Row,
+ *   getPartialRowDeps?: React.DependencyList,
+ *   storeOrStoreId?: StoreOrStoreId,
+ *   then?: (store: Store, partialRow: Row) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): ParameterizedCallback<Parameter>;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * mutate the data in Store. In this case, the parameter will likely be the
  * event, so that you can use data from it as part of the mutation.
@@ -1699,20 +1993,42 @@ export function useAddRowCallback<Parameter>(
  * ```
  * @category Store hooks
  */
-export function useSetPartialRowCallback<Parameter>(
-  tableId: Id,
-  rowId: Id,
-  getPartialRow: (parameter: Parameter, store: Store) => Row,
-  getPartialRowDeps?: React.DependencyList,
-  storeOrStoreId?: StoreOrStoreId,
-  then?: (store: Store, partialRow: Row) => void,
-  thenDeps?: React.DependencyList,
-): ParameterizedCallback<Parameter>;
+  useSetPartialRowCallback: <
+    Parameter,
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    SetPartialRow = Row<Schemas[0], TableId, true>,
+  >(
+    tableId: TableId,
+    rowId: Id,
+    getPartialRow: (
+      parameter: Parameter,
+      store: Store<Schemas>,
+    ) => NoInfer<SetPartialRow>,
+    getPartialRowDeps?: React.DependencyList,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (store: Store<Schemas>, partialRow: SetPartialRow) => void,
+    thenDeps?: React.DependencyList,
+  ) => ParameterizedCallback<Parameter>;
 
-/**
+  /**
  * The useSetCellCallback hook returns a parameterized callback that can be used
  * to set the value of a single Cell in a Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useSetCellCallback<Parameter>(
+ *   tableId: Id,
+ *   rowId: Id,
+ *   cellId: Id,
+ *   getCell: (parameter: Parameter, store: Store) => Cell | MapCell,
+ *   getCellDeps?: React.DependencyList,
+ *   storeOrStoreId?: StoreOrStoreId,
+ *   then?: (store: Store, cell: Cell | MapCell) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): ParameterizedCallback<Parameter>;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * mutate the data in the Store. In this case, the parameter will likely be the
  * event, so that you can use data from it as part of the mutation.
@@ -1827,21 +2143,43 @@ export function useSetPartialRowCallback<Parameter>(
  * ```
  * @category Store hooks
  */
-export function useSetCellCallback<Parameter>(
-  tableId: Id,
-  rowId: Id,
-  cellId: Id,
-  getCell: (parameter: Parameter, store: Store) => Cell | MapCell,
-  getCellDeps?: React.DependencyList,
-  storeOrStoreId?: StoreOrStoreId,
-  then?: (store: Store, cell: Cell | MapCell) => void,
-  thenDeps?: React.DependencyList,
-): ParameterizedCallback<Parameter>;
+  useSetCellCallback: <
+    Parameter,
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    CellId extends CellIdFromSchema<Schemas[0], TableId>,
+    SetOrMapCell =
+      | Cell<Schemas[0], TableId, CellId>
+      | MapCell<Schemas[0], TableId, CellId>,
+  >(
+    tableId: TableId,
+    rowId: Id,
+    cellId: CellId,
+    getCell: (
+      parameter: Parameter,
+      store: Store<Schemas>,
+    ) => NoInfer<SetOrMapCell>,
+    getCellDeps?: React.DependencyList,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (store: Store<Schemas>, cell: SetOrMapCell) => void,
+    thenDeps?: React.DependencyList,
+  ) => ParameterizedCallback<Parameter>;
 
-/**
+  /**
  * The useSetValuesCallback hook returns a parameterized callback that can be
  * used to set the keyed value data of a Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useSetValuesCallback<Parameter>(
+ *   getValues: (parameter: Parameter, store: Store) => Values,
+ *   getValuesDeps?: React.DependencyList,
+ *   storeOrStoreId?: StoreOrStoreId,
+ *   then?: (store: Store, values: Values) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): ParameterizedCallback<Parameter>;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * mutate the data in the Store. In this case, the parameter will likely be the
  * event, so that you can use data from it as part of the mutation.
@@ -1914,19 +2252,34 @@ export function useSetCellCallback<Parameter>(
  * @category Store hooks
  * @since v3.0.0
  */
-export function useSetValuesCallback<Parameter>(
-  getValues: (parameter: Parameter, store: Store) => Values,
-  getValuesDeps?: React.DependencyList,
-  storeOrStoreId?: StoreOrStoreId,
-  then?: (store: Store, values: Values) => void,
-  thenDeps?: React.DependencyList,
-): ParameterizedCallback<Parameter>;
+  useSetValuesCallback: <Parameter, SetValues = Values<Schemas[1], true>>(
+    getValues: (
+      parameter: Parameter,
+      store: Store<Schemas>,
+    ) => NoInfer<SetValues>,
+    getValuesDeps?: React.DependencyList,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (store: Store<Schemas>, values: SetValues) => void,
+    thenDeps?: React.DependencyList,
+  ) => ParameterizedCallback<Parameter>;
 
-/**
+  /**
  * The useSetPartialValuesCallback hook returns a parameterized callback that
  * can be used to set partial Values data in the Store, leaving other Values
  * unaffected.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useSetPartialValuesCallback<Parameter>(
+ *   getPartialValues: (parameter: Parameter, store: Store) => Values,
+ *   getPartialValuesDeps?: React.DependencyList,
+ *   storeOrStoreId?: StoreOrStoreId,
+ *   then?: (store: Store, partialValues: Values) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): ParameterizedCallback<Parameter>;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * mutate the data in the Store. In this case, the parameter will likely be the
  * event, so that you can use data from it as part of the mutation.
@@ -2000,18 +2353,37 @@ export function useSetValuesCallback<Parameter>(
  * @category Store hooks
  * @since v3.0.0
  */
-export function useSetPartialValuesCallback<Parameter>(
-  getPartialValues: (parameter: Parameter, store: Store) => Values,
-  getPartialValuesDeps?: React.DependencyList,
-  storeOrStoreId?: StoreOrStoreId,
-  then?: (store: Store, partialValues: Values) => void,
-  thenDeps?: React.DependencyList,
-): ParameterizedCallback<Parameter>;
+  useSetPartialValuesCallback: <
+    Parameter,
+    SetPartialValues = Values<Schemas[1], true>,
+  >(
+    getPartialValues: (
+      parameter: Parameter,
+      store: Store<Schemas>,
+    ) => NoInfer<SetPartialValues>,
+    getPartialValuesDeps?: React.DependencyList,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (store: Store<Schemas>, partialValues: SetPartialValues) => void,
+    thenDeps?: React.DependencyList,
+  ) => ParameterizedCallback<Parameter>;
 
-/**
+  /**
  * The useSetValueCallback hook returns a parameterized callback that can be
  * used to set the data of a single Value in a Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useSetValueCallback<Parameter>(
+ *   valueId: Id,
+ *   getValue: (parameter: Parameter, store: Store) => Value | MapValue,
+ *   getValueDeps?: React.DependencyList,
+ *   storeOrStoreId?: StoreOrStoreId,
+ *   then?: (store: Store, value: Value | MapValue) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): ParameterizedCallback<Parameter>;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * mutate the data in the Store. In this case, the parameter will likely be the
  * event, so that you can use data from it as part of the mutation.
@@ -2086,19 +2458,36 @@ export function useSetPartialValuesCallback<Parameter>(
  * @category Store hooks
  * @since v3.0.0
  */
-export function useSetValueCallback<Parameter>(
-  valueId: Id,
-  getValue: (parameter: Parameter, store: Store) => Value,
-  getValueDeps?: React.DependencyList,
-  storeOrStoreId?: StoreOrStoreId,
-  then?: (store: Store, value: Value) => void,
-  thenDeps?: React.DependencyList,
-): ParameterizedCallback<Parameter>;
+  useSetValueCallback: <
+    Parameter,
+    ValueId extends ValueIdFromSchema<Schemas[1]>,
+    SetOrMapValue = Value<Schemas[1], ValueId> | MapValue<Schemas[1], ValueId>,
+  >(
+    valueId: ValueId,
+    getValue: (
+      parameter: Parameter,
+      store: Store<Schemas>,
+    ) => NoInfer<SetOrMapValue>,
+    getValueDeps?: React.DependencyList,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (store: Store<Schemas>, value: SetOrMapValue) => void,
+    thenDeps?: React.DependencyList,
+  ) => ParameterizedCallback<Parameter>;
 
-/**
+  /**
  * The useDelTablesCallback hook returns a callback that can be used to remove
  * all of the tabular data in a Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useDelTablesCallback(
+ *   storeOrStoreId?: StoreOrStoreId,
+ *   then?: (store: Store) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): Callback;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * delete data in a Store.
  *
@@ -2152,16 +2541,27 @@ export function useSetValueCallback<Parameter>(
  * ```
  * @category Store hooks
  */
-export function useDelTablesCallback(
-  storeOrStoreId?: StoreOrStoreId,
-  then?: (store: Store) => void,
-  thenDeps?: React.DependencyList,
-): Callback;
+  useDelTablesCallback: (
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (store: Store<Schemas>) => void,
+    thenDeps?: React.DependencyList,
+  ) => Callback;
 
-/**
+  /**
  * The useDelTableCallback hook returns a callback that can be used to remove a
  * single Table from a Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useDelTableCallback(
+ *   tableId: Id,
+ *   storeOrStoreId?: StoreOrStoreId,
+ *   then?: (store: Store) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): Callback;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * delete data in a Store.
  *
@@ -2216,17 +2616,29 @@ export function useDelTablesCallback(
  * ```
  * @category Store hooks
  */
-export function useDelTableCallback(
-  tableId: Id,
-  storeOrStoreId?: StoreOrStoreId,
-  then?: (store: Store) => void,
-  thenDeps?: React.DependencyList,
-): Callback;
+  useDelTableCallback: <TableId extends TableIdFromSchema<Schemas[0]>>(
+    tableId: TableId,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (store: Store<Schemas>) => void,
+    thenDeps?: React.DependencyList,
+  ) => Callback;
 
-/**
+  /**
  * The useDelRowCallback hook returns a callback that can be used to remove a
  * single Row from a Table.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useDelRowCallback(
+ *   tableId: Id,
+ *   rowId: Id,
+ *   storeOrStoreId?: StoreOrStoreId,
+ *   then?: (store: Store) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): Callback;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * delete data in a Store.
  *
@@ -2282,18 +2694,32 @@ export function useDelTableCallback(
  * ```
  * @category Store hooks
  */
-export function useDelRowCallback(
-  tableId: Id,
-  rowId: Id,
-  storeOrStoreId?: StoreOrStoreId,
-  then?: (store: Store) => void,
-  thenDeps?: React.DependencyList,
-): Callback;
+  useDelRowCallback: <TableId extends TableIdFromSchema<Schemas[0]>>(
+    tableId: TableId,
+    rowId: Id,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (store: Store<Schemas>) => void,
+    thenDeps?: React.DependencyList,
+  ) => Callback;
 
-/**
+  /**
  * The useDelCellCallback hook returns a callback that can be used to remove a
  * single Cell from a Row.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useDelCellCallback(
+ *   tableId: Id,
+ *   rowId: Id,
+ *   cellId: Id,
+ *   forceDel?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ *   then?: (store: Store) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): Callback;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * delete data in a Store.
  *
@@ -2358,20 +2784,33 @@ export function useDelRowCallback(
  * ```
  * @category Store hooks
  */
-export function useDelCellCallback(
-  tableId: Id,
-  rowId: Id,
-  cellId: Id,
-  forceDel?: boolean,
-  storeOrStoreId?: StoreOrStoreId,
-  then?: (store: Store) => void,
-  thenDeps?: React.DependencyList,
-): Callback;
+  useDelCellCallback: <
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    CellId extends CellIdFromSchema<Schemas[0], TableId>,
+  >(
+    tableId: TableId,
+    rowId: Id,
+    cellId: CellId,
+    forceDel?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (store: Store<Schemas>) => void,
+    thenDeps?: React.DependencyList,
+  ) => Callback;
 
-/**
+  /**
  * The useDelValuesCallback hook returns a callback that can be used to remove
  * all of the keyed value data in a Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useDelValuesCallback(
+ *   storeOrStoreId?: StoreOrStoreId,
+ *   then?: (store: Store) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): Callback;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * delete data in a Store.
  *
@@ -2426,16 +2865,27 @@ export function useDelCellCallback(
  * @category Store hooks
  * @since v3.0.0
  */
-export function useDelValuesCallback(
-  storeOrStoreId?: StoreOrStoreId,
-  then?: (store: Store) => void,
-  thenDeps?: React.DependencyList,
-): Callback;
+  useDelValuesCallback: (
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (store: Store<Schemas>) => void,
+    thenDeps?: React.DependencyList,
+  ) => Callback;
 
-/**
+  /**
  * The useDelValueCallback hook returns a callback that can be used to remove a
  * single Value from a Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useDelValueCallback(
+ *   valueId: Id,
+ *   storeOrStoreId?: StoreOrStoreId,
+ *   then?: (store: Store) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): Callback;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * delete data in a Store.
  *
@@ -2491,17 +2941,28 @@ export function useDelValuesCallback(
  * @category Store hooks
  * @since v3.0.0
  */
-export function useDelValueCallback(
-  valueId: Id,
-  storeOrStoreId?: StoreOrStoreId,
-  then?: (store: Store) => void,
-  thenDeps?: React.DependencyList,
-): Callback;
+  useDelValueCallback: <ValueId extends ValueIdFromSchema<Schemas[1]>>(
+    valueId: ValueId,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+    then?: (store: Store<Schemas>) => void,
+    thenDeps?: React.DependencyList,
+  ) => Callback;
 
-/**
+  /**
  * The useTablesListener hook registers a listener function with a Store that
  * will be called whenever tabular data in it changes.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useTablesListener(
+ *   listener: TablesListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useTables hook).
@@ -2553,17 +3014,28 @@ export function useDelValueCallback(
  * ```
  * @category Store hooks
  */
-export function useTablesListener(
-  listener: TablesListener,
-  listenerDeps?: React.DependencyList,
-  mutator?: boolean,
-  storeOrStoreId?: StoreOrStoreId,
-): void;
+  useTablesListener: (
+    listener: TablesListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useTableIdsListener hook registers a listener function with a Store that
  * will be called whenever the Table Ids in it change.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useTableIdsListener(
+ *   listener: TableIdsListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useTableIds hook).
@@ -2616,17 +3088,29 @@ export function useTablesListener(
  * ```
  * @category Store hooks
  */
-export function useTableIdsListener(
-  listener: TableIdsListener,
-  listenerDeps?: React.DependencyList,
-  mutator?: boolean,
-  storeOrStoreId?: StoreOrStoreId,
-): void;
+  useTableIdsListener: (
+    listener: TableIdsListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useTableListener hook registers a listener function with a Store that
  * will be called whenever data in a Table changes.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useTableListener(
+ *   tableId: IdOrNull,
+ *   listener: TableListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useTable hook).
@@ -2682,18 +3166,32 @@ export function useTableIdsListener(
  * ```
  * @category Store hooks
  */
-export function useTableListener(
-  tableId: IdOrNull,
-  listener: TableListener,
-  listenerDeps?: React.DependencyList,
-  mutator?: boolean,
-  storeOrStoreId?: StoreOrStoreId,
-): void;
+  useTableListener: <
+    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+  >(
+    tableId: TableIdOrNull,
+    listener: TableListener<Schemas, TableIdOrNull>,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useRowIdsListener hook registers a listener function with a Store that
  * will be called whenever the Row Ids in a Table change.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useRowIdsListener(
+ *   tableId: IdOrNull,
+ *   listener: RowIdsListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useRowIds hook).
@@ -2749,19 +3247,37 @@ export function useTableListener(
  * ```
  * @category Store hooks
  */
-export function useRowIdsListener(
-  tableId: IdOrNull,
-  listener: RowIdsListener,
-  listenerDeps?: React.DependencyList,
-  mutator?: boolean,
-  storeOrStoreId?: StoreOrStoreId,
-): void;
+  useRowIdsListener: <
+    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+  >(
+    tableId: TableIdOrNull,
+    listener: RowIdsListener<Schemas, TableIdOrNull>,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useSortedRowIdsListener hook registers a listener function with a Store
  * that will be called whenever sorted (and optionally, paginated) Row Ids in a
  * Table change.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useSortedRowIdsListener(
+ *   tableId: Id,
+ *   cellId: Id | undefined,
+ *   descending: boolean,
+ *   offset: number,
+ *   limit: number | undefined,
+ *   listener: SortedRowIdsListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useSortedRowIds hook).
@@ -2828,22 +3344,48 @@ export function useRowIdsListener(
  * @category Store hooks
  * @since v2.0.0
  */
-export function useSortedRowIdsListener(
-  tableId: Id,
-  cellId: Id | undefined,
-  descending: boolean,
-  offset: number,
-  limit: number | undefined,
-  listener: SortedRowIdsListener,
-  listenerDeps?: React.DependencyList,
-  mutator?: boolean,
-  storeOrStoreId?: StoreOrStoreId,
-): void;
+  useSortedRowIdsListener: <
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    CellIdOrUndefined extends CellIdFromSchema<Schemas[0], TableId> | undefined,
+    Descending extends boolean,
+    Offset extends number,
+    Limit extends number | undefined,
+  >(
+    tableId: TableId,
+    cellId: CellIdOrUndefined,
+    descending: Descending,
+    offset: Offset,
+    limit: Limit,
+    listener: SortedRowIdsListener<
+      Schemas,
+      TableId,
+      CellIdOrUndefined,
+      Descending,
+      Offset,
+      Limit
+    >,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useRowListener hook registers a listener function with a Store that will
  * be called whenever data in a Row changes.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useRowListener(
+ *   tableId: IdOrNull,
+ *   rowId: IdOrNull,
+ *   listener: RowListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useRow hook).
@@ -2906,19 +3448,35 @@ export function useSortedRowIdsListener(
  * ```
  * @category Store hooks
  */
-export function useRowListener(
-  tableId: IdOrNull,
-  rowId: IdOrNull,
-  listener: RowListener,
-  listenerDeps?: React.DependencyList,
-  mutator?: boolean,
-  storeOrStoreId?: StoreOrStoreId,
-): void;
+  useRowListener: <
+    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+    RowIdOrNull extends IdOrNull,
+  >(
+    tableId: TableIdOrNull,
+    rowId: RowIdOrNull,
+    listener: RowListener<Schemas, TableIdOrNull, RowIdOrNull>,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useCellIdsListener hook registers a listener function with a Store that
  * will be called whenever the Cell Ids in a Row change.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCellIdsListener(
+ *   tableId: IdOrNull,
+ *   rowId: IdOrNull,
+ *   listener: CellIdsListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useCellIds hook).
@@ -2984,19 +3542,36 @@ export function useRowListener(
  * ```
  * @category Store hooks
  */
-export function useCellIdsListener(
-  tableId: IdOrNull,
-  rowId: IdOrNull,
-  listener: CellIdsListener,
-  listenerDeps?: React.DependencyList,
-  mutator?: boolean,
-  storeOrStoreId?: StoreOrStoreId,
-): void;
+  useCellIdsListener: <
+    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+    RowIdOrNull extends IdOrNull,
+  >(
+    tableId: TableIdOrNull,
+    rowId: RowIdOrNull,
+    listener: CellIdsListener<Schemas, TableIdOrNull, RowIdOrNull>,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useCellListener hook registers a listener function with a Store that will
  * be called whenever data in a Cell changes.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCellListener(
+ *   tableId: IdOrNull,
+ *   rowId: IdOrNull,
+ *   cellId: IdOrNull,
+ *   listener: CellListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useCell hook).
@@ -3062,20 +3637,39 @@ export function useCellIdsListener(
  * ```
  * @category Store hooks
  */
-export function useCellListener(
-  tableId: IdOrNull,
-  rowId: IdOrNull,
-  cellId: IdOrNull,
-  listener: CellListener,
-  listenerDeps?: React.DependencyList,
-  mutator?: boolean,
-  storeOrStoreId?: StoreOrStoreId,
-): void;
+  useCellListener: <
+    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+    RowIdOrNull extends IdOrNull,
+    CellIdOrNull extends
+      | (TableIdOrNull extends TableIdFromSchema<Schemas[0]>
+          ? CellIdFromSchema<Schemas[0], TableIdOrNull>
+          : AllCellIdFromSchema<Schemas[0]>)
+      | null,
+  >(
+    tableId: TableIdOrNull,
+    rowId: RowIdOrNull,
+    cellId: CellIdOrNull,
+    listener: CellListener<Schemas, TableIdOrNull, RowIdOrNull, CellIdOrNull>,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useValuesListener hook registers a listener function with a Store that
  * will be called whenever keyed value data in it changes.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useValuesListener(
+ *   listener: ValuesListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useValues hook).
@@ -3128,17 +3722,28 @@ export function useCellListener(
  * @category Store hooks
  * @since v3.0.0
  */
-export function useValuesListener(
-  listener: ValuesListener,
-  listenerDeps?: React.DependencyList,
-  mutator?: boolean,
-  storeOrStoreId?: StoreOrStoreId,
-): void;
+  useValuesListener: (
+    listener: ValuesListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useValueIdsListener hook registers a listener function with a Store that
  * will be called whenever the Value Ids in it change.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useValueIdsListener(
+ *   listener: ValueIdsListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useValueIds hook).
@@ -3192,17 +3797,29 @@ export function useValuesListener(
  * @category Store hooks
  * @since v3.0.0
  */
-export function useValueIdsListener(
-  listener: ValueIdsListener,
-  listenerDeps?: React.DependencyList,
-  mutator?: boolean,
-  storeOrStoreId?: StoreOrStoreId,
-): void;
+  useValueIdsListener: (
+    listener: ValueIdsListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useValueListener hook registers a listener function with a Store that
  * will be called whenever data in a Value changes.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useValueListener(
+ *   valueId: IdOrNull,
+ *   listener: ValueListener,
+ *   listenerDeps?: React.DependencyList,
+ *   mutator?: boolean,
+ *   storeOrStoreId?: StoreOrStoreId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useValue hook).
@@ -3259,18 +3876,30 @@ export function useValueIdsListener(
  * @category Store hooks
  * @since v3.0.0
  */
-export function useValueListener(
-  valueId: IdOrNull,
-  listener: ValueListener,
-  listenerDeps?: React.DependencyList,
-  mutator?: boolean,
-  storeOrStoreId?: StoreOrStoreId,
-): void;
+  useValueListener: <
+    ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null,
+  >(
+    valueId: ValueIdOrNull,
+    listener: ValueListener<Schemas, ValueIdOrNull>,
+    listenerDeps?: React.DependencyList,
+    mutator?: boolean,
+    storeOrStoreId?: StoreOrStoreId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useCreateMetrics hook is used to create a Metrics object within a React
  * application with convenient memoization.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCreateMetrics(
+ *   store: Store,
+ *   create: (store: Store) => Metrics,
+ *   createDeps?: React.DependencyList,
+ * ): Metrics;
+ * ```
+ *
  * It is possible to create a Metrics object outside of the React app with the
  * regular createMetrics function and pass it in, but you may prefer to create
  * it within the app, perhaps inside the top-level component. To defend against
@@ -3372,16 +4001,22 @@ export function useValueListener(
  * ```
  * @category Metrics hooks
  */
-export function useCreateMetrics(
-  store: Store,
-  create: (store: Store) => Metrics,
-  createDeps?: React.DependencyList,
-): Metrics;
+  useCreateMetrics: (
+    store: Store<Schemas>,
+    create: (store: Store<Schemas>) => Metrics<Schemas>,
+    createDeps?: React.DependencyList,
+  ) => Metrics<Schemas>;
 
-/**
+  /**
  * The useMetrics hook is used to get a reference to a Metrics object from
  * within a Provider component context.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useMetrics(id?: Id): Metrics | undefined;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context. It
  * can contain a default Metrics object (or a set of Metrics objects named by
  * Id) that can be easily accessed without having to be passed down as props
@@ -3439,12 +4074,21 @@ export function useCreateMetrics(
  * ```
  * @category Metrics hooks
  */
-export function useMetrics(id?: Id): Metrics | undefined;
+  useMetrics: (id?: Id) => Metrics<Schemas> | undefined;
 
-/**
+  /**
  * The useMetric hook gets the current value of a Metric, and registers a
  * listener so that any changes to that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useMetric(
+ *   metricId: Id,
+ *   metricsOrMetricsId?: MetricsOrMetricsId,
+ * ): number | undefined;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Metrics object or a set of Metrics objects named by
  * Id. The useMetric hook lets you indicate which Metrics object to get data
@@ -3537,15 +4181,26 @@ export function useMetrics(id?: Id): Metrics | undefined;
  * ```
  * @category Metrics hooks
  */
-export function useMetric(
-  metricId: Id,
-  metricsOrMetricsId?: MetricsOrMetricsId,
-): number | undefined;
+  useMetric: (
+    metricId: Id,
+    metricsOrMetricsId?: MetricsOrMetricsId<Schemas>,
+  ) => number | undefined;
 
-/**
+  /**
  * The useMetricListener hook registers a listener function with the Metrics
  * object that will be called whenever the value of a specified Metric changes.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useMetricListener(
+ *   metricId: IdOrNull,
+ *   listener: MetricListener,
+ *   listenerDeps?: React.DependencyList,
+ *   metricsOrMetricsId?: MetricsOrMetricsId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useMetric hook).
@@ -3607,17 +4262,27 @@ export function useMetric(
  * ```
  * @category Metrics hooks
  */
-export function useMetricListener(
-  metricId: IdOrNull,
-  listener: MetricListener,
-  listenerDeps?: React.DependencyList,
-  metricsOrMetricsId?: MetricsOrMetricsId,
-): void;
+  useMetricListener: (
+    metricId: IdOrNull,
+    listener: MetricListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    metricsOrMetricsId?: MetricsOrMetricsId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useCreateIndexes hook is used to create an Indexes object within a React
  * application with convenient memoization.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCreateIndexes(
+ *   store: Store,
+ *   create: (store: Store) => Indexes,
+ *   createDeps?: React.DependencyList,
+ * ): Indexes;
+ * ```
+ *
  * It is possible to create an Indexes object outside of the React app with the
  * regular createIndexes function and pass it in, but you may prefer to create
  * it within the app, perhaps inside the top-level component. To defend against
@@ -3727,16 +4392,22 @@ export function useMetricListener(
  * ```
  * @category Indexes hooks
  */
-export function useCreateIndexes(
-  store: Store,
-  create: (store: Store) => Indexes,
-  createDeps?: React.DependencyList,
-): Indexes;
+  useCreateIndexes: (
+    store: Store<Schemas>,
+    create: (store: Store<Schemas>) => Indexes<Schemas>,
+    createDeps?: React.DependencyList,
+  ) => Indexes<Schemas>;
 
-/**
+  /**
  * The useIndexes hook is used to get a reference to an Indexes object from
  * within a Provider component context.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useIndexes(id?: Id): Indexes | undefined;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context. It
  * can contain a default Indexes object (or a set of Indexes objects named by
  * Id) that can be easily accessed without having to be passed down as props
@@ -3794,12 +4465,21 @@ export function useCreateIndexes(
  * ```
  * @category Indexes hooks
  */
-export function useIndexes(id?: Id): Indexes | undefined;
+  useIndexes: (id?: Id) => Indexes<Schemas> | undefined;
 
-/**
+  /**
  * The useSliceIds hook gets the list of Slice Ids in an Index, and registers a
  * listener so that any changes to that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useSliceIds(
+ *   indexId: Id,
+ *   indexesOrIndexesId?: IndexesOrIndexesId,
+ * ): Ids;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Indexes object or a set of Indexes objects named by
  * Id. The useSliceIds hook lets you indicate which Indexes object to get data
@@ -3896,16 +4576,26 @@ export function useIndexes(id?: Id): Indexes | undefined;
  * ```
  * @category Indexes hooks
  */
-export function useSliceIds(
-  indexId: Id,
-  indexesOrIndexesId?: IndexesOrIndexesId,
-): Ids;
+  useSliceIds: (
+    indexId: Id,
+    indexesOrIndexesId?: IndexesOrIndexesId<Schemas>,
+  ) => Ids;
 
-/**
+  /**
  * The useSliceRowIds hook gets the list of Row Ids in a given Slice, and
  * registers a listener so that any changes to that result will cause a
  * re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useSliceRowIds(
+ *   indexId: Id,
+ *   sliceId: Id,
+ *   indexesOrIndexesId?: IndexesOrIndexesId,
+ * ): Ids;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Indexes object or a set of Indexes objects named by
  * Id. The useSliceRowIds hook lets you indicate which Indexes object to get
@@ -4009,16 +4699,27 @@ export function useSliceIds(
  * ```
  * @category Indexes hooks
  */
-export function useSliceRowIds(
-  indexId: Id,
-  sliceId: Id,
-  indexesOrIndexesId?: IndexesOrIndexesId,
-): Ids;
+  useSliceRowIds: (
+    indexId: Id,
+    sliceId: Id,
+    indexesOrIndexesId?: IndexesOrIndexesId<Schemas>,
+  ) => Ids;
 
-/**
+  /**
  * The useSliceIdsListener hook registers a listener function with the Indexes
  * object that will be called whenever the Slice Ids in an Index change.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useSliceIdsListener(
+ *   indexId: IdOrNull,
+ *   listener: SliceIdsListener,
+ *   listenerDeps?: React.DependencyList,
+ *   indexesOrIndexesId?: IndexesOrIndexesId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useSliceIds hook).
@@ -4081,17 +4782,29 @@ export function useSliceRowIds(
  * ```
  * @category Indexes hooks
  */
-export function useSliceIdsListener(
-  indexId: IdOrNull,
-  listener: SliceIdsListener,
-  listenerDeps?: React.DependencyList,
-  indexesOrIndexesId?: IndexesOrIndexesId,
-): void;
+  useSliceIdsListener: (
+    indexId: IdOrNull,
+    listener: SliceIdsListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    indexesOrIndexesId?: IndexesOrIndexesId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useSliceRowIdsListener hook registers a listener function with the
  * Indexes object that will be called whenever the Row Ids in a Slice change.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useSliceRowIdsListener(
+ *   indexId: IdOrNull,
+ *   sliceId: IdOrNull,
+ *   listener: SliceRowIdsListener,
+ *   listenerDeps?: React.DependencyList,
+ *   indexesOrIndexesId?: IndexesOrIndexesId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useSliceRowIds hook).
@@ -4162,18 +4875,28 @@ export function useSliceIdsListener(
  * ```
  * @category Indexes hooks
  */
-export function useSliceRowIdsListener(
-  indexId: IdOrNull,
-  sliceId: IdOrNull,
-  listener: SliceRowIdsListener,
-  listenerDeps?: React.DependencyList,
-  indexesOrIndexesId?: IndexesOrIndexesId,
-): void;
+  useSliceRowIdsListener: (
+    indexId: IdOrNull,
+    sliceId: IdOrNull,
+    listener: SliceRowIdsListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    indexesOrIndexesId?: IndexesOrIndexesId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useCreateRelationships hook is used to create a Relationships object
  * within a React application with convenient memoization.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCreateRelationships(
+ *   store: Store,
+ *   create: (store: Store) => Relationships,
+ *   createDeps?: React.DependencyList,
+ * ): Relationships;
+ * ```
+ *
  * It is possible to create a Relationships object outside of the React app with
  * the regular createRelationships function and pass it in, but you may prefer
  * to create it within the app, perhaps inside the top-level component. To
@@ -4291,16 +5014,22 @@ export function useSliceRowIdsListener(
  * ```
  * @category Relationships hooks
  */
-export function useCreateRelationships(
-  store: Store,
-  create: (store: Store) => Relationships,
-  createDeps?: React.DependencyList,
-): Relationships;
+  useCreateRelationships: (
+    store: Store<Schemas>,
+    create: (store: Store<Schemas>) => Relationships<Schemas>,
+    createDeps?: React.DependencyList,
+  ) => Relationships<Schemas>;
 
-/**
+  /**
  * The useRelationships hook is used to get a reference to a Relationships
  * object from within a Provider component context.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useRelationships(id?: Id): Relationships | undefined;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context. It
  * can contain a default Relationships object (or a set of Relationships objects
  * named by Id) that can be easily accessed without having to be passed down as
@@ -4366,13 +5095,23 @@ export function useCreateRelationships(
  * ```
  * @category Relationships hooks
  */
-export function useRelationships(id?: Id): Relationships | undefined;
+  useRelationships: (id?: Id) => Relationships<Schemas> | undefined;
 
-/**
+  /**
  * The useRemoteRowId hook gets the remote Row Id for a given local Row in a
  * Relationship, and registers a listener so that any changes to that result
  * will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useRemoteRowId(
+ *   relationshipId: Id,
+ *   localRowId: Id,
+ *   relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId,
+ * ): Id | undefined;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Relationships object or a set of Relationships
  * objects named by Id. The useRemoteRowId hook lets you indicate which
@@ -4471,17 +5210,27 @@ export function useRelationships(id?: Id): Relationships | undefined;
  * ```
  * @category Relationships hooks
  */
-export function useRemoteRowId(
-  relationshipId: Id,
-  localRowId: Id,
-  relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId,
-): Id | undefined;
+  useRemoteRowId: (
+    relationshipId: Id,
+    localRowId: Id,
+    relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId<Schemas>,
+  ) => Id | undefined;
 
-/**
+  /**
  * The useLocalRowIds hook gets the local Row Ids for a given remote Row in a
  * Relationship, and registers a listener so that any changes to that result
  * will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useLocalRowIds(
+ *   relationshipId: Id,
+ *   remoteRowId: Id,
+ *   relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId,
+ * ): Ids;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Relationships object or a set of Relationships
  * objects named by Id. The useLocalRowIds hook lets you indicate which
@@ -4588,17 +5337,27 @@ export function useRemoteRowId(
  * ```
  * @category Relationships hooks
  */
-export function useLocalRowIds(
-  relationshipId: Id,
-  remoteRowId: Id,
-  relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId,
-): Ids;
+  useLocalRowIds: (
+    relationshipId: Id,
+    remoteRowId: Id,
+    relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId<Schemas>,
+  ) => Ids;
 
-/**
+  /**
  * The useLinkedRowIds hook gets the linked Row Ids for a given Row in a linked
  * list Relationship, and registers a listener so that any changes to that
  * result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useLinkedRowIds(
+ *   relationshipId: Id,
+ *   firstRowId: Id,
+ *   relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId,
+ * ): Ids;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Relationships object or a set of Relationships
  * objects named by Id. The useLinkedRowIds hook lets you indicate which
@@ -4712,17 +5471,29 @@ export function useLocalRowIds(
  * ```
  * @category Relationships hooks
  */
-export function useLinkedRowIds(
-  relationshipId: Id,
-  firstRowId: Id,
-  relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId,
-): Ids;
+  useLinkedRowIds: (
+    relationshipId: Id,
+    firstRowId: Id,
+    relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId<Schemas>,
+  ) => Ids;
 
-/**
+  /**
  * The useRemoteRowIdListener hook registers a listener function with the
  * Relationships object that will be called whenever a remote Row Id in a
  * Relationship changes.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useRemoteRowIdListener(
+ *   relationshipId: IdOrNull,
+ *   localRowId: IdOrNull,
+ *   listener: RemoteRowIdListener,
+ *   listenerDeps?: React.DependencyList,
+ *   relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useRemoteRowId hook).
@@ -4799,19 +5570,31 @@ export function useLinkedRowIds(
  * ```
  * @category Relationships hooks
  */
-export function useRemoteRowIdListener(
-  relationshipId: IdOrNull,
-  localRowId: IdOrNull,
-  listener: RemoteRowIdListener,
-  listenerDeps?: React.DependencyList,
-  relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId,
-): void;
+  useRemoteRowIdListener: (
+    relationshipId: IdOrNull,
+    localRowId: IdOrNull,
+    listener: RemoteRowIdListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useLocalRowIdsListener hook registers a listener function with the
  * Relationships object that will be called whenever the local Row Ids in a
  * Relationship change.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useLocalRowIdsListener(
+ *   relationshipId: IdOrNull,
+ *   remoteRowId: IdOrNull,
+ *   listener: LocalRowIdsListener,
+ *   listenerDeps?: React.DependencyList,
+ *   relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useLocalRowsId hook).
@@ -4888,19 +5671,31 @@ export function useRemoteRowIdListener(
  * ```
  * @category Relationships hooks
  */
-export function useLocalRowIdsListener(
-  relationshipId: IdOrNull,
-  remoteRowId: IdOrNull,
-  listener: LocalRowIdsListener,
-  listenerDeps?: React.DependencyList,
-  relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId,
-): void;
+  useLocalRowIdsListener: (
+    relationshipId: IdOrNull,
+    remoteRowId: IdOrNull,
+    listener: LocalRowIdsListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useLinkedRowIdsListener hook registers a listener function with the
  * Relationships object that will be called whenever the linked Row Ids in a
  * Relationship change.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useLinkedRowIdsListener(
+ *   relationshipId: Id,
+ *   firstRowId: Id,
+ *   listener: LinkedRowIdsListener,
+ *   listenerDeps?: React.DependencyList,
+ *   relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useLinkedRowsId hook).
@@ -4974,18 +5769,28 @@ export function useLocalRowIdsListener(
  * ```
  * @category Relationships hooks
  */
-export function useLinkedRowIdsListener(
-  relationshipId: Id,
-  firstRowId: Id,
-  listener: LinkedRowIdsListener,
-  listenerDeps?: React.DependencyList,
-  relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId,
-): void;
+  useLinkedRowIdsListener: (
+    relationshipId: Id,
+    firstRowId: Id,
+    listener: LinkedRowIdsListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    relationshipsOrRelationshipsId?: RelationshipsOrRelationshipsId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useCreateQueries hook is used to create a Queries object within a React
  * application with convenient memoization.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCreateQueries(
+ *   store: Store,
+ *   create: (store: Store) => Queries,
+ *   createDeps?: React.DependencyList,
+ * ): Queries;
+ * ```
+ *
  * It is possible to create a Queries object outside of the React app with the
  * regular createQueries function and pass it in, but you may prefer to create
  * it within the app, perhaps inside the top-level component. To defend against
@@ -5098,16 +5903,22 @@ export function useLinkedRowIdsListener(
  * @category Queries hooks
  * @since v2.0.0
  */
-export function useCreateQueries(
-  store: Store,
-  create: (store: Store) => Queries,
-  createDeps?: React.DependencyList,
-): Queries;
+  useCreateQueries: (
+    store: Store<Schemas>,
+    create: (store: Store<Schemas>) => Queries<Schemas>,
+    createDeps?: React.DependencyList,
+  ) => Queries<Schemas>;
 
-/**
+  /**
  * The useQueries hook is used to get a reference to a Queries object from
  * within a Provider component context.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useQueries(id?: Id): Queries | undefined;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context. It
  * can contain a default Queries object (or a set of Queries objects named by
  * Id) that can be easily accessed without having to be passed down as props
@@ -5166,13 +5977,22 @@ export function useCreateQueries(
  * @category Queries hooks
  * @since v2.0.0
  */
-export function useQueries(id?: Id): Queries | undefined;
+  useQueries: (id?: Id) => Queries<Schemas> | undefined;
 
-/**
+  /**
  * The useResultTable hook returns an object containing the entire data of the
  * result Table of the given query, and registers a listener so that any changes
  * to that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useResultTable(
+ *   queryId: Id,
+ *   queriesOrQueriesId?: QueriesOrQueriesId,
+ * ): Table;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Queries object or a set of Queries objects named by
  * Id. The useResultTable hook lets you indicate which Queries object to get
@@ -5283,16 +6103,25 @@ export function useQueries(id?: Id): Queries | undefined;
  * @category Queries hooks
  * @since v2.0.0
  */
-export function useResultTable(
-  queryId: Id,
-  queriesOrQueriesId?: QueriesOrQueriesId,
-): Table;
+  useResultTable: (
+    queryId: Id,
+    queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
+  ) => ResultTable;
 
-/**
+  /**
  * The useResultRowIds hook returns the Ids of every Row in the result Table of
  * the given query, and registers a listener so that any changes to those Ids
  * will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useResultRowIds(
+ *   queryId: Id,
+ *   queriesOrQueriesId?: QueriesOrQueriesId,
+ * ): Ids;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Queries object or a set of Queries objects named by
  * Id. The useResultRowIds hook lets you indicate which Queries object to get
@@ -5404,16 +6233,29 @@ export function useResultTable(
  * @category Queries hooks
  * @since v2.0.0
  */
-export function useResultRowIds(
-  queryId: Id,
-  queriesOrQueriesId?: QueriesOrQueriesId,
-): Ids;
+  useResultRowIds: (
+    queryId: Id,
+    queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
+  ) => Ids;
 
-/**
+  /**
  * The useResultSortedRowIds hook returns the sorted (and optionally, paginated)
  * Ids of every Row in the result Table of the given query, and registers a
  * listener so that any changes to those Ids will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useResultSortedRowIds(
+ *   queryId: Id,
+ *   cellId?: Id,
+ *   descending?: boolean,
+ *   offset?: number,
+ *   limit?: number,
+ *   queriesOrQueriesId?: QueriesOrQueriesId,
+ * ): Ids;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Queries object or a set of Queries objects named by
  * Id. The useResultSortedRowIds hook lets you indicate which Queries object to
@@ -5553,20 +6395,30 @@ export function useResultRowIds(
  * @category Queries hooks
  * @since v2.0.0
  */
-export function useResultSortedRowIds(
-  queryId: Id,
-  cellId?: Id,
-  descending?: boolean,
-  offset?: number,
-  limit?: number,
-  queriesOrQueriesId?: QueriesOrQueriesId,
-): Ids;
+  useResultSortedRowIds: (
+    queryId: Id,
+    cellId?: Id,
+    descending?: boolean,
+    offset?: number,
+    limit?: number,
+    queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
+  ) => Ids;
 
-/**
+  /**
  * The useResultRow hook returns an object containing the data of a
  * single Row in the result Table of the given query, and registers a listener
  * so that any changes to that Row will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useResultRow(
+ *   queryId: Id,
+ *   rowId: Id,
+ *   queriesOrQueriesId?: QueriesOrQueriesId,
+ * ): Row;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Queries object or a set of Queries objects named by
  * Id. The useResultRow hook lets you indicate which Queries object to get data
@@ -5681,17 +6533,27 @@ export function useResultSortedRowIds(
  * @category Queries hooks
  * @since v2.0.0
  */
-export function useResultRow(
-  queryId: Id,
-  rowId: Id,
-  queriesOrQueriesId?: QueriesOrQueriesId,
-): Row;
+  useResultRow: (
+    queryId: Id,
+    rowId: Id,
+    queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
+  ) => ResultRow;
 
-/**
+  /**
  * The useResultCellIds hook returns the Ids of every Cell in a given Row in the
  * result Table of the given query, and registers a listener so that any changes
  * to those Ids will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useResultCellIds(
+ *   queryId: Id,
+ *   rowId: Id,
+ *   queriesOrQueriesId?: QueriesOrQueriesId,
+ * ): Ids;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Queries object or a set of Queries objects named by
  * Id. The useResultCellIds hook lets you indicate which Queries object to get
@@ -5812,17 +6674,28 @@ export function useResultRow(
  * @category Queries hooks
  * @since v2.0.0
  */
-export function useResultCellIds(
-  queryId: Id,
-  rowId: Id,
-  queriesOrQueriesId?: QueriesOrQueriesId,
-): Ids;
+  useResultCellIds: (
+    queryId: Id,
+    rowId: Id,
+    queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
+  ) => Ids;
 
-/**
+  /**
  * The useResultCell hook returns the value of a single Cell in a given Row in
  * the result Table of the given query, and registers a listener so that any
  * changes to that value will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useResultCell(
+ *   queryId: Id,
+ *   rowId: Id,
+ *   cellId: Id,
+ *   queriesOrQueriesId?: QueriesOrQueriesId,
+ * ): Cell | undefined;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Queries object or a set of Queries objects named by
  * Id. The useResultCell hook lets you indicate which Queries object to get data
@@ -5939,17 +6812,28 @@ export function useResultCellIds(
  * @category Queries hooks
  * @since v2.0.0
  */
-export function useResultCell(
-  queryId: Id,
-  rowId: Id,
-  cellId: Id,
-  queriesOrQueriesId?: QueriesOrQueriesId,
-): Cell | undefined;
+  useResultCell: (
+    queryId: Id,
+    rowId: Id,
+    cellId: Id,
+    queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
+  ) => ResultCell | undefined;
 
-/**
+  /**
  * The useResultTableListener hook registers a listener function with a Queries
  * object that will be called whenever data in a result Table changes.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useResultTableListener(
+ *   queryId: IdOrNull,
+ *   listener: ResultTableListener,
+ *   listenerDeps?: React.DependencyList,
+ *   queriesOrQueriesId?: QueriesOrQueriesId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useResultTable hook).
@@ -6017,17 +6901,28 @@ export function useResultCell(
  * @category Queries hooks
  * @since v2.0.0
  */
-export function useResultTableListener(
-  queryId: IdOrNull,
-  listener: ResultTableListener,
-  listenerDeps?: React.DependencyList,
-  queriesOrQueriesId?: QueriesOrQueriesId,
-): void;
+  useResultTableListener: (
+    queryId: IdOrNull,
+    listener: ResultTableListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useResultRowIdsListener hook registers a listener function with a Queries
  * object that will be called whenever the Row Ids in a result Table change.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useResultRowIdsListener(
+ *   queryId: IdOrNull,
+ *   listener: ResultRowIdsListener,
+ *   listenerDeps?: React.DependencyList,
+ *   queriesOrQueriesId?: QueriesOrQueriesId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useResultRowIds hook).
@@ -6095,18 +6990,33 @@ export function useResultTableListener(
  * @category Queries hooks
  * @since v2.0.0
  */
-export function useResultRowIdsListener(
-  queryId: IdOrNull,
-  listener: ResultRowIdsListener,
-  listenerDeps?: React.DependencyList,
-  queriesOrQueriesId?: QueriesOrQueriesId,
-): void;
+  useResultRowIdsListener: (
+    queryId: IdOrNull,
+    listener: ResultRowIdsListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useResultSortedRowIdsListener hook registers a listener function with a
  * Queries object that will be called whenever the sorted (and optionally,
  * paginated) Row Ids in a result Table change.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useResultSortedRowIdsListener(
+ *   queryId: Id,
+ *   cellId: Id | undefined,
+ *   descending: boolean,
+ *   offset: number,
+ *   limit: number | undefined,
+ *   listener: ResultRowIdsListener,
+ *   listenerDeps?: React.DependencyList,
+ *   queriesOrQueriesId?: QueriesOrQueriesId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useResultSortedRowIds hook).
@@ -6180,21 +7090,33 @@ export function useResultRowIdsListener(
  * @category Queries hooks
  * @since v2.0.0
  */
-export function useResultSortedRowIdsListener(
-  queryId: Id,
-  cellId: Id | undefined,
-  descending: boolean,
-  offset: number,
-  limit: number | undefined,
-  listener: ResultRowIdsListener,
-  listenerDeps?: React.DependencyList,
-  queriesOrQueriesId?: QueriesOrQueriesId,
-): void;
+  useResultSortedRowIdsListener: (
+    queryId: Id,
+    cellId: Id | undefined,
+    descending: boolean,
+    offset: number,
+    limit: number | undefined,
+    listener: ResultRowIdsListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useResultRowListener hook registers a listener function with a Queries
  * object that will be called whenever data in a result Row changes.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useResultRowListener(
+ *   queryId: IdOrNull,
+ *   rowId: IdOrNull,
+ *   listener: ResultRowListener,
+ *   listenerDeps?: React.DependencyList,
+ *   queriesOrQueriesId?: QueriesOrQueriesId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useResultRow hook).
@@ -6268,19 +7190,31 @@ export function useResultSortedRowIdsListener(
  * @category Queries hooks
  * @since v2.0.0
  */
-export function useResultRowListener(
-  queryId: IdOrNull,
-  rowId: IdOrNull,
-  listener: ResultRowListener,
-  listenerDeps?: React.DependencyList,
-  queriesOrQueriesId?: QueriesOrQueriesId,
-): void;
+  useResultRowListener: (
+    queryId: IdOrNull,
+    rowId: IdOrNull,
+    listener: ResultRowListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useResultCellIdsListener hook registers a listener function with a
  * Queries object that will be called whenever the Cell Ids in a result Row
  * change.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useResultCellIdsListener(
+ *   queryId: IdOrNull,
+ *   rowId: IdOrNull,
+ *   listener: ResultCellIdsListener,
+ *   listenerDeps?: React.DependencyList,
+ *   queriesOrQueriesId?: QueriesOrQueriesId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useResultCellIds hook).
@@ -6353,18 +7287,31 @@ export function useResultRowListener(
  * @category Queries hooks
  * @since v2.0.0
  */
-export function useResultCellIdsListener(
-  queryId: IdOrNull,
-  rowId: IdOrNull,
-  listener: ResultCellIdsListener,
-  listenerDeps?: React.DependencyList,
-  queriesOrQueriesId?: QueriesOrQueriesId,
-): void;
+  useResultCellIdsListener: (
+    queryId: IdOrNull,
+    rowId: IdOrNull,
+    listener: ResultCellIdsListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useResultCellListener hook registers a listener function with a Queries
  * object that will be called whenever data in a Cell changes.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useResultCellListener(
+ *   queryId: IdOrNull,
+ *   rowId: IdOrNull,
+ *   cellId: IdOrNull,
+ *   listener: ResultCellListener,
+ *   listenerDeps?: React.DependencyList,
+ *   queriesOrQueriesId?: QueriesOrQueriesId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useResultCell hook).
@@ -6440,19 +7387,29 @@ export function useResultCellIdsListener(
  * @category Queries hooks
  * @since v2.0.0
  */
-export function useResultCellListener(
-  queryId: IdOrNull,
-  rowId: IdOrNull,
-  cellId: IdOrNull,
-  listener: ResultCellListener,
-  listenerDeps?: React.DependencyList,
-  queriesOrQueriesId?: QueriesOrQueriesId,
-): void;
+  useResultCellListener: (
+    queryId: IdOrNull,
+    rowId: IdOrNull,
+    cellId: IdOrNull,
+    listener: ResultCellListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    queriesOrQueriesId?: QueriesOrQueriesId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useCreateCheckpoints hook is used to create a Checkpoints object within a
  * React application with convenient memoization.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCreateCheckpoints(
+ *   store: Store,
+ *   create: (store: Store) => Checkpoints,
+ *   createDeps?: React.DependencyList,
+ * ): Checkpoints;
+ * ```
+ *
  * It is possible to create a Checkpoints object outside of the React app with
  * the regular createCheckpoints function and pass it in, but you may prefer to
  * create it within the app, perhaps inside the top-level component. To defend
@@ -6544,16 +7501,22 @@ export function useResultCellListener(
  * ```
  * @category Checkpoints hooks
  */
-export function useCreateCheckpoints(
-  store: Store,
-  create: (store: Store) => Checkpoints,
-  createDeps?: React.DependencyList,
-): Checkpoints;
+  useCreateCheckpoints: (
+    store: Store<Schemas>,
+    create: (store: Store<Schemas>) => Checkpoints<Schemas>,
+    createDeps?: React.DependencyList,
+  ) => Checkpoints<Schemas>;
 
-/**
+  /**
  * The useCheckpoints hook is used to get a reference to a Checkpoints object
  * from within a Provider component context.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCheckpoints(id?: Id): Checkpoints | undefined;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context. It
  * can contain a default Checkpoints object (or a set of Checkpoints objects
  * named by Id) that can be easily accessed without having to be passed down as
@@ -6617,13 +7580,21 @@ export function useCreateCheckpoints(
  * ```
  * @category Checkpoints hooks
  */
-export function useCheckpoints(id?: Id): Checkpoints | undefined;
+  useCheckpoints: (id?: Id) => Checkpoints<Schemas> | undefined;
 
-/**
+  /**
  * The useCheckpointIds hook returns an array of the checkpoint Ids being
  * managed by this Checkpoints object, and registers a listener so that any
  * changes to that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCheckpointIds(
+ *   checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
+ * ): CheckpointIds;
+ * ```
+ *
  *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Checkpoints object or a set of Checkpoints objects
@@ -6716,14 +7687,23 @@ export function useCheckpoints(id?: Id): Checkpoints | undefined;
  * ```
  * @category Checkpoints hooks
  */
-export function useCheckpointIds(
-  checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
-): CheckpointIds;
+  useCheckpointIds: (
+    checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId<Schemas>,
+  ) => CheckpointIds;
 
-/**
+  /**
  * The useCheckpoint hook returns the label for a checkpoint, and registers a
  * listener so that any changes to that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCheckpoint(
+ *   checkpointId: Id,
+ *   checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
+ * ): string | undefined;
+ * ```
+ *
  * A Provider component is used to wrap part of an application in a context, and
  * it can contain a default Checkpoints object or a set of Checkpoints objects
  * named by Id. The useCheckpoint hook lets you indicate which Checkpoints
@@ -6809,16 +7789,28 @@ export function useCheckpointIds(
  * ```
  * @category Checkpoints hooks
  */
-export function useCheckpoint(
-  checkpointId: Id,
-  checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
-): string | undefined;
+  useCheckpoint: (
+    checkpointId: Id,
+    checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId<Schemas>,
+  ) => string | undefined;
 
-/**
+  /**
  * The useSetCheckpointCallback hook returns a parameterized callback that can
  * be used to record a checkpoint of a Store into a Checkpoints object that can
  * be reverted to in the future.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useSetCheckpointCallback<Parameter>(
+ *   getCheckpoint?: (parameter: Parameter) => string,
+ *   getCheckpointDeps?: React.DependencyList,
+ *   checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
+ *   then?: (checkpointId: Id, checkpoints: Checkpoints, label?: string) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): ParameterizedCallback<Parameter>;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * set the checkpoint. In this case, the parameter will likely be the event, so
  * that you can use data from it as the checkpoint label.
@@ -6889,19 +7881,31 @@ export function useCheckpoint(
  * ```
  * @category Checkpoints hooks
  */
-export function useSetCheckpointCallback<Parameter>(
-  getCheckpoint?: (parameter: Parameter) => string,
-  getCheckpointDeps?: React.DependencyList,
-  checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
-  then?: (checkpointId: Id, checkpoints: Checkpoints, label?: string) => void,
-  thenDeps?: React.DependencyList,
-): ParameterizedCallback<Parameter>;
+  useSetCheckpointCallback: <Parameter>(
+    getCheckpoint?: (parameter: Parameter) => string,
+    getCheckpointDeps?: React.DependencyList,
+    checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId<Schemas>,
+    then?: (
+      checkpointId: Id,
+      checkpoints: Checkpoints<Schemas>,
+      label?: string,
+    ) => void,
+    thenDeps?: React.DependencyList,
+  ) => ParameterizedCallback<Parameter>;
 
-/**
+  /**
  * The useGoBackwardCallback hook returns a callback that moves the state of the
  * underlying Store back to the previous checkpoint, effectively performing an
  * 'undo' on the Store data.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useGoBackwardCallback(
+ *   checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
+ * ): Callback;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will go
  * backward to the previous checkpoint - such as when clicking an undo button.
  *
@@ -6941,15 +7945,23 @@ export function useSetCheckpointCallback<Parameter>(
  * ```
  * @category Checkpoints hooks
  */
-export function useGoBackwardCallback(
-  checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
-): Callback;
+  useGoBackwardCallback: (
+    checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId<Schemas>,
+  ) => Callback;
 
-/**
+  /**
  * The useGoForwardCallback hook returns a callback that moves the state of the
  * underlying Store forwards to a future checkpoint, effectively performing an
  * 'redo' on the Store data.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useGoForwardCallback(
+ *   checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
+ * ): Callback;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will go
  * forward to the next checkpoint - such as when clicking an redo button.
  *
@@ -6993,15 +8005,27 @@ export function useGoBackwardCallback(
  * ```
  * @category Checkpoints hooks
  */
-export function useGoForwardCallback(
-  checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
-): Callback;
+  useGoForwardCallback: (
+    checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId<Schemas>,
+  ) => Callback;
 
-/**
+  /**
  * The useGoToCallback hook returns a parameterized callback that can be used to
  * move the state of the underlying Store backwards or forwards to a specified
  * checkpoint.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useGoToCallback<Parameter>(
+ *   getCheckpointId: (parameter: Parameter) => Id,
+ *   getCheckpointIdDeps?: React.DependencyList,
+ *   checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
+ *   then?: (checkpoints: Checkpoints, checkpointId: Id) => void,
+ *   thenDeps?: React.DependencyList,
+ * ): ParameterizedCallback<Parameter>;
+ * ```
+ *
  * This hook is useful, for example, when creating an event handler that will
  * move the checkpoint. In this case, the parameter will likely be the event, so
  * that you can use data from it as the checkpoint Id to move to.
@@ -7069,19 +8093,27 @@ export function useGoForwardCallback(
  * ```
  * @category Checkpoints hooks
  */
-export function useGoToCallback<Parameter>(
-  getCheckpointId: (parameter: Parameter) => Id,
-  getCheckpointIdDeps?: React.DependencyList,
-  checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
-  then?: (checkpoints: Checkpoints, checkpointId: Id) => void,
-  thenDeps?: React.DependencyList,
-): ParameterizedCallback<Parameter>;
+  useGoToCallback: <Parameter>(
+    getCheckpointId: (parameter: Parameter) => Id,
+    getCheckpointIdDeps?: React.DependencyList,
+    checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId<Schemas>,
+    then?: (checkpoints: Checkpoints<Schemas>, checkpointId: Id) => void,
+    thenDeps?: React.DependencyList,
+  ) => ParameterizedCallback<Parameter>;
 
-/**
+  /**
  * The useUndoInformation hook returns an UndoOrRedoInformation array that
  * indicates if and how you can move the state of the underlying Store backward
  * to the previous checkpoint.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useUndoInformation(
+ *   checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
+ * ): UndoOrRedoInformation;
+ * ```
+ *
  * This hook is useful if you are building an undo button: the information
  * contains whether an undo action is available (to enable the button), the
  * callback to perform the undo action, the current checkpoint Id that will be
@@ -7119,15 +8151,23 @@ export function useGoToCallback<Parameter>(
  * ```
  * @category Checkpoints hooks
  */
-export function useUndoInformation(
-  checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
-): UndoOrRedoInformation;
+  useUndoInformation: (
+    checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId<Schemas>,
+  ) => UndoOrRedoInformation;
 
-/**
+  /**
  * The useRedoInformation hook returns an UndoOrRedoInformation array that
  * indicates if and how you can move the state of the underlying Store forwards
  * to a future checkpoint.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useRedoInformation(
+ *   checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
+ * ): UndoOrRedoInformation;
+ * ```
+ *
  * This hook is useful if you are building an redo button: the information
  * contains whether a redo action is available (to enable the button), the
  * callback to perform the redo action, the checkpoint Id that will be redone,
@@ -7166,15 +8206,25 @@ export function useUndoInformation(
  * ```
  * @category Checkpoints hooks
  */
-export function useRedoInformation(
-  checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
-): UndoOrRedoInformation;
+  useRedoInformation: (
+    checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId<Schemas>,
+  ) => UndoOrRedoInformation;
 
-/**
+  /**
  * The useCheckpointIdsListener hook registers a listener function with the
  * Checkpoints object that will be called whenever its set of checkpoints
  * changes.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCheckpointIdsListener(
+ *   listener: CheckpointIdsListener,
+ *   listenerDeps?: React.DependencyList,
+ *   checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useCheckpointIds hook).
@@ -7229,17 +8279,28 @@ export function useRedoInformation(
  * ```
  * @category Checkpoints hooks
  */
-export function useCheckpointIdsListener(
-  listener: CheckpointIdsListener,
-  listenerDeps?: React.DependencyList,
-  checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
-): void;
+  useCheckpointIdsListener: (
+    listener: CheckpointIdsListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useCheckpointListener hook registers a listener function with the
  * Checkpoints object that will be called whenever the label of a checkpoint
  * changes.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCheckpointListener(
+ *   checkpointId: IdOrNull,
+ *   listener: CheckpointListener,
+ *   listenerDeps?: React.DependencyList,
+ *   checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
+ * ): void;
+ * ```
+ *
  * This hook is useful for situations where a component needs to register its
  * own specific listener to do more than simply tracking the value (which is
  * more easily done with the useCheckpoint hook).
@@ -7300,17 +8361,29 @@ export function useCheckpointIdsListener(
  * ```
  * @category Checkpoints hooks
  */
-export function useCheckpointListener(
-  checkpointId: IdOrNull,
-  listener: CheckpointListener,
-  listenerDeps?: React.DependencyList,
-  checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId,
-): void;
+  useCheckpointListener: (
+    checkpointId: IdOrNull,
+    listener: CheckpointListener<Schemas>,
+    listenerDeps?: React.DependencyList,
+    checkpointsOrCheckpointsId?: CheckpointsOrCheckpointsId<Schemas>,
+  ) => void;
 
-/**
+  /**
  * The useCreatePersister hook is used to create a Persister within a React
  * application along with convenient memoization and callbacks.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useCreatePersister(
+ *   store: Store,
+ *   create: (store: Store) => Persister,
+ *   createDeps?: React.DependencyList,
+ *   then?: (persister: Persister) => Promise<void>,
+ *   thenDeps?: React.DependencyList,
+ * ): Persister;
+ * ```
+ *
  * It is possible to create a Persister outside of the React app with the
  * regular createPersister function and pass it in, but you may prefer to create
  * it within the app, perhaps inside the top-level component. To defend against
@@ -7435,801 +8508,203 @@ export function useCheckpointListener(
  * ```
  *  @category Persister hooks
  */
-export function useCreatePersister(
-  store: Store,
-  create: (store: Store) => Persister,
-  createDeps?: React.DependencyList,
-  then?: (persister: Persister) => Promise<void>,
-  thenDeps?: React.DependencyList,
-): Persister;
+  useCreatePersister: (
+    store: Store<Schemas>,
+    create: (store: Store<Schemas>) => Persister<Schemas>,
+    createDeps?: React.DependencyList,
+    then?: (persister: Persister<Schemas>) => Promise<void>,
+    thenDeps?: React.DependencyList,
+  ) => Persister<Schemas>;
 
-/**
+  /**
  * The ExtraProps type represents a set of arbitrary additional props.
  *
  * @category Props
  */
-export type ExtraProps = {[propName: string]: any};
+  ExtraProps: ExtraProps;
 
-/**
+  /**
  * TablesProps props are used for components that refer to all the Tables in a
  * Store, such as the TablesView component.
  *
  * @category Props
  */
-export type TablesProps = {
-  /**
-   * The Store to be accessed: omit for the default context Store, provide an Id
-   * for a named context Store, or provide an explicit reference.
-   */
-  readonly store?: StoreOrStoreId;
-  /**
-   * A component for rendering each Table in the Store (to override the default
-   * TableView component).
-   */
-  readonly tableComponent?: ComponentType<TableProps>;
-  /**
-   * A custom function for generating extra props for each Table component based
-   * on its Id.
-   */
-  readonly getTableComponentProps?: (tableId: Id) => ExtraProps;
-  /**
-   * A component or string to separate each Table component.
-   */
-  readonly separator?: ReactElement | string;
-  /**
-   * Whether the component should also render the Ids of each Table, and its
-   * descendent objects, to assist with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  TablesProps: TablesProps<Schemas>;
 
-/**
+  /**
  * TableProps props are used for components that refer to a single Table in a
  * Store, such as the TableView component.
  *
  * @category Props
  */
-export type TableProps = {
-  /**
-   * The Id of the Table in the Store to be rendered.
-   */
-  readonly tableId: Id;
-  /**
-   * The Store to be accessed: omit for the default context Store, provide an Id
-   * for a named context Store, or provide an explicit reference.
-   */
-  readonly store?: StoreOrStoreId;
-  /**
-   * A custom component for rendering each Row in the Table (to override the
-   * default RowView component).
-   */
-  readonly rowComponent?: ComponentType<RowProps>;
-  /**
-   * A function for generating extra props for each custom Row component based
-   * on its Id.
-   */
-  readonly getRowComponentProps?: (rowId: Id) => ExtraProps;
-  /**
-   * A component or string to separate each Row component.
-   */
-  readonly separator?: ReactElement | string;
-  /**
-   * Whether the component should also render the Id of the Table, and its
-   * descendent objects, to assist with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  TableProps: TableProps<Schemas>;
 
-/**
+  /**
  * SortedTableProps props are used for components that refer to a single sorted
  * Table in a Store, such as the SortedTableView component.
  *
  * @category Props
  * @since v2.0.0
  */
-export type SortedTableProps = {
-  /**
-   * The Id of the Table in the Store to be rendered.
-   */
-  readonly tableId: Id;
-  /**
-   * The Id of the Cell whose values are used for the sorting. If omitted, the
-   * view will sort the Row Id itself.
-   */
-  readonly cellId?: Id;
-  /**
-   * Whether the sorting should be in descending order.
-   */
-  readonly descending?: boolean;
-  /**
-   * The number of Row Ids to skip for pagination purposes.
-   */
-  readonly offset?: number;
-  /**
-   * The maximum number of Row Ids to return.
-   */
-  readonly limit?: number;
-  /**
-   * The Store to be accessed: omit for the default context Store, provide an Id
-   * for a named context Store, or provide an explicit reference.
-   */
-  readonly store?: StoreOrStoreId;
-  /**
-   * A custom component for rendering each Row in the Table (to override the
-   * default RowView component).
-   */
-  readonly rowComponent?: ComponentType<RowProps>;
-  /**
-   * A function for generating extra props for each custom Row component based
-   * on its Id.
-   */
-  readonly getRowComponentProps?: (rowId: Id) => ExtraProps;
-  /**
-   * A component or string to separate each Row component.
-   */
-  readonly separator?: ReactElement | string;
-  /**
-   * Whether the component should also render the Id of the Table, and its
-   * descendent objects, to assist with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  SortedTableProps: SortedTableProps<Schemas>;
 
-/**
+  /**
  * RowProps props are used for components that refer to a single Row in a Table,
  * such as the RowView component.
  *
  * @category Props
  */
-export type RowProps = {
-  /**
-   * The Id of the Table in the Store.
-   */
-  readonly tableId: Id;
-  /**
-   * The Id of the Row in the Table to be rendered.
-   */
-  readonly rowId: Id;
-  /**
-   * The Store to be accessed: omit for the default context Store, provide an Id
-   * for a named context Store, or provide an explicit reference.
-   */
-  readonly store?: StoreOrStoreId;
-  /**
-   * A custom component for rendering each Cell in the Row (to override the
-   * default CellView component).
-   */
-  readonly cellComponent?: ComponentType<CellProps>;
-  /**
-   * A function for generating extra props for each custom Cell component based
-   * on its Id.
-   */
-  readonly getCellComponentProps?: (cellId: Id) => ExtraProps;
-  /**
-   * A component or string to separate each Cell component.
-   */
-  readonly separator?: ReactElement | string;
-  /**
-   * Whether the component should also render the Id of the Row, and its
-   * descendent objects, to assist with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  RowProps: RowProps<Schemas>;
 
-/**
+  /**
  * CellProps props are used for components that refer to a single Cell in a Row,
  * such as the CellView component.
  *
  * @category Props
  */
-export type CellProps = {
-  /**
-   * The Id of the Table in the Store.
-   */
-  readonly tableId: Id;
-  /**
-   * The Id of the Row in the Table.
-   */
-  readonly rowId: Id;
-  /**
-   * The Id of the Cell in the Row to be rendered.
-   */
-  readonly cellId: Id;
-  /**
-   * The Store to be accessed: omit for the default context Store, provide an Id
-   * for a named context Store, or provide an explicit reference.
-   */
-  readonly store?: StoreOrStoreId;
-  /**
-   * Whether the component should also render the Id of the Cell to assist with
-   * debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  CellProps: CellProps<Schemas>;
 
-/**
+  /**
  * ValuesProps props are used for components that refer to all the Values in a
  * Store, such as the ValuesView component.
  *
  * @category Props
  * @since v3.0.0
  */
-export type ValuesProps = {
-  /**
-   * The Store to be accessed: omit for the default context Store, provide an Id
-   * for a named context Store, or provide an explicit reference.
-   */
-  readonly store?: StoreOrStoreId;
-  /**
-   * A custom component for rendering each Value in the Store (to override the
-   * default ValueView component).
-   */
-  readonly valueComponent?: ComponentType<ValueProps>;
-  /**
-   * A function for generating extra props for each custom Value component based
-   * on its Id.
-   */
-  readonly getValueComponentProps?: (valueId: Id) => ExtraProps;
-  /**
-   * A component or string to separate each Value component.
-   */
-  readonly separator?: ReactElement | string;
-  /**
-   * Whether the component should also render the Ids of each Value to assist
-   * with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  ValuesProps: ValuesProps<Schemas>;
 
-/**
+  /**
  * ValueProps props are used for components that refer to a single Value in a
  * Row, such as the ValueView component.
  *
  * @category Props
  * @since v3.0.0
  */
-export type ValueProps = {
-  /**
-   * The Id of the Value in the Row to be rendered.
-   */
-  readonly valueId: Id;
-  /**
-   * The Store to be accessed: omit for the default context Store, provide an Id
-   * for a named context Store, or provide an explicit reference.
-   */
-  readonly store?: StoreOrStoreId;
-  /**
-   * Whether the component should also render the Id of the Value to assist with
-   * debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  ValueProps: ValueProps<Schemas>;
 
-/**
+  /**
  * MetricProps props are used for components that refer to a single Metric in a
  * Metrics object, such as the MetricView component.
  *
  * @category Props
  */
-export type MetricProps = {
-  /**
-   * The Id of the Metric in the Metrics object to be rendered.
-   */
-  readonly metricId: Id;
-  /**
-   * The Metrics object to be accessed: omit for the default context Metrics
-   * object, provide an Id for a named context Metrics object, or provide an
-   * explicit reference.
-   */
-  readonly metrics?: MetricsOrMetricsId;
-  /**
-   * Whether the component should also render the Id of the Metric to assist
-   * with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  MetricProps: MetricProps<Schemas>;
 
-/**
+  /**
  * IndexProps props are used for components that refer to a single Index in an
  * Indexes object, such as the IndexView component.
  *
  * @category Props
  */
-export type IndexProps = {
-  /**
-   * The Id of the Index in the Indexes object to be rendered.
-   */
-  readonly indexId: Id;
-  /**
-   * The Indexes object to be accessed: omit for the default context Indexes
-   * object, provide an Id for a named context Indexes object, or provide an
-   * explicit reference.
-   */
-  readonly indexes?: IndexesOrIndexesId;
-  /**
-   * A component for rendering each Slice in the Index.
-   */
-  readonly sliceComponent?: ComponentType<SliceProps>;
-  /**
-   * A function for generating extra props for each Slice component based on its
-   * Id.
-   */
-  readonly getSliceComponentProps?: (sliceId: Id) => ExtraProps;
-  /**
-   * A component or string to separate each Slice component.
-   */
-  readonly separator?: ReactElement | string;
-  /**
-   * Whether the component should also render the Id of the Index, and its
-   * descendent objects, to assist with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  IndexProps: IndexProps<Schemas>;
 
-/**
- * IndexProps props are used for components that refer to a single Slice in an
+  /**
+ * SliceProps props are used for components that refer to a single Slice in an
  * Index object, such as the SliceView component.
  *
  * @category Props
  */
-export type SliceProps = {
-  /**
-   * The Id of the Index in the Indexes object.
-   */
-  readonly indexId: Id;
-  /**
-   * The Id of the Slice in the Index to be rendered.
-   */
-  readonly sliceId: Id;
-  /**
-   * The Indexes object to be accessed: omit for the default context Indexes
-   * object, provide an Id for a named context Indexes object, or provide an
-   * explicit reference.
-   */
-  readonly indexes?: IndexesOrIndexesId;
-  /**
-   * A component for rendering each Row in the Index.
-   */
-  readonly rowComponent?: ComponentType<RowProps>;
-  /**
-   * A function for generating extra props for each Row component based on its
-   * Id.
-   */
-  readonly getRowComponentProps?: (rowId: Id) => ExtraProps;
-  /**
-   * A component or string to separate each Row component.
-   */
-  readonly separator?: ReactElement | string;
-  /**
-   * Whether the component should also render the Id of the Slice, and its
-   * descendent objects, to assist with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  SliceProps: SliceProps<Schemas>;
 
-/**
+  /**
  * RemoteRowProps props are used for components that refer to a single
  * Relationship in a Relationships object, and where you want to render a remote
  * Row based on a local Row, such as in the RemoteRowView component.
  *
  * @category Props
  */
-export type RemoteRowProps = {
-  /**
-   * The Id of the Relationship in the Relationships object.
-   */
-  readonly relationshipId: Id;
-  /**
-   * The Id of the local Row for which to render the remote Row.
-   */
-  readonly localRowId: Id;
-  /**
-   * The Relationships object to be accessed: omit for the default context
-   * Relationships object, provide an Id for a named context Relationships
-   * object, or provide an explicit reference.
-   */
-  readonly relationships?: RelationshipsOrRelationshipsId;
-  /**
-   * A component for rendering each (remote, local, or linked) Row in the
-   * Relationship.
-   */
-  readonly rowComponent?: ComponentType<RowProps>;
-  /**
-   * A function for generating extra props for each Row component based on its
-   * Id.
-   */
-  readonly getRowComponentProps?: (rowId: Id) => ExtraProps;
-  /**
-   * Whether the component should also render the Id of the Row in the
-   * Relationship, and its descendent objects, to assist with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  RemoteRowProps: RemoteRowProps<Schemas>;
 
-/**
+  /**
  * LocalRowsProps props are used for components that refer to a single
  * Relationship in a Relationships object, and where you want to render local
  * Rows based on a remote Row, such as the LocalRowsView component.
  *
  * @category Props
  */
-export type LocalRowsProps = {
-  /**
-   * The Id of the Relationship in the Relationships object.
-   */
-  readonly relationshipId: Id;
-  /**
-   * The Id of the remote Row for which to render the local Rows.
-   */
-  readonly remoteRowId: Id;
-  /**
-   * The Relationships object to be accessed: omit for the default context
-   * Relationships object, provide an Id for a named context Relationships
-   * object, or provide an explicit reference.
-   */
-  readonly relationships?: RelationshipsOrRelationshipsId;
-  /**
-   * A component for rendering each (remote, local, or linked) Row in the
-   * Relationship.
-   */
-  readonly rowComponent?: ComponentType<RowProps>;
-  /**
-   * A function for generating extra props for each Row component based on its
-   * Id.
-   */
-  readonly getRowComponentProps?: (rowId: Id) => ExtraProps;
-  /**
-   * A component or string to separate each Row component.
-   */
-  readonly separator?: ReactElement | string;
-  /**
-   * Whether the component should also render the Id of the Row in the
-   * Relationship, and its descendent objects, to assist with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  LocalRowsProps: LocalRowsProps<Schemas>;
 
-/**
+  /**
  * LinkedRowsProps props are used for components that refer to a single
  * Relationship in a Relationships object, and where you want to render a linked
  * list of Rows starting from a first Row, such as the LinkedRowsView component.
  *
  * @category Props
  */
-export type LinkedRowsProps = {
-  /**
-   * The Id of the Relationship in the Relationships object.
-   */
-  readonly relationshipId: Id;
-  /**
-   * The Id of the first Row in the linked list Relationship.
-   */
-  readonly firstRowId: Id;
-  /**
-   * The Relationships object to be accessed: omit for the default context
-   * Relationships object, provide an Id for a named context Relationships
-   * object, or provide an explicit reference.
-   */
-  readonly relationships?: RelationshipsOrRelationshipsId;
-  /**
-   * A component for rendering each (remote, local, or linked) Row in the
-   * Relationship.
-   */
-  readonly rowComponent?: ComponentType<RowProps>;
-  /**
-   * A function for generating extra props for each Row component based on its
-   * Id.
-   */
-  readonly getRowComponentProps?: (rowId: Id) => ExtraProps;
-  /**
-   * A component or string to separate each Row component.
-   */
-  readonly separator?: ReactElement | string;
-  /**
-   * Whether the component should also render the Id of the Row in the
-   * Relationship, and its descendent objects, to assist with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  LinkedRowsProps: LinkedRowsProps<Schemas>;
 
-/**
+  /**
  * ResultTableProps props are used for components that refer to a single query
  * result Table, such as the ResultTableView component.
  *
  * @category Props
  * @since v2.0.0
  */
-export type ResultTableProps = {
-  /**
-   * The Id of the query in the Queries object for which the result Table will
-   * be rendered.
-   */
-  readonly queryId: Id;
-  /**
-   * The Queries object to be accessed: omit for the default context Queries
-   * object, provide an Id for a named context Queries object, or provide an
-   * explicit reference.
-   */
-  readonly queries?: QueriesOrQueriesId;
-  /**
-   * A custom component for rendering each Row in the Table (to override the
-   * default ResultRowView component).
-   */
-  readonly resultRowComponent?: ComponentType<ResultRowProps>;
-  /**
-   * A function for generating extra props for each custom Row component based
-   * on its Id.
-   */
-  readonly getResultRowComponentProps?: (rowId: Id) => ExtraProps;
-  /**
-   * A component or string to separate each Row component.
-   */
-  readonly separator?: ReactElement | string;
-  /**
-   * Whether the component should also render the Id of the query, and its
-   * descendent objects, to assist with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  ResultTableProps: ResultTableProps<Schemas>;
 
-/**
+  /**
  * ResultSortedTableProps props are used for components that refer to a single
  * sorted query result Table, such as the ResultSortedTableView component.
  *
  * @category Props
  * @since v2.0.0
  */
-export type ResultSortedTableProps = {
-  /**
-   * The Id of the query in the Queries object for which the sorted result Table
-   * will be rendered.
-   */
-  readonly queryId: Id;
-  /**
-   * The Id of the Cell whose values are used for the sorting. If omitted, the
-   * view will sort the Row Id itself.
-   */
-  readonly cellId?: Id;
-  /**
-   * Whether the sorting should be in descending order.
-   */
-  readonly descending?: boolean;
-  /**
-   * The number of Row Ids to skip for pagination purposes.
-   */
-  readonly offset?: number;
-  /**
-   * The maximum number of Row Ids to return.
-   */
-  readonly limit?: number;
-  /**
-   * The Queries object to be accessed: omit for the default context Queries
-   * object, provide an Id for a named context Queries object, or provide an
-   * explicit reference.
-   */
-  readonly queries?: QueriesOrQueriesId;
-  /**
-   * A custom component for rendering each Row in the Table (to override the
-   * default ResultRowView component).
-   */
-  readonly resultRowComponent?: ComponentType<ResultRowProps>;
-  /**
-   * A function for generating extra props for each custom Row component based
-   * on its Id.
-   */
-  readonly getResultRowComponentProps?: (rowId: Id) => ExtraProps;
-  /**
-   * A component or string to separate each Row component.
-   */
-  readonly separator?: ReactElement | string;
-  /**
-   * Whether the component should also render the Id of the query, and its
-   * descendent objects, to assist with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  ResultSortedTableProps: ResultSortedTableProps<Schemas>;
 
-/**
+  /**
  * ResultRowProps props are used for components that refer to a single Row in a
  * query result Table, such as the ResultRowView component.
  *
  * @category Props
  * @since v2.0.0
  */
-export type ResultRowProps = {
-  /**
-   * The Id of the query in the Queries object for which the result Table will
-   * be rendered.
-   */
-  readonly queryId: Id;
-  /**
-   * The Id of the Row in the result Table to be rendered.
-   */
-  readonly rowId: Id;
-  /**
-   * The Queries object to be accessed: omit for the default context Queries
-   * object, provide an Id for a named context Queries object, or provide an
-   * explicit reference.
-   */
-  readonly queries?: QueriesOrQueriesId;
-  /**
-   * A custom component for rendering each Cell in the Row (to override the
-   * default CellView component).
-   */
-  readonly resultCellComponent?: ComponentType<ResultCellProps>;
-  /**
-   * A function for generating extra props for each custom Cell component based
-   * on its Id.
-   */
-  readonly getResultCellComponentProps?: (cellId: Id) => ExtraProps;
-  /**
-   * A component or string to separate each Cell component.
-   */
-  readonly separator?: ReactElement | string;
-  /**
-   * Whether the component should also render the Id of the Row, and its
-   * descendent objects, to assist with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  ResultRowProps: ResultRowProps<Schemas>;
 
-/**
+  /**
  * ResultRowProps props are used for components that refer to a single Cell in a
  * Row of a result Table, such as the ResultCellView component.
  *
  * @category Props
  * @since v2.0.0
  */
-export type ResultCellProps = {
-  /**
-   * The Id of the query in the Queries object for which the result Table will
-   * be rendered.
-   */
-  readonly queryId: Id;
-  /**
-   * The Id of the Row in the Table.
-   */
-  readonly rowId: Id;
-  /**
-   * The Id of the Cell in the Row to be rendered.
-   */
-  readonly cellId: Id;
-  /**
-   * The Queries object to be accessed: omit for the default context Queries
-   * object, provide an Id for a named context Queries object, or provide an
-   * explicit reference.
-   */
-  readonly queries?: QueriesOrQueriesId;
-  /**
-   * Whether the component should also render the Id of the Cell to assist with
-   * debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  ResultCellProps: ResultCellProps<Schemas>;
 
-/**
+  /**
  * CheckpointProps props are used for components that refer to a single
  * checkpoint in a Checkpoints object, such as the CheckpointView component.
  *
  * @category Props
  */
-export type CheckpointProps = {
-  /**
-   * The Id of the checkpoint in the Checkpoints object.
-   */
-  readonly checkpointId: Id;
-  /**
-   * The Checkpoints object to be accessed: omit for the default context
-   * Checkpoints object, provide an Id for a named context Checkpoints object,
-   * or provide an explicit reference.
-   */
-  readonly checkpoints?: CheckpointsOrCheckpointsId;
-  /**
-   * Whether the component should also render the Id of the checkpoint to assist
-   * with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  CheckpointProps: CheckpointProps<Schemas>;
 
-/**
+  /**
  * BackwardCheckpointsProps props are used for components that refer to a list
  * of previous checkpoints in a Checkpoints object, such as the
  * BackwardCheckpointsView component.
  *
  * @category Props
  */
-export type BackwardCheckpointsProps = {
-  /**
-   * The Checkpoints object to be accessed: omit for the default context
-   * Checkpoints object, provide an Id for a named context Checkpoints object,
-   * or provide an explicit reference.
-   */
-  readonly checkpoints?: CheckpointsOrCheckpointsId;
-  /**
-   * A component for rendering each checkpoint in the Checkpoints object.
-   */
-  readonly checkpointComponent?: ComponentType<CheckpointProps>;
-  /**
-   * A function for generating extra props for each checkpoint component based
-   * on its Id.
-   */
-  readonly getCheckpointComponentProps?: (checkpointId: Id) => ExtraProps;
-  /**
-   * A component or string to separate each Checkpoint component.
-   */
-  readonly separator?: ReactElement | string;
-  /**
-   * Whether the component should also render the Ids of the checkpoints to
-   * assist with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  BackwardCheckpointsProps: BackwardCheckpointsProps<Schemas>;
 
-/**
+  /**
  * CurrentCheckpointsProps props are used for components that refer to the
  * current checkpoints in a Checkpoints object, such as the
  * BackwardCheckpointsView component.
  *
  * @category Props
  */
-export type CurrentCheckpointProps = {
-  /**
-   * The Checkpoints object to be accessed: omit for the default context
-   * Checkpoints object, provide an Id for a named context Checkpoints object,
-   * or provide an explicit reference.
-   */
-  readonly checkpoints?: CheckpointsOrCheckpointsId;
-  /**
-   * A component for rendering each checkpoint in the Checkpoints object.
-   */
-  readonly checkpointComponent?: ComponentType<CheckpointProps>;
-  /**
-   * A function for generating extra props for each checkpoint component based
-   * on its Id.
-   */
-  readonly getCheckpointComponentProps?: (checkpointId: Id) => ExtraProps;
-  /**
-   * Whether the component should also render the Ids of the checkpoints to
-   * assist with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  CurrentCheckpointProps: CurrentCheckpointProps<Schemas>;
 
-/**
+  /**
  * ForwardCheckpointsProps props are used for components that refer to a list of
  * future checkpoints in a Checkpoints object, such as the
  * ForwardCheckpointsView component.
  *
  * @category Props
  */
-export type ForwardCheckpointsProps = {
-  /**
-   * The Checkpoints object to be accessed: omit for the default context
-   * Checkpoints object, provide an Id for a named context Checkpoints object,
-   * or provide an explicit reference.
-   */
-  readonly checkpoints?: CheckpointsOrCheckpointsId;
-  /**
-   * A component for rendering each checkpoint in the Checkpoints object.
-   */
-  readonly checkpointComponent?: ComponentType<CheckpointProps>;
-  /**
-   * A function for generating extra props for each checkpoint component based
-   * on its Id.
-   */
-  readonly getCheckpointComponentProps?: (checkpointId: Id) => ExtraProps;
-  /**
-   * A component or string to separate each Checkpoint component.
-   */
-  readonly separator?: ReactElement | string;
-  /**
-   * Whether the component should also render the Ids of the checkpoints to
-   * assist with debugging.
-   */
-  readonly debugIds?: boolean;
-};
+  ForwardCheckpointsProps: ForwardCheckpointsProps<Schemas>;
 
-/**
+  /**
  * ProviderProps props are used with the Provider component, so that Store
  * Metrics, Indexes, Relationships, Queries, and Checkpoints objects can be
  * passed into the context of an application and used throughout.
@@ -8240,81 +8715,28 @@ export type ForwardCheckpointsProps = {
  *
  * @category Props
  */
-export type ProviderProps = {
-  /**
-   * A default single Store object that will be available within the Provider
-   * context.
-   */
-  readonly store?: Store;
-  /**
-   * An object containing multiple Store objects that will be available within
-   * the Provider context by their Id.
-   */
-  readonly storesById?: {[storeId: Id]: Store};
-  /**
-   * A default single Metrics object that will be available within the Provider
-   * context.
-   */
-  readonly metrics?: Metrics;
-  /**
-   * An object containing multiple Metrics objects that will be available within
-   * the Provider context by their Id.
-   */
-  readonly metricsById?: {[metricsId: Id]: Metrics};
-  /**
-   * A default single Indexes object that will be available within the Provider
-   * context.
-   */
-  readonly indexes?: Indexes;
-  /**
-   * An object containing multiple Indexes objects that will be available within
-   * the Provider context by their Id.
-   */
-  readonly indexesById?: {[indexesId: Id]: Indexes};
-  /**
-   * A default single Relationships object that will be available within the
-   * Provider context.
-   */
-  readonly relationships?: Relationships;
-  /**
-   * An object containing multiple Relationships objects that will be available
-   * within the Provider context by their Id.
-   */
-  readonly relationshipsById?: {[relationshipsId: Id]: Relationships};
-  /**
-   * A default single Queries object that will be available within the Provider
-   * context, since v2.0.0.
-   */
-  readonly queries?: Queries;
-  /**
-   * An object containing multiple Queries objects that will be available within
-   * the Provider context by their Id, since v2.0.0.
-   */
-  readonly queriesById?: {[queriesId: Id]: Queries};
-  /**
-   * A default single Checkpoints object that will be available within the
-   * Provider context.
-   */
-  readonly checkpoints?: Checkpoints;
-  /**
-   * An object containing multiple Checkpoints objects that will be available
-   * within the Provider context by their Id.
-   */
-  readonly checkpointsById?: {[checkpointsId: Id]: Checkpoints};
-};
+  ProviderProps: ProviderProps<Schemas>;
 
-/**
+  /**
  * ComponentReturnType is a simple alias for what a React component can return:
  * either a ReactElement, or `null` for an empty component.
  *
  * @category Component
  */
-export type ComponentReturnType = ReactElement<any, any> | null;
+  ComponentReturnType: ReactElement<any, any> | null;
 
-/**
+  /**
  * The Provider component is used to wrap part of an application in a context
  * that provides default objects to be used by hooks and components within.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * Provider(
+ *   props: ProviderProps & {children: React.ReactNode},
+ * ): ComponentReturnType;
+ * ```
+ *
  * Store, Metrics, Indexes, Relationships, Queries, and Checkpoints objects can
  * be passed into the context of an application and used throughout. One of each
  * type of object can be provided as a default within the context. Additionally,
@@ -8407,15 +8829,21 @@ export type ComponentReturnType = ReactElement<any, any> | null;
  * ```
  * @category Context components
  */
-export function Provider(
-  props: ProviderProps & {children: React.ReactNode},
-): ComponentReturnType;
+  Provider: (
+    props: ProviderProps<Schemas> & {children: React.ReactNode},
+  ) => ComponentReturnType;
 
-/**
+  /**
  * The CellView component renders the value of a single Cell in a given Row, in
  * a given Table, and registers a listener so that any changes to that result
  * will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * CellView(props: CellProps): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which Cell to render based on Table Id, Row
  * Id, Cell Id, and Store (which is either the default context Store, a named
  * context Store, or an explicit reference).
@@ -8500,13 +8928,19 @@ export function Provider(
  * ```
  * @category Store components
  */
-export function CellView(props: CellProps): ComponentReturnType;
+  CellView: (props: CellProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * 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.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * RowView(props: RowProps): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which Row to render based on Table Id, Row Id,
  * and Store (which is either the default context Store, a named context Store,
  * or an explicit reference).
@@ -8614,13 +9048,19 @@ export function CellView(props: CellProps): ComponentReturnType;
  * ```
  * @category Store components
  */
-export function RowView(props: RowProps): ComponentReturnType;
+  RowView: (props: RowProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The SortedTableView component renders the contents of a single sorted Table
  * in a Store, and registers a listener so that any changes to that result will
  * cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * SortedTableView(props: SortedTableProps): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which Table to render based on Table Id, and
  * Store (which is either the default context Store, a named context Store, or
  * by explicit reference). It also takes a Cell Id to sort by and a boolean to
@@ -8744,13 +9184,19 @@ export function RowView(props: RowProps): ComponentReturnType;
  * @category Store components
  * @since v2.0.0
  */
-export function SortedTableView(props: SortedTableProps): ComponentReturnType;
+  SortedTableView: (props: SortedTableProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The TableView component renders the contents of a single Table in a Store,
  * and registers a listener so that any changes to that result will cause a
  * re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * TableView(props: TableProps): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which Table to render based on Table Id, and
  * Store (which is either the default context Store, a named context Store, or
  * by explicit reference).
@@ -8856,13 +9302,19 @@ export function SortedTableView(props: SortedTableProps): ComponentReturnType;
  * ```
  * @category Store components
  */
-export function TableView(props: TableProps): ComponentReturnType;
+  TableView: (props: TableProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The TablesView component renders the tabular contents of a Store, and
  * registers a listener so that any changes to that result will cause a
  * re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * TablesView(props: TablesProps): ComponentReturnType;
+ * ```
+ *
  * The component's props can identify which Store to render - either the default
  * context Store, a named context Store, or an explicit reference.
  *
@@ -8964,12 +9416,18 @@ export function TableView(props: TableProps): ComponentReturnType;
  * ```
  * @category Store components
  */
-export function TablesView(props: TablesProps): ComponentReturnType;
+  TablesView: (props: TablesProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The ValueView component renders the value of a single Value, and registers a
  * listener so that any changes to that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * ValueView(props: ValueProps): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which Value to render based on Value Id and
  * Store (which is either the default context Store, a named context Store, or
  * an explicit reference).
@@ -9055,13 +9513,19 @@ export function TablesView(props: TablesProps): ComponentReturnType;
  * @category Store components
  * @since v3.0.0
  */
-export function ValueView(props: ValueProps): ComponentReturnType;
+  ValueView: (props: ValueProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The ValuesView component renders the keyed value contents of a Store, and
  * registers a listener so that any changes to that result will cause a
  * re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * ValuesView(props: ValuesProps): ComponentReturnType;
+ * ```
+ *
  * The component's props can identify which Store to render - either the default
  * context Store, a named context Store, or an explicit reference.
  *
@@ -9161,12 +9625,18 @@ export function ValueView(props: ValueProps): ComponentReturnType;
  * @category Store components
  * @since v3.0.0
  */
-export function ValuesView(props: ValuesProps): ComponentReturnType;
+  ValuesView: (props: ValuesProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The MetricView component renders the current value of a Metric, and registers
  * a listener so that any changes to that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * MetricView(props: MetricProps): ComponentReturnType;
+ * ```
+ *
  * The component's props can identify which Metrics object to get data for: omit
  * the optional final parameter for the default context Metrics object, provide
  * an Id for a named context Metrics object, or by explicit reference.
@@ -9266,12 +9736,18 @@ export function ValuesView(props: ValuesProps): ComponentReturnType;
  * ```
  * @category Metrics components
  */
-export function MetricView(props: MetricProps): ComponentReturnType;
+  MetricView: (props: MetricProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The SliceView component renders the contents of a Slice, and registers a
  * listener so that any changes to that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * SliceView(props: SliceProps): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which Slice to render based on Index Id, Slice
  * Id, and Indexes object (which is either the default context Indexes object, a
  * named context Indexes object, or an explicit reference).
@@ -9392,12 +9868,18 @@ export function MetricView(props: MetricProps): ComponentReturnType;
  * ```
  * @category Indexes components
  */
-export function SliceView(props: SliceProps): ComponentReturnType;
+  SliceView: (props: SliceProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The IndexView component renders the contents of a Index, and registers a
  * listener so that any changes to that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * IndexView(props: IndexProps): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which Index to render based on Index Id, and
  * Indexes object (which is either the default context Indexes object, a named
  * context Indexes object, or an explicit reference).
@@ -9513,13 +9995,19 @@ export function SliceView(props: SliceProps): ComponentReturnType;
  * ```
  * @category Indexes components
  */
-export function IndexView(props: IndexProps): ComponentReturnType;
+  IndexView: (props: IndexProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The RemoteRowView component renders the remote Row Id for a given local Row
  * in a Relationship, and registers a listener so that any changes to that
  * result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * RemoteRowView(props: RemoteRowProps): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which remote Row to render based on
  * Relationship Id, local Row Id, and Relationships object (which is either the
  * default context Relationships object, a named context Relationships object,
@@ -9647,13 +10135,19 @@ export function IndexView(props: IndexProps): ComponentReturnType;
  * ```
  * @category Relationships components
  */
-export function RemoteRowView(props: RemoteRowProps): ComponentReturnType;
+  RemoteRowView: (props: RemoteRowProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The LocalRowsView component renders the local Row objects for a given remote
  * Row in a Relationship, and registers a listener so that any changes to that
  * result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * LocalRowsView(props: LocalRowsProps): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which local Rows to render based on
  * Relationship Id, remote Row Id, and Relationships object (which is either the
  * default context Relationships object, a named context Relationships object,
@@ -9782,13 +10276,19 @@ export function RemoteRowView(props: RemoteRowProps): ComponentReturnType;
  * ```
  * @category Relationships components
  */
-export function LocalRowsView(props: LocalRowsProps): ComponentReturnType;
+  LocalRowsView: (props: LocalRowsProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The LinkedRowsView component renders the local Row objects for a given remote
  * Row in a Relationship, and registers a listener so that any changes to that
  * result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * LinkedRowsView(props: LinkedRowsProps): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which local Rows to render based on
  * Relationship Id, remote Row Id, and Relationships object (which is either the
  * default context Relationships object, a named context Relationships object,
@@ -9922,13 +10422,19 @@ export function LocalRowsView(props: LocalRowsProps): ComponentReturnType;
  * ```
  * @category Relationships components
  */
-export function LinkedRowsView(props: LinkedRowsProps): ComponentReturnType;
+  LinkedRowsView: (props: LinkedRowsProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The ResultCellView component renders the value of a single Cell in a given
  * Row, in a given query's result Table, and registers a listener so that any
  * changes to that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * ResultCellView(props: ResultCellProps): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which Cell to render based on query Id, Row
  * Id, Cell Id, and Queries object (which is either the default context Queries
  * object, a named context Queries object, or an explicit reference).
@@ -10045,13 +10551,19 @@ export function LinkedRowsView(props: LinkedRowsProps): ComponentReturnType;
  * @category Queries components
  * @since v2.0.0
  */
-export function ResultCellView(props: ResultCellProps): ComponentReturnType;
+  ResultCellView: (props: ResultCellProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The ResultRowView component renders the contents of a single Row in a given
  * query's result Table, and registers a listener so that any changes to that
  * result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * ResultRowView(props: ResultRowProps): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which Row to render based on query Id, Row Id,
  * and Queries object (which is either the default context Queries object, a
  * named context Queries object, or an explicit reference).
@@ -10192,13 +10704,21 @@ export function ResultCellView(props: ResultCellProps): ComponentReturnType;
  * @category Queries components
  * @since v2.0.0
  */
-export function ResultRowView(props: ResultRowProps): ComponentReturnType;
+  ResultRowView: (props: ResultRowProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The ResultSortedTableView component renders the contents of a single query's
  * sorted result Table in a Queries object, and registers a listener so that any
  * changes to that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * ResultSortedTableView(
+ *   props: ResultSortedTableProps,
+ * ): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which Table to render based on query Id, and
  * Queries object (which is either the default context Queries object, a named
  * context Queries object, or by explicit reference). It also takes a Cell Id to
@@ -10330,15 +10850,21 @@ export function ResultRowView(props: ResultRowProps): ComponentReturnType;
  * @category Queries components
  * @since v2.0.0
  */
-export function ResultSortedTableView(
-  props: ResultSortedTableProps,
-): ComponentReturnType;
+  ResultSortedTableView: (
+    props: ResultSortedTableProps<Schemas>,
+  ) => ComponentReturnType;
 
-/**
+  /**
  * The ResultTableView component renders the contents of a single query's result
  * Table in a Queries object, and registers a listener so that any changes to
  * that result will cause a re-render.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * ResultTableView(props: ResultTableProps): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which Table to render based on query Id, and
  * Queries object (which is either the default context Queries object, a named
  * context Queries object, or by explicit reference).
@@ -10455,11 +10981,17 @@ export function ResultSortedTableView(
  * @category Queries components
  * @since v2.0.0
  */
-export function ResultTableView(props: ResultTableProps): ComponentReturnType;
+  ResultTableView: (props: ResultTableProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The CheckpointView component simply renders the label of a checkpoint.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * CheckpointView(props: CheckpointProps): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which checkpoint to render based on Checkpoint
  * Id and Checkpoints object (which is either the default context Checkpoints
  * object, a named context Checkpoints object, or an explicit reference).
@@ -10506,12 +11038,20 @@ export function ResultTableView(props: ResultTableProps): ComponentReturnType;
  * ```
  * @category Checkpoints components
  */
-export function CheckpointView(props: CheckpointProps): ComponentReturnType;
+  CheckpointView: (props: CheckpointProps<Schemas>) => ComponentReturnType;
 
-/**
+  /**
  * The BackwardCheckpointsView component renders a list of previous checkpoints
  * that the underlying Store can go back to.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * BackwardCheckpointsView(
+ *   props: BackwardCheckpointsProps,
+ * ): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which previous checkpoints to render based on
  * the Checkpoints object (which is either the default context Checkpoints
  * object, a named context Checkpoints object, or an explicit reference).
@@ -10641,14 +11181,22 @@ export function CheckpointView(props: CheckpointProps): ComponentReturnType;
  * ```
  * @category Checkpoints components
  */
-export function BackwardCheckpointsView(
-  props: BackwardCheckpointsProps,
-): ComponentReturnType;
+  BackwardCheckpointsView: (
+    props: BackwardCheckpointsProps<Schemas>,
+  ) => ComponentReturnType;
 
-/**
+  /**
  * The CurrentCheckpointView component renders the current checkpoint that the
  * underlying Store is currently on.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * CurrentCheckpointView(
+ *   props: CurrentCheckpointProps,
+ * ): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which current checkpoint to render based on
  * the Checkpoints object (which is either the default context Checkpoints
  * object, a named context Checkpoints object, or an explicit reference).
@@ -10778,14 +11326,22 @@ export function BackwardCheckpointsView(
  * ```
  * @category Checkpoints components
  */
-export function CurrentCheckpointView(
-  props: CurrentCheckpointProps,
-): ComponentReturnType;
+  CurrentCheckpointView: (
+    props: CurrentCheckpointProps<Schemas>,
+  ) => ComponentReturnType;
 
-/**
+  /**
  * The ForwardCheckpointsView component renders a list of future checkpoints
  * that the underlying Store can go forwards to.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * ForwardCheckpointsView(
+ *   props: ForwardCheckpointsProps,
+ * ): ComponentReturnType;
+ * ```
+ *
  * The component's props identify which future checkpoints to render based on
  * the Checkpoints object (which is either the default context Checkpoints
  * object, a named context Checkpoints object, or an explicit reference).
@@ -10916,6 +11472,7 @@ export function CurrentCheckpointView(
  * ```
  * @category Checkpoints components
  */
-export function ForwardCheckpointsView(
-  props: ForwardCheckpointsProps,
-): ComponentReturnType;
+  ForwardCheckpointsView: (
+    props: ForwardCheckpointsProps<Schemas>,
+  ) => ComponentReturnType;
+};