tinybase 3.1.0-beta.4 → 3.1.0

package/lib/types/tinybase.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This is everything.
+ *
+ * @packageDocumentation
+ */
+
+export * from './checkpoints.d';
+export * from './common.d';
+export * from './indexes.d';
+export * from './metrics.d';
+export * from './persisters.d';
+export * from './queries.d';
+export * from './relationships.d';
+export * from './store.d';

package/lib/{debug → types}/tools.d.ts

@@ -10,13 +10,7 @@
  * @since v2.2.0
  */
 
-import {
-  NoSchemas,
-  OptionalSchemas,
-  Store,
-  TablesSchema,
-  ValuesSchema,
-} from './store.d';
+import {Store, TablesSchema, ValuesSchema} from './store.d';
 import {Id} from './common.d';
 
 /**
@@ -90,6 +84,9 @@ export type StoreStatsTableDetail = {
    * The number of Cell objects in the Table, across all Row objects.
    */
   tableCells: number;
+  /**
+   * Detail about the Table object.
+   */
   rows: {[rowId: Id]: StoreStatsRowDetail};
 };
 
@@ -115,7 +112,8 @@ export type StoreStatsRowDetail = {
  * @category Tools
  * @since v2.2.0
  */
-export interface Tools<Schemas extends OptionalSchemas = NoSchemas> {
+export interface Tools {
+  //
   /* eslint-disable max-len */
   /**
    * The getStoreStats method provides a set of statistics about the Store, and
@@ -174,6 +172,7 @@ export interface Tools<Schemas extends OptionalSchemas = NoSchemas> {
    * @since v2.2.0
    */
   getStoreStats(detail?: boolean): StoreStats;
+
   /* eslint-enable max-len */
 
   /**
@@ -483,7 +482,8 @@ export interface Tools<Schemas extends OptionalSchemas = NoSchemas> {
    * @category Getter
    * @since v3.0.0
    */
-  getStore(): Store<Schemas>;
+  getStore(): Store;
+  //
 }
 
 /* eslint-disable max-len */
@@ -530,7 +530,7 @@ export interface Tools<Schemas extends OptionalSchemas = NoSchemas> {
  * @category Creation
  * @since v2.2.0
  */
-export function createTools<Schemas extends OptionalSchemas>(
-  store: Store<Schemas>,
-): Tools<Schemas>;
+export function createTools(store: Store): Tools;
+//
+
 /* eslint-enable max-len */

package/lib/{debug → types}/ui-react.d.ts

@@ -28,7 +28,9 @@ import {
   Cell,
   CellIdsListener,
   CellListener,
+  CellOrUndefined,
   MapCell,
+  MapValue,
   Row,
   RowIdsListener,
   RowListener,
@@ -42,6 +44,7 @@ import {
   Value,
   ValueIdsListener,
   ValueListener,
+  ValueOrUndefined,
   Values,
   ValuesListener,
 } from './store.d';
@@ -1036,7 +1039,7 @@ export function useCell(
   rowId: Id,
   cellId: Id,
   storeOrStoreId?: StoreOrStoreId,
-): Cell | undefined;
+): CellOrUndefined;
 
 /**
  * The useValues hook returns a Values object containing the keyed value data of
@@ -1272,7 +1275,10 @@ export function useValueIds(storeOrStoreId?: StoreOrStoreId): Ids;
  * @category Store hooks
  * @since v3.0.0
  */
-export function useValue(valueId: Id, storeOrStoreId?: StoreOrStoreId): Value;
+export function useValue(
+  valueId: Id,
+  storeOrStoreId?: StoreOrStoreId,
+): ValueOrUndefined;
 
 /**
  * The useSetTablesCallback hook returns a parameterized callback that can be
@@ -2088,10 +2094,10 @@ export function useSetPartialValuesCallback<Parameter>(
  */
 export function useSetValueCallback<Parameter>(
   valueId: Id,
-  getValue: (parameter: Parameter, store: Store) => Value,
+  getValue: (parameter: Parameter, store: Store) => Value | MapValue,
   getValueDeps?: React.DependencyList,
   storeOrStoreId?: StoreOrStoreId,
-  then?: (store: Store, value: Value) => void,
+  then?: (store: Store, value: Value | MapValue) => void,
   thenDeps?: React.DependencyList,
 ): ParameterizedCallback<Parameter>;
 
@@ -7767,7 +7773,7 @@ export type IndexProps = {
 };
 
 /**
- * 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

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

@@ -12,7 +12,7 @@
  */
 
 import {Id, IdOrNull, Ids} from './common.d';
-import {NoSchemas, OptionalSchemas, Store} from './store.d';
+import {OptionalSchemas, Store} from './store.d';
 
 /**
  * The CheckpointIds type is a representation of the list of checkpoint Ids
@@ -51,6 +51,12 @@ export type CheckpointCallback = (checkpointId: Id, label?: string) => void;
  * The CheckpointIdsListener type describes a function that is used to listen to
  * changes to the checkpoint Ids in a Checkpoints object.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (checkpoints: Checkpoints) => void;
+ * ```
+ *
  * A CheckpointIdsListener is provided when using the addCheckpointIdsListener
  * method. See that method for specific examples.
  *
@@ -60,12 +66,23 @@ export type CheckpointCallback = (checkpointId: Id, label?: string) => void;
  * @param checkpoints A reference to the Checkpoints object that changed.
  * @category Listener
  */
-export type CheckpointIdsListener = (checkpoints: Checkpoints) => void;
+export type CheckpointIdsListener<Schemas extends OptionalSchemas> = (
+  checkpoints: Checkpoints<Schemas>,
+) => void;
 
 /**
  * The CheckpointListener type describes a function that is used to listen to
  * changes to a checkpoint's label in a Checkpoints object.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   checkpoints: Checkpoints,
+ *   checkpointId: Id,
+ * ) => void;
+ * ```
+ *
  * A CheckpointListener is provided when using the addCheckpointListener method.
  * See that method for specific examples.
  *
@@ -76,8 +93,8 @@ export type CheckpointIdsListener = (checkpoints: Checkpoints) => void;
  * @param checkpointId The Id of the checkpoint that changed.
  * @category Listener
  */
-export type CheckpointListener = (
-  checkpoints: Checkpoints,
+export type CheckpointListener<Schemas extends OptionalSchemas> = (
+  checkpoints: Checkpoints<Schemas>,
   checkpointId: Id,
 ) => void;
 
@@ -177,11 +194,17 @@ export type CheckpointsListenerStats = {
  * @see Drawing demo
  * @category Checkpoints
  */
-export interface Checkpoints<Schemas extends OptionalSchemas = NoSchemas> {
+export interface Checkpoints<in out Schemas extends OptionalSchemas> {
   /**
    * The setSize method lets you specify how many checkpoints the Checkpoints
    * object will store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * setSize(size: number): Checkpoints;
+   * ```
+   *
    * If you set more checkpoints than this size, the oldest checkpoints will be
    * pruned to make room for more recent ones.
    *
@@ -271,6 +294,12 @@ export interface Checkpoints<Schemas extends OptionalSchemas = NoSchemas> {
    * The setCheckpoint method updates the label for a checkpoint in the
    * Checkpoints object after it has been created
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * setCheckpoint(checkpointId: Id, label: string): Checkpoints;
+   * ```
+   *
    * The `label` parameter can be used to describe the actions that changed the
    * Store before the given checkpoint. This can be useful for interfaces that
    * let users 'Undo [last action]'.
@@ -326,6 +355,12 @@ export interface Checkpoints<Schemas extends OptionalSchemas = NoSchemas> {
    * The getStore method returns a reference to the underlying Store that is
    * backing this Checkpoints object.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getStore(): Store;
+   * ```
+   *
    * @returns A reference to the Store.
    * @example
    * This example creates a Checkpoints object against a newly-created Store
@@ -491,6 +526,12 @@ export interface Checkpoints<Schemas extends OptionalSchemas = NoSchemas> {
    * 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
+   * addCheckpointIdsListener(listener: CheckpointIdsListener): Id;
+   * ```
+   *
    * The provided listener is a CheckpointIdsListener function, and will be
    * called with a reference to the Checkpoints object.
    *
@@ -534,13 +575,22 @@ export interface Checkpoints<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Listener
    */
-  addCheckpointIdsListener(listener: CheckpointIdsListener): Id;
+  addCheckpointIdsListener(listener: CheckpointIdsListener<Schemas>): Id;
 
   /**
    * The addCheckpointListener method 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
+   * addCheckpointListener(
+   *   checkpointId: IdOrNull,
+   *   listener: CheckpointListener,
+   * ): Id;
+   * ```
+   *
    * You can either listen to a single checkpoint label (by specifying the
    * checkpoint Id as the method's first parameter), or changes to any
    * checkpoint label (by providing a `null` wildcard).
@@ -596,13 +646,19 @@ export interface Checkpoints<Schemas extends OptionalSchemas = NoSchemas> {
    */
   addCheckpointListener(
     checkpointId: IdOrNull,
-    listener: CheckpointListener,
+    listener: CheckpointListener<Schemas>,
   ): Id;
 
   /**
    * The delListener method removes a listener that was previously added to the
    * Checkpoints object.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * delListener(listenerId: Id): Checkpoints;
+   * ```
+   *
    * Use the Id returned by the addCheckpointIdsListener method. Note that the
    * Checkpoints object may re-use this Id for future listeners added to it.
    *
@@ -643,6 +699,12 @@ export interface Checkpoints<Schemas extends OptionalSchemas = NoSchemas> {
    * The goBackward method 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
+   * goBackward(): Checkpoints;
+   * ```
+   *
    * If there is no previous checkpoint to return to, this method has no effect.
    *
    * @returns A reference to the Checkpoints object.
@@ -676,6 +738,12 @@ export interface Checkpoints<Schemas extends OptionalSchemas = NoSchemas> {
    * The goForward method 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
+   * goForward(): Checkpoints;
+   * ```
+   *
    * If there is no future checkpoint to return to, this method has no effect.
    *
    * Note that if you have previously used the goBackward method to undo
@@ -756,6 +824,12 @@ export interface Checkpoints<Schemas extends OptionalSchemas = NoSchemas> {
    * The goTo method moves 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
+   * goTo(checkpointId: Id): Checkpoints;
+   * ```
+   *
    * If there is no checkpoint with the Id specified, this method has no effect.
    *
    * @param checkpointId The Id of the checkpoint to move to.
@@ -806,6 +880,12 @@ export interface Checkpoints<Schemas extends OptionalSchemas = NoSchemas> {
    * The clear method resets this Checkpoints object to its initial state,
    * removing all the checkpoints it has been managing.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * clear(): Checkpoints;
+   * ```
+   *
    * Obviously this method should be used with caution as it destroys the
    * ability to undo recent changes to the Store (though of course the Store
    * itself is not reset by this method).
@@ -928,6 +1008,12 @@ export interface Checkpoints<Schemas extends OptionalSchemas = NoSchemas> {
  * The createCheckpoints function creates a Checkpoints object, and is the main
  * entry point into the checkpoints module.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * createCheckpoints(store: Store): Checkpoints;
+ * ```
+ *
  * A given Store can only have one Checkpoints object associated with it. If you
  * call this function twice on the same Store, your second call will return a
  * reference to the Checkpoints object created by the first.

package/lib/{cjs → types/with-schemas}/indexes.d.ts

@@ -11,10 +11,11 @@
  * @module indexes
  */
 
+import {CellIdFromSchema, TableIdFromSchema} from './internal/store';
 import {
   GetCell,
-  NoSchemas,
   OptionalSchemas,
+  OptionalTablesSchema,
   RowCallback,
   Store,
 } from './store.d';
@@ -53,6 +54,15 @@ export type Slice = Ids;
  * The IndexCallback type describes a function that takes an Index's Id and a
  * callback to loop over each Slice within it.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   indexId: Id,
+ *   forEachSlice: (sliceCallback: SliceCallback) => void,
+ * ) => void;
+ * ```
+ *
  * A IndexCallback is provided when using the forEachIndex method, so that you
  * can do something based on every Index in the Indexes object. See that method
  * for specific examples.
@@ -62,15 +72,24 @@ export type Slice = Ids;
  * in this Index.
  * @category Callback
  */
-export type IndexCallback = (
+export type IndexCallback<Schema extends OptionalTablesSchema> = (
   indexId: Id,
-  forEachSlice: (sliceCallback: SliceCallback) => void,
+  forEachSlice: (sliceCallback: SliceCallback<Schema>) => void,
 ) => void;
 
 /**
  * The SliceCallback type describes a function that takes a Slice's Id and a
  * callback to loop over each Row within it.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   sliceId: Id,
+ *   forEachRow: (rowCallback: RowCallback) => void,
+ * ) => void;
+ * ```
+ *
  * A SliceCallback is provided when using the forEachSlice method, so that you
  * can do something based on every Slice in an Index. See that method for
  * specific examples.
@@ -80,15 +99,21 @@ export type IndexCallback = (
  * in this Slice.
  * @category Callback
  */
-export type SliceCallback = (
+export type SliceCallback<Schema extends OptionalTablesSchema> = (
   sliceId: Id,
-  forEachRow: (rowCallback: RowCallback) => void,
+  forEachRow: (rowCallback: RowCallback<Schema>) => void,
 ) => void;
 
 /**
  * The SliceIdsListener type describes a function that is used to listen to
  * changes to the Slice Ids in an Index.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (indexes: Indexes, indexId: Id) => void;
+ * ```
+ *
  * A SliceIdsListener is provided when using the addSliceIdsListener method. See
  * that method for specific examples.
  *
@@ -99,12 +124,25 @@ export type SliceCallback = (
  * @param indexId The Id of the Index that changed.
  * @category Listener
  */
-export type SliceIdsListener = (indexes: Indexes, indexId: Id) => void;
+export type SliceIdsListener<Schemas extends OptionalSchemas> = (
+  indexes: Indexes<Schemas>,
+  indexId: Id,
+) => void;
 
 /**
  * The SliceRowIdsListener type describes a function that is used to listen to
  * changes to the Row Ids in a Slice.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   indexes: Indexes,
+ *   indexId: Id,
+ *   sliceId: Id,
+ * ) => void;
+ * ```
+ *
  * A SliceRowIdsListener is provided when using the addSliceRowIdsListener
  * method. See that method for specific examples.
  *
@@ -117,8 +155,8 @@ export type SliceIdsListener = (indexes: Indexes, indexId: Id) => void;
  * @param sliceId The Id of the Slice that changed.
  * @category Listener
  */
-export type SliceRowIdsListener = (
-  indexes: Indexes,
+export type SliceRowIdsListener<Schemas extends OptionalSchemas> = (
+  indexes: Indexes<Schemas>,
   indexId: Id,
   sliceId: Id,
 ) => void;
@@ -201,10 +239,23 @@ export type IndexesListenerStats = {
  * @see Word Frequencies demo
  * @category Indexes
  */
-export interface Indexes<Schemas extends OptionalSchemas = NoSchemas> {
+export interface Indexes<in out Schemas extends OptionalSchemas> {
   /**
    * The setIndexDefinition method lets you set the definition of an Index.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * setIndexDefinition(
+   *   indexId: Id,
+   *   tableId: Id,
+   *   getSliceIdOrIds?: Id | ((getCell: GetCell, rowId: Id) => Id | Ids),
+   *   getSortKey?: Id | ((getCell: GetCell, rowId: Id) => SortKey),
+   *   sliceIdSorter?: (sliceId1: Id, sliceId2: Id) => number,
+   *   rowIdSorter?: (sortKey1: SortKey, sortKey2: SortKey, sliceId: Id) => number,
+   * ): Indexes;
+   * ```
+   *
    * Every Index definition is identified by a unique Id, and if you re-use an
    * existing Id with this method, the previous definition is overwritten.
    *
@@ -354,11 +405,15 @@ export interface Indexes<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Configuration
    */
-  setIndexDefinition(
+  setIndexDefinition<TableId extends TableIdFromSchema<Schemas[0]>>(
     indexId: Id,
-    tableId: Id,
-    getSliceIdOrIds?: Id | ((getCell: GetCell, rowId: Id) => Id | Ids),
-    getSortKey?: Id | ((getCell: GetCell, rowId: Id) => SortKey),
+    tableId: TableId,
+    getSliceIdOrIds?:
+      | CellIdFromSchema<Schemas[0], TableId>
+      | ((getCell: GetCell<Schemas[0], TableId>, rowId: Id) => Id | Ids),
+    getSortKey?:
+      | CellIdFromSchema<Schemas[0], TableId>
+      | ((getCell: GetCell<Schemas[0], TableId>, rowId: Id) => SortKey),
     sliceIdSorter?: (sliceId1: Id, sliceId2: Id) => number,
     rowIdSorter?: (sortKey1: SortKey, sortKey2: SortKey, sliceId: Id) => number,
   ): Indexes<Schemas>;
@@ -366,6 +421,12 @@ export interface Indexes<Schemas extends OptionalSchemas = NoSchemas> {
   /**
    * The delIndexDefinition method removes an existing Index definition.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * delIndexDefinition(indexId: Id): Indexes;
+   * ```
+   *
    * @param indexId The Id of the Index to remove.
    * @returns A reference to the Indexes object.
    * @example
@@ -396,6 +457,12 @@ export interface Indexes<Schemas extends OptionalSchemas = NoSchemas> {
    * The getStore method returns a reference to the underlying Store that is
    * backing this Indexes object.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getStore(): Store;
+   * ```
+   *
    * @returns A reference to the Store.
    * @example
    * This example creates an Indexes object against a newly-created Store and
@@ -437,6 +504,12 @@ export interface Indexes<Schemas extends OptionalSchemas = NoSchemas> {
    * The forEachIndex method takes a function that it will then call for each
    * Index in a specified Indexes object.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * forEachIndex(indexCallback: IndexCallback): void;
+   * ```
+   *
    * This method is useful for iterating over the structure of the Indexes
    * object in a functional style. The `indexCallback` parameter is a
    * IndexCallback function that will be called with the Id of each Index, and
@@ -471,12 +544,18 @@ export interface Indexes<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Iterator
    */
-  forEachIndex(indexCallback: IndexCallback): void;
+  forEachIndex(indexCallback: IndexCallback<Schemas[0]>): void;
 
   /**
    * The forEachSlice method takes a function that it will then call for each
    * Slice in a specified Index.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * forEachSlice(indexId: Id, sliceCallback: SliceCallback): void;
+   * ```
+   *
    * This method is useful for iterating over the Slice structure of the Index
    * in a functional style. The `rowCallback` parameter is a RowCallback
    * function that will be called with the Id and value of each Row in the
@@ -508,7 +587,7 @@ export interface Indexes<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Iterator
    */
-  forEachSlice(indexId: Id, sliceCallback: SliceCallback): void;
+  forEachSlice(indexId: Id, sliceCallback: SliceCallback<Schemas[0]>): void;
 
   /**
    * The hasIndex method returns a boolean indicating whether a given Index
@@ -562,6 +641,12 @@ export interface Indexes<Schemas extends OptionalSchemas = NoSchemas> {
    * The getTableId method returns the Id of the underlying Table that is
    * backing an Index.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getTableId(indexId: Id): Id | undefined;
+   * ```
+   *
    * If the Index Id is invalid, the method returns `undefined`.
    *
    * @param indexId The Id of an Index.
@@ -581,7 +666,9 @@ export interface Indexes<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Getter
    */
-  getTableId(indexId: Id): Id;
+  getTableId<TableId extends TableIdFromSchema<Schemas[0]>>(
+    indexId: Id,
+  ): TableId | undefined;
 
   /**
    * The getSliceIds method gets the list of Slice Ids in an Index.
@@ -656,6 +743,12 @@ export interface Indexes<Schemas extends OptionalSchemas = NoSchemas> {
    * 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
+   * addSliceIdsListener(indexId: IdOrNull, listener: SliceIdsListener): Id;
+   * ```
+   *
    * You can either listen to a single Index (by specifying the Index Id as the
    * method's first parameter), or changes to any Index (by providing a `null`
    * wildcard).
@@ -729,12 +822,25 @@ export interface Indexes<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Listener
    */
-  addSliceIdsListener(indexId: IdOrNull, listener: SliceIdsListener): Id;
+  addSliceIdsListener(
+    indexId: IdOrNull,
+    listener: SliceIdsListener<Schemas>,
+  ): Id;
 
   /**
    * The addSliceRowIdsListener method 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
+   * addSliceRowIdsListener(
+   *   indexId: IdOrNull,
+   *   sliceId: IdOrNull,
+   *   listener: SliceRowIdsListener,
+   * ): Id;
+   * ```
+   *
    * You can either listen to a single Slice (by specifying the Index Id and
    * Slice Id as the method's first two parameters), or changes to any Slice (by
    * providing `null` wildcards).
@@ -821,13 +927,19 @@ export interface Indexes<Schemas extends OptionalSchemas = NoSchemas> {
   addSliceRowIdsListener(
     indexId: IdOrNull,
     sliceId: IdOrNull,
-    listener: SliceRowIdsListener,
+    listener: SliceRowIdsListener<Schemas>,
   ): Id;
 
   /**
    * The delListener method removes a listener that was previously added to the
    * Indexes object.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * delListener(listenerId: Id): Indexes;
+   * ```
+   *
    * Use the Id returned by whichever method was used to add the listener. Note
    * that the Indexes object may re-use this Id for future listeners added to
    * it.
@@ -941,6 +1053,12 @@ export interface Indexes<Schemas extends OptionalSchemas = NoSchemas> {
  * The createIndexes function creates an Indexes object, and is the main entry
  * point into the indexes module.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * createIndexes(store: Store): Indexes;
+ * ```
+ *
  * A given Store can only have one Indexes object associated with it. If you
  * call this function twice on the same Store, your second call will return a
  * reference to the Indexes object created by the first.

package/lib/types/with-schemas/internal/queries.d.ts

@@ -0,0 +1,15 @@
+import {CellIdFromSchema, TableIdFromSchema} from './store';
+import {NoTablesSchema, OptionalTablesSchema} from '../store';
+import {Id} from '../common';
+import {ResultCell} from '../queries';
+
+export type JoinedCellIdOrId<
+  Schema extends OptionalTablesSchema = NoTablesSchema,
+  JoinedTableId extends TableIdFromSchema<Schema> | Id =
+    | TableIdFromSchema<Schema>
+    | Id,
+> = JoinedTableId extends TableIdFromSchema<Schema>
+  ? CellIdFromSchema<Schema, JoinedTableId>
+  : Id;
+
+export type GetResultCell = (cellId: Id) => ResultCell;