tinybase 3.1.0-beta.5 → 3.1.1

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

@@ -122,6 +122,12 @@ 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
@@ -139,6 +145,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
  *
@@ -158,6 +170,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
  *
@@ -177,6 +195,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
  *
@@ -196,6 +220,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
  *
@@ -216,6 +246,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
  *
@@ -248,6 +284,15 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -334,6 +379,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -396,6 +447,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -473,6 +530,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -552,6 +615,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -635,6 +704,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -718,6 +793,19 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -839,6 +927,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -926,6 +1024,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -1018,6 +1126,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -1108,6 +1227,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -1185,6 +1310,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -1265,6 +1396,15 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -1348,6 +1488,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
@@ -1434,6 +1586,19 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
@@ -1527,6 +1692,20 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
@@ -1620,6 +1799,20 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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,
+ *   reuseRowIds?: boolean,
+ * ): 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.
@@ -1641,6 +1834,13 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * hook's `storeOrStoreId` parameter) is always automatically used as a hook
  * dependency for the callback.
  *
+ * The `reuseRowIds` parameter defaults to `true`, which means that if you
+ * delete a Row and then add another, the Id will be re-used - unless you delete
+ * the entire Table, in which case all Row Ids will reset. Otherwise, if you
+ * specify `reuseRowIds` to be `false`, then the Id will be a monotonically
+ * increasing string representation of an increasing integer, regardless of any
+ * you may have previously deleted.
+ *
  * @param tableId The Id of the Table in the Store.
  * @param getRow A function which returns the Row object that will be used to
  * update the Store, based on the parameter the callback will receive (and which
@@ -1656,6 +1856,9 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param thenDeps An optional array of dependencies for the `then` function,
  * which, if any change, result in the regeneration of the callback. This
  * parameter defaults to an empty array.
+ * @param reuseRowIds Whether Ids should be recycled from previously deleted Row
+ * objects, defaulting to `true`.
+ *
  * @returns A parameterized callback for subsequent use.
  * @example
  * This example uses the useAddRowCallback hook to create an event handler which
@@ -1704,6 +1907,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     storeOrStoreId?: StoreOrStoreId<Schemas>,
     then?: (rowId: Id | undefined, store: Store<Schemas>, row: AddRow) => void,
     thenDeps?: React.DependencyList,
+    reuseRowIds?: boolean,
   ) => ParameterizedCallback<Parameter>;
 
   /**
@@ -1711,6 +1915,20 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
@@ -1808,6 +2026,21 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
@@ -1947,6 +2180,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
@@ -2035,6 +2280,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
@@ -2126,6 +2383,19 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
@@ -2220,6 +2490,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
  *
@@ -2283,6 +2563,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
  *
@@ -2348,6 +2639,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
  *
@@ -2415,6 +2718,20 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
  *
@@ -2496,6 +2813,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
  *
@@ -2560,6 +2887,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
  *
@@ -2626,6 +2964,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -2688,6 +3037,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -2751,6 +3111,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -2820,6 +3192,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -2890,6 +3274,22 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -2985,6 +3385,19 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -3063,6 +3476,19 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -3144,6 +3570,20 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -3231,6 +3671,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -3294,6 +3745,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -3358,6 +3820,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -3428,6 +3902,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -3539,6 +4023,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -3602,6 +4092,15 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -3703,6 +4202,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -3775,6 +4285,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -3894,6 +4414,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -3957,6 +4483,15 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -4063,6 +4598,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -4176,6 +4721,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -4249,6 +4805,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -4331,6 +4899,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -4458,6 +5036,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -4530,6 +5114,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -4639,6 +5233,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -4756,6 +5360,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -4880,6 +5494,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -4969,6 +5595,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -5058,6 +5696,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -5143,6 +5793,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -5265,6 +5925,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -5330,6 +5996,15 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -5450,6 +6125,15 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -5571,6 +6255,19 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -5724,6 +6421,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -5849,6 +6556,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -5980,6 +6697,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -6107,6 +6835,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -6185,6 +6924,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -6264,6 +7014,21 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -6352,6 +7117,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -6438,6 +7215,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -6522,6 +7311,19 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -6610,6 +7412,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -6711,6 +7523,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -6781,6 +7599,14 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -6881,6 +7707,15 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -6976,6 +7811,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
@@ -7063,6 +7910,14 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
  *
@@ -7111,6 +7966,14 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
  *
@@ -7163,6 +8026,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
@@ -7243,6 +8118,14 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -7289,6 +8172,14 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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,
@@ -7336,6 +8227,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -7401,6 +8302,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -7472,6 +8384,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -7817,6 +8741,14 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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,
@@ -7918,6 +8850,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -8009,6 +8947,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -8123,6 +9067,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -8253,6 +9203,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -8365,6 +9321,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
  *
@@ -8472,6 +9434,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -8564,6 +9532,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
  *
@@ -8669,6 +9643,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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.
@@ -8774,6 +9754,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -8900,6 +9886,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -9022,6 +10014,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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,
@@ -9156,6 +10154,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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,
@@ -9291,6 +10295,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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,
@@ -9431,6 +10441,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -9554,6 +10570,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -9701,6 +10723,14 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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
@@ -9841,6 +10871,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -9962,6 +10998,12 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   /**
  * 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).
@@ -10014,6 +11056,14 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -10151,6 +11201,14 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).
@@ -10288,6 +11346,14 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * 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).