tinybase 3.1.0-beta.4 → 3.1.0

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

@@ -11,6 +11,17 @@
  * @module store
  */
 
+import {
+  AllCellIdFromSchema,
+  CellIdFromSchema,
+  DefaultCellIdFromSchema,
+  DefaultValueIdFromSchema,
+  DefaultedCellFromSchema,
+  DefaultedValueFromSchema,
+  TableIdFromSchema,
+  Truncate,
+  ValueIdFromSchema,
+} from './internal/store';
 import {Id, IdOrNull, Ids, Json} from './common.d';
 
 /**
@@ -26,7 +37,7 @@ import {Id, IdOrNull, Ids, Json} from './common.d';
  * `pets`, in which each Row may contain a string `species` Cell, and is
  * guaranteed to contain a boolean `sold` Cell that defaults to `false`.
  *
- *```js
+ * ```js
  * const tableSchema: TablesSchema = {
  *   pets: {
  *     species: {type: 'string'},
@@ -57,7 +68,7 @@ export type TablesSchema = {[tableId: Id]: {[cellId: Id]: CellSchema}};
  * When applied to a Store, this CellSchema ensures a boolean Cell is always
  * present, and defaults it to `false`.
  *
- *```js
+ * ```js
  * const requiredBoolean: CellSchema = {type: 'boolean', default: false};
  * ```
  * @category Schema
@@ -78,7 +89,7 @@ export type CellSchema =
  * When applied to a Store, this ValuesSchema only allows one boolean Value
  * called `open`, that defaults to `false`.
  *
- *```js
+ * ```js
  * const valuesSchema: ValuesSchema = {
  *   open: {type: 'boolean', default: false},
  * };
@@ -107,7 +118,7 @@ export type ValuesSchema = {[valueId: Id]: ValueSchema};
  * When applied to a Store, this ValueSchema ensures a boolean Value is always
  * present, and defaults it to `false`.
  *
- *```js
+ * ```js
  * const requiredBoolean: ValueSchema = {type: 'boolean', default: false};
  * ```
  * @category Schema
@@ -122,10 +133,7 @@ export type ValueSchema =
  * The NoTablesSchema type is a TablesSchema-like type for when one has not been
  * provided.
  *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
+ * @category Schema
  */
 export type NoTablesSchema = {[tableId: Id]: {[cellId: Id]: {type: 'any'}}};
 
@@ -133,10 +141,7 @@ export type NoTablesSchema = {[tableId: Id]: {[cellId: Id]: {type: 'any'}}};
  * The NoValuesSchema type is a ValuesSchema-like type for when one has not been
  * provided.
  *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
+ * @category Schema
  */
 export type NoValuesSchema = {[valueId: Id]: {type: 'any'}};
 
@@ -176,8 +181,10 @@ export type NoSchemas = [NoTablesSchema, NoValuesSchema];
  * The Tables type is the data structure representing all of the data in a
  * Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
  * ```ts override
- * {[tableId: Id]: Table}
+ * {[tableId: Id]: Table};
  * ```
  *
  * A Tables object is used when setting all of the tables together with the
@@ -201,15 +208,23 @@ export type NoSchemas = [NoTablesSchema, NoValuesSchema];
  * @category Store
  */
 export type Tables<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
+  Schema extends OptionalTablesSchema,
   WhenSet extends boolean = false,
-> = TablesFromSchema<Schema, WhenSet>;
+> = {
+  -readonly [TableId in TableIdFromSchema<Schema>]?: Table<
+    Schema,
+    TableId,
+    WhenSet
+  >;
+};
 
 /**
  * The Table type is the data structure representing the data in a single table.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
  * ```ts override
- * {[rowId: Id]: Row}
+ * {[rowId: Id]: Row};
  * ```
  *
  * A Table is used when setting a table with the setTable method, and when
@@ -227,16 +242,18 @@ export type Tables<
  * @category Store
  */
 export type Table<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
+  Schema extends OptionalTablesSchema,
+  TableId extends TableIdFromSchema<Schema>,
   WhenSet extends boolean = false,
-> = TableFromSchema<Schema, TableId, WhenSet>;
+> = {[rowId: Id]: Row<Schema, TableId, WhenSet>};
 
 /**
  * The Row type is the data structure representing the data in a single row.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
  * ```ts override
- * {[cellId: Id]: Cell}
+ * {[cellId: Id]: Cell};
  * ```
  *
  * A Row is used when setting a row with the setRow method, and when getting it
@@ -250,16 +267,38 @@ export type Table<
  * @category Store
  */
 export type Row<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
+  Schema extends OptionalTablesSchema,
+  TableId extends TableIdFromSchema<Schema>,
   WhenSet extends boolean = false,
-> = RowFromSchema<Schema, TableId, WhenSet>;
+> = (WhenSet extends true
+  ? {
+      -readonly [CellId in DefaultCellIdFromSchema<Schema, TableId>]?: Cell<
+        Schema,
+        TableId,
+        CellId
+      >;
+    }
+  : {
+      -readonly [CellId in DefaultCellIdFromSchema<Schema, TableId>]: Cell<
+        Schema,
+        TableId,
+        CellId
+      >;
+    }) & {
+  -readonly [CellId in DefaultCellIdFromSchema<Schema, TableId, false>]?: Cell<
+    Schema,
+    TableId,
+    CellId
+  >;
+};
 
 /**
  * The Cell type is the data structure representing the data in a single cell.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
  * ```ts override
- * string | number | boolean
+ * string | number | boolean;
  * ```
  *
  * A Cell is used when setting a cell with the setCell method, and when getting
@@ -273,18 +312,28 @@ export type Row<
  * @category Store
  */
 export type Cell<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
-  CellId extends CellIdFromSchema<Schema, TableId> = CellIdFromSchema<
-    Schema,
-    TableId
-  >,
-> = CellFromSchema<Schema, TableId, CellId>;
+  Schema extends OptionalTablesSchema,
+  TableId extends TableIdFromSchema<Schema>,
+  CellId extends CellIdFromSchema<Schema, TableId>,
+  CellType = Schema[TableId][CellId]['type'],
+> = CellType extends 'string'
+  ? string
+  : CellType extends 'number'
+  ? number
+  : CellType extends 'boolean'
+  ? boolean
+  : string | number | boolean;
 
 /**
  * The CellOrUndefined type is a data structure representing the data in a
  * single cell, or the value `undefined`.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * Cell | undefined;
+ * ```
+ *
  * This is used when describing a Cell that is present _or_ that is not present,
  * such as when it has been deleted, or when describing a previous state where
  * the Cell value has since been added.
@@ -292,21 +341,19 @@ export type Cell<
  * @category Store
  */
 export type CellOrUndefined<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
-  CellId extends CellIdFromSchema<Schema, TableId> = CellIdFromSchema<
-    Schema,
-    TableId
-  >,
-  Cell = CellFromSchema<Schema, TableId, CellId>,
-> = Cell | undefined;
+  Schema extends OptionalTablesSchema,
+  TableId extends TableIdFromSchema<Schema>,
+  CellId extends CellIdFromSchema<Schema, TableId>,
+> = Cell<Schema, TableId, CellId> | undefined;
 
 /**
  * The Values type is the data structure representing all the keyed values in a
  * Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
  * ```ts override
- * {[valueId: Id]: Value}
+ * {[valueId: Id]: Value};
  * ```
  *
  * A Values object is used when setting values with the setValues method, and
@@ -322,16 +369,35 @@ export type CellOrUndefined<
  * @since v3.0.0
  */
 export type Values<
-  Schema extends OptionalValuesSchema = NoValuesSchema,
+  Schema extends OptionalValuesSchema,
   WhenSet extends boolean = false,
-> = ValuesFromSchema<Schema, WhenSet>;
+> = (WhenSet extends true
+  ? {
+      -readonly [ValueId in DefaultValueIdFromSchema<Schema>]?: Value<
+        Schema,
+        ValueId
+      >;
+    }
+  : {
+      -readonly [ValueId in DefaultValueIdFromSchema<Schema>]: Value<
+        Schema,
+        ValueId
+      >;
+    }) & {
+  -readonly [ValueId in DefaultValueIdFromSchema<Schema, false>]?: Value<
+    Schema,
+    ValueId
+  >;
+};
 
 /**
  * The Value type is the data structure representing the data in a single keyed
  * value.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
  * ```ts override
- * string | number | boolean
+ * string | number | boolean;
  * ```
  *
  * A Value is used when setting a value with the setValue method, and when
@@ -346,14 +412,27 @@ export type Values<
  * @since v3.0.0
  */
 export type Value<
-  Schema extends OptionalValuesSchema = NoValuesSchema,
-  ValueId extends ValueIdFromSchema<Schema> = ValueIdFromSchema<Schema>,
-> = ValueFromSchema<Schema, ValueId>;
+  Schema extends OptionalValuesSchema,
+  ValueId extends ValueIdFromSchema<Schema>,
+  ValueType = Schema[ValueId]['type'],
+> = ValueType extends 'string'
+  ? string
+  : ValueType extends 'number'
+  ? number
+  : ValueType extends 'boolean'
+  ? boolean
+  : string | number | boolean;
 
 /**
  * The ValueOrUndefined type is a data structure representing the data in a
  * single value, or the value `undefined`.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * Value | undefined;
+ * ```
+ *
  * This is used when describing a Value that is present _or_ that is not
  * present, such as when it has been deleted, or when describing a previous
  * state where the Value has since been added.
@@ -362,15 +441,23 @@ export type Value<
  * @since v3.0.0
  */
 export type ValueOrUndefined<
-  Schema extends OptionalValuesSchema = NoValuesSchema,
-  ValueId extends ValueIdFromSchema<Schema> = ValueIdFromSchema<Schema>,
-  Value = ValueFromSchema<Schema, ValueId>,
-> = Value | undefined;
+  Schema extends OptionalValuesSchema,
+  ValueId extends ValueIdFromSchema<Schema>,
+> = Value<Schema, ValueId> | undefined;
 
 /**
  * The TableCallback type describes a function that takes a Table'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
+ * (
+ *   tableId: Id,
+ *   forEachRow: (rowCallback: RowCallback) => void,
+ * ) => void;
+ * ```
+ *
  * A TableCallback is provided when using the forEachTable method, so that you
  * can do something based on every Table in the Store. See that method for
  * specific examples.
@@ -381,17 +468,32 @@ export type ValueOrUndefined<
  * @category Callback
  */
 export type TableCallback<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
-> = (
-  tableId: TableId,
-  forEachRow: (rowCallback: RowCallback<Schema, TableId>) => void,
-) => void;
+  Schema extends OptionalTablesSchema,
+  Params extends any[] = TableIdFromSchema<Schema> extends infer TableId
+    ? TableId extends TableIdFromSchema<Schema>
+      ? [
+          tableId: TableId,
+          forEachRow: (rowCallback: RowCallback<Schema, TableId>) => void,
+        ]
+      : never
+    : never,
+  Params2 extends any[] = Params | [tableId: never, forEachRow: never],
+  Params1 extends any[] = Truncate<Params2>,
+> = ((...params: Params2) => void) | ((...params: Params1) => void);
 
 /**
  * The RowCallback type describes a function that takes a Row's Id and a
  * callback to loop over each Cell within it.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   rowId: Id,
+ *   forEachCell: (cellCallback: CellCallback) => void,
+ * ) => void;
+ * ```
+ *
  * A RowCallback is provided when using the forEachRow method, so that you can
  * do something based on every Row in a Table. See that method for specific
  * examples.
@@ -402,17 +504,27 @@ export type TableCallback<
  * @category Callback
  */
 export type RowCallback<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
-> = (
-  rowId: Id,
-  forEachCell: (cellCallback: CellCallback<Schema, TableId>) => void,
-) => void;
+  Schema extends OptionalTablesSchema,
+  TableIdOrNull extends TableIdFromSchema<Schema> | null = null,
+  Params extends any[] = [
+    rowId: Id,
+    forEachCell: (cellCallback: CellCallback<Schema, TableIdOrNull>) => void,
+  ],
+  Params2 extends any[] = Params | [rowId: never, forEachCell: never],
+  // Params1 extends any[] = Truncate<Params2>,
+> = Params extends any[] ? (...params: Params2) => void : never;
+// | ((...params: Params1) => void)
 
 /**
  * The CellCallback type describes a function that takes a Cell's Id and its
  * value.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (cellId: Id, cell: Cell) => void;
+ * ```
+ *
  * A CellCallback is provided when using the forEachCell method, so that you can
  * do something based on every Cell in a Row. See that method for specific
  * examples.
@@ -422,18 +534,35 @@ export type RowCallback<
  * @category Callback
  */
 export type CellCallback<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
-  CellId extends CellIdFromSchema<Schema, TableId> = CellIdFromSchema<
-    Schema,
-    TableId
-  >,
-> = (cellId: CellId, cell: Cell<Schema, TableId, CellId>) => void;
+  Schema extends OptionalTablesSchema,
+  TableIdOrNull extends TableIdFromSchema<Schema> | null = null,
+  Params extends any[] = (
+    TableIdOrNull extends null ? TableIdFromSchema<Schema> : TableIdOrNull
+  ) extends infer TableId
+    ? TableId extends TableIdFromSchema<Schema>
+      ? CellIdFromSchema<Schema, TableId> extends infer CellId
+        ? CellId extends CellIdFromSchema<Schema, TableId>
+          ? [cellId: CellId, cell: Cell<Schema, TableId, CellId>]
+          : never
+        : never
+      : never
+    : never,
+  Params2 extends any[] = Params | [cellId: never, cell: never],
+  Params1 extends any[] = Truncate<Params2>,
+> = Params extends any[]
+  ? ((...params: Params2) => void) | ((...params: Params1) => void)
+  : never;
 
 /**
  * The ValueCallback type describes a function that takes a Value's Id and its
  * actual value.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (valueId: Id, value: Value) => void;
+ * ```
+ *
  * A ValueCallback is provided when using the forEachValue method, so that you
  * can do something based on every Value in a Store. See that method for
  * specific examples.
@@ -444,14 +573,30 @@ export type CellCallback<
  * @since v3.0.0
  */
 export type ValueCallback<
-  Schema extends OptionalValuesSchema = NoValuesSchema,
-  ValueId extends ValueIdFromSchema<Schema> = ValueIdFromSchema<Schema>,
-> = (valueId: ValueId, value: Value<Schema, ValueId>) => void;
+  Schema extends OptionalValuesSchema,
+  Params extends any[] = ValueIdFromSchema<Schema> extends infer ValueId
+    ? ValueId extends ValueIdFromSchema<Schema>
+      ?
+          | [valueId: ValueId, value: Value<Schema, ValueId>]
+          | [valueId: never, value: never]
+      : never
+    : never,
+  Params2 extends any[] = Params | [valueId: never, value: never],
+  Params1 extends any[] = Truncate<Params2>,
+> = Params extends any[]
+  ? ((...params: Params2) => void) | ((...params: Params1) => void)
+  : never;
 
 /**
  * The MapCell type describes a function that takes an existing Cell value and
  * returns another.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (cell: CellOrUndefined) => Cell;
+ * ```
+ *
  * A MapCell can be provided in the setCell method to map an existing value to a
  * new one, such as when incrementing a number. See that method for specific
  * examples.
@@ -460,12 +605,9 @@ export type ValueCallback<
  * @category Callback
  */
 export type MapCell<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
-  CellId extends CellIdFromSchema<Schema, TableId> = CellIdFromSchema<
-    Schema,
-    TableId
-  >,
+  Schema extends OptionalTablesSchema,
+  TableId extends TableIdFromSchema<Schema>,
+  CellId extends CellIdFromSchema<Schema, TableId>,
 > = (
   cell: CellOrUndefined<Schema, TableId, CellId>,
 ) => Cell<Schema, TableId, CellId>;
@@ -474,6 +616,12 @@ export type MapCell<
  * The MapValue type describes a function that takes an existing Value and
  * returns another.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (value: ValueOrUndefined) => Value;
+ * ```
+ *
  * A MapValue can be provided in the setValue method to map an existing Value to
  * a new one, such as when incrementing a number. See that method for specific
  * examples.
@@ -483,7 +631,7 @@ export type MapCell<
  * @since v3.0.0
  */
 export type MapValue<
-  Schema extends OptionalValuesSchema = NoValuesSchema,
+  Schema extends OptionalValuesSchema,
   ValueId extends ValueIdFromSchema<Schema> = ValueIdFromSchema<Schema>,
 > = (value: ValueOrUndefined<Schema, ValueId>) => Value<Schema, ValueId>;
 
@@ -491,6 +639,12 @@ export type MapValue<
  * The GetCell type describes a function that takes a Id and returns the Cell
  * value for a particular Row.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (cellId: Id) => CellOrUndefined;
+ * ```
+ *
  * A GetCell can be provided when setting definitions, as in the
  * setMetricDefinition method of a Metrics object, or the setIndexDefinition
  * method of an Indexes object. See those methods for specific examples.
@@ -499,18 +653,27 @@ export type MapValue<
  * @category Callback
  */
 export type GetCell<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
-  CellId extends CellIdFromSchema<Schema, TableId> = CellIdFromSchema<
-    Schema,
-    TableId
-  >,
-> = (cellId: CellId) => CellOrUndefined<Schema, TableId, CellId>;
+  Schema extends OptionalTablesSchema,
+  TableId extends TableIdFromSchema<Schema>,
+> = <CellId extends CellIdFromSchema<Schema, TableId>>(
+  cellId: CellId,
+) => DefaultedCellFromSchema<Schema, TableId, CellId>;
 
 /**
  * The DoRollback type describes a function that you can use to rollback the
  * transaction if it did not complete to your satisfaction.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   changedCells: ChangedCells,
+ *   invalidCells: InvalidCells,
+ *   changedValues: ChangedValues,
+ *   invalidValues: InvalidValues,
+ * ) => boolean;
+ * ```
+ *
  * A DoRollback can be provided when calling the transaction method or the
  * finishTransaction method. See those methods for specific examples.
  *
@@ -526,14 +689,10 @@ export type GetCell<
  * @param invalidValues Any invalid attempts to change Values, since v3.0.0.
  * @category Callback
  */
-export type DoRollback<
-  Schemas extends OptionalSchemas = NoSchemas,
-  TablesSchema extends OptionalTablesSchema = Schemas[0],
-  ValuesSchema extends OptionalValuesSchema = Schemas[1],
-> = (
-  changedCells: ChangedCells<TablesSchema>,
+export type DoRollback<Schemas extends OptionalSchemas> = (
+  changedCells: ChangedCells<Schemas[0]>,
   invalidCells: InvalidCells,
-  changedValues: ChangedValues<ValuesSchema>,
+  changedValues: ChangedValues<Schemas[1]>,
   invalidValues: InvalidValues,
 ) => boolean;
 
@@ -541,6 +700,16 @@ export type DoRollback<
  * The TransactionListener type describes a function that is used to listen to
  * the completion of a transaction for the Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   store: Store,
+ *   cellsTouched: boolean,
+ *   valuesTouched: boolean,
+ * ) => void;
+ * ```
+ *
  * A TransactionListener is provided when using the
  * addWillFinishTransactionListener and addDidFinishTransactionListener methods.
  * See those methods for specific examples.
@@ -563,7 +732,7 @@ export type DoRollback<
  * since v3.0.0.
  * @category Listener
  */
-export type TransactionListener<Schemas extends OptionalSchemas = NoSchemas> = (
+export type TransactionListener<Schemas extends OptionalSchemas> = (
   store: Store<Schemas>,
   cellsTouched: boolean,
   valuesTouched: boolean,
@@ -573,6 +742,15 @@ export type TransactionListener<Schemas extends OptionalSchemas = NoSchemas> = (
  * The TablesListener type describes a function that is used to listen to
  * changes to the whole Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   store: Store,
+ *   getCellChange: GetCellChange | undefined,
+ * ) => void;
+ * ```
+ *
  * A TablesListener is provided when using the addTablesListener method. See
  * that method for specific examples.
  *
@@ -589,18 +767,21 @@ export type TransactionListener<Schemas extends OptionalSchemas = NoSchemas> = (
  * changes.
  * @category Listener
  */
-export type TablesListener<
-  Schemas extends OptionalSchemas = NoSchemas,
-  TablesSchema extends OptionalTablesSchema = Schemas[0],
-> = (
+export type TablesListener<Schemas extends OptionalSchemas> = (
   store: Store<Schemas>,
-  getCellChange: GetCellChange<TablesSchema> | undefined,
+  getCellChange: GetCellChange<Schemas[0]> | undefined,
 ) => void;
 
 /**
  * The TableIdsListener type describes a function that is used to listen to
  * changes to the Table Ids in the Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (store: Store) => void;
+ * ```
+ *
  * A TableIdsListener is provided when using the addTableIdsListener method. See
  * that method for specific examples.
  *
@@ -609,7 +790,7 @@ export type TablesListener<
  * @param store A reference to the Store that changed.
  * @category Listener
  */
-export type TableIdsListener<Schemas extends OptionalSchemas = NoSchemas> = (
+export type TableIdsListener<Schemas extends OptionalSchemas> = (
   store: Store<Schemas>,
 ) => void;
 
@@ -617,6 +798,16 @@ export type TableIdsListener<Schemas extends OptionalSchemas = NoSchemas> = (
  * The TableListener type describes a function that is used to listen to changes
  * to a Table.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   store: Store,
+ *   tableId: Id,
+ *   getCellChange: GetCellChange | undefined,
+ * ) => void;
+ * ```
+ *
  * A TableListener is provided when using the addTableListener method. See that
  * method for specific examples.
  *
@@ -635,24 +826,26 @@ export type TableIdsListener<Schemas extends OptionalSchemas = NoSchemas> = (
  * @category Listener
  */
 export type TableListener<
-  Schemas extends OptionalSchemas = NoSchemas,
-  TableIdOrNull extends TableIdFromSchema<
-    Schemas[0]
-  > | null = TableIdFromSchema<Schemas[0]> | null,
-  TableId = TableIdOrNull extends null
-    ? TableIdFromSchema<Schemas[0]>
-    : TableIdOrNull,
-  TablesSchema extends OptionalTablesSchema = Schemas[0],
+  Schemas extends OptionalSchemas,
+  TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
 > = (
   store: Store<Schemas>,
-  tableId: TableId,
-  getCellChange: GetCellChange<TablesSchema> | undefined,
+  tableId: TableIdOrNull extends null
+    ? TableIdFromSchema<Schemas[0]>
+    : TableIdOrNull,
+  getCellChange: GetCellChange<Schemas[0]> | undefined,
 ) => void;
 
 /**
  * The RowIdsListener type describes a function that is used to listen to
  * changes to the Row Ids in a Table.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (store: Store, tableId: Id) => void;
+ * ```
+ *
  * A RowIdsListener is provided when using the addRowIdsListener method. See
  * that method for specific examples.
  *
@@ -664,19 +857,33 @@ export type TableListener<
  * @category Listener
  */
 export type RowIdsListener<
-  Schemas extends OptionalSchemas = NoSchemas,
-  TableIdOrNull extends TableIdFromSchema<
-    Schemas[0]
-  > | null = TableIdFromSchema<Schemas[0]> | null,
-  TableId = TableIdOrNull extends null
+  Schemas extends OptionalSchemas,
+  TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+> = (
+  store: Store<Schemas>,
+  tableId: TableIdOrNull extends null
     ? TableIdFromSchema<Schemas[0]>
     : TableIdOrNull,
-> = (store: Store<Schemas>, tableId: TableId) => void;
+) => void;
 
 /**
  * The SortedRowIdsListener type describes a function that is used to listen to
  * changes to sorted Row Ids in a Table.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   store: Store,
+ *   tableId: Id,
+ *   cellId: Id | undefined,
+ *   descending: boolean,
+ *   offset: number,
+ *   limit: number | undefined,
+ *   sortedRowIds: Ids,
+ * ) => void;
+ * ```
+ *
  * A SortedRowIdsListener is provided when using the addSortedRowIdsListener
  * method. See that method for specific examples.
  *
@@ -698,14 +905,12 @@ export type RowIdsListener<
  * @since v2.0.0
  */
 export type SortedRowIdsListener<
-  Schemas extends OptionalSchemas = NoSchemas,
-  TableId extends TableIdFromSchema<Schemas[0]> = TableIdFromSchema<Schemas[0]>,
-  CellId extends CellIdFromSchema<Schemas[0], TableId> | undefined =
-    | CellIdFromSchema<Schemas[0], TableId>
-    | undefined,
-  Descending extends boolean = boolean,
-  Offset extends number = number,
-  Limit extends number | undefined = number | undefined,
+  Schemas extends OptionalSchemas,
+  TableId extends TableIdFromSchema<Schemas[0]>,
+  CellId extends CellIdFromSchema<Schemas[0], TableId> | undefined,
+  Descending extends boolean,
+  Offset extends number,
+  Limit extends number | undefined,
 > = (
   store: Store<Schemas>,
   tableId: TableId,
@@ -720,6 +925,17 @@ export type SortedRowIdsListener<
  * The RowListener type describes a function that is used to listen to changes
  * to a Row.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   store: Store,
+ *   tableId: Id,
+ *   rowId: Id,
+ *   getCellChange: GetCellChange | undefined,
+ * ) => void;
+ * ```
+ *
  * A RowListener is provided when using the addRowListener method. See that
  * method for specific examples.
  *
@@ -740,27 +956,28 @@ export type SortedRowIdsListener<
  * @category Listener
  */
 export type RowListener<
-  Schemas extends OptionalSchemas = NoSchemas,
-  TableIdOrNull extends TableIdFromSchema<
-    Schemas[0]
-  > | null = TableIdFromSchema<Schemas[0]> | null,
-  RowIdOrNull extends IdOrNull = IdOrNull,
-  TableId = TableIdOrNull extends null
-    ? TableIdFromSchema<Schemas[0]>
-    : TableIdOrNull,
-  RowId = RowIdOrNull extends null ? Id : RowIdOrNull,
-  TablesSchema extends OptionalTablesSchema = Schemas[0],
+  Schemas extends OptionalSchemas,
+  TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+  RowIdOrNull extends IdOrNull,
 > = (
   store: Store<Schemas>,
-  tableId: TableId,
-  rowId: RowId,
-  getCellChange: GetCellChange<TablesSchema> | undefined,
+  tableId: TableIdOrNull extends null
+    ? TableIdFromSchema<Schemas[0]>
+    : TableIdOrNull,
+  rowId: RowIdOrNull extends null ? Id : RowIdOrNull,
+  getCellChange: GetCellChange<Schemas[0]> | undefined,
 ) => void;
 
 /**
  * The CellIdsListener type describes a function that is used to listen to
  * changes to the Cell Ids in a Row.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (store: Store, tableId: Id, rowId: Id) => void;
+ * ```
+ *
  * A CellIdsListener is provided when using the addCellIdsListener method. See
  * that method for specific examples.
  *
@@ -773,21 +990,35 @@ export type RowListener<
  * @category Listener
  */
 export type CellIdsListener<
-  Schemas extends OptionalSchemas = NoSchemas,
-  TableIdOrNull extends TableIdFromSchema<
-    Schemas[0]
-  > | null = TableIdFromSchema<Schemas[0]> | null,
-  RowIdOrNull extends IdOrNull = null,
-  TableId = TableIdOrNull extends null
+  Schemas extends OptionalSchemas,
+  TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+  RowIdOrNull extends IdOrNull,
+> = (
+  store: Store<Schemas>,
+  tableId: TableIdOrNull extends null
     ? TableIdFromSchema<Schemas[0]>
     : TableIdOrNull,
-  RowId = RowIdOrNull extends null ? Id : RowIdOrNull,
-> = (store: Store<Schemas>, tableId: TableId, rowId: RowId) => void;
+  rowId: RowIdOrNull extends null ? Id : RowIdOrNull,
+) => void;
 
 /**
  * The CellListener type describes a function that is used to listen to changes
  * to a Cell.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   store: Store,
+ *   tableId: Id,
+ *   rowId: Id,
+ *   cellId: Id,
+ *   newCell: Cell,
+ *   oldCell: Cell,
+ *   getCellChange: GetCellChange | undefined,
+ * ) => void;
+ * ```
+ *
  * A CellListener is provided when using the addCellListener method. See that
  * method for specific examples.
  *
@@ -813,45 +1044,80 @@ export type CellIdsListener<
  * @category Listener
  */
 export type CellListener<
-  Schemas extends OptionalSchemas = NoSchemas,
-  TableIdOrNull extends TableIdFromSchema<
-    Schemas[0]
-  > | null = TableIdFromSchema<Schemas[0]> | null,
-  RowIdOrNull extends IdOrNull = IdOrNull,
+  Schemas extends OptionalSchemas,
+  TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+  RowIdOrNull extends IdOrNull,
   CellIdOrNull extends
-    | (TableIdOrNull extends TableIdFromSchema<Schemas[0]>
-        ? CellIdFromSchema<Schemas[0], TableIdOrNull>
-        : AllCellIdFromSchema<Schemas[0]>)
-    | null =
     | (TableIdOrNull extends TableIdFromSchema<Schemas[0]>
         ? CellIdFromSchema<Schemas[0], TableIdOrNull>
         : AllCellIdFromSchema<Schemas[0]>)
     | null,
-  TableId extends Id = TableIdOrNull extends null
-    ? TableIdFromSchema<Schemas[0]>
-    : TableIdOrNull,
-  RowId = RowIdOrNull extends null ? Id : RowIdOrNull,
-  CellId extends Id = CellIdOrNull extends null
-    ? TableIdOrNull extends TableIdFromSchema<Schemas[0]>
-      ? CellIdFromSchema<Schemas[0], TableIdOrNull>
-      : AllCellIdFromSchema<Schemas[0]>
-    : CellIdOrNull,
-  Cell = CellFromSchema<Schemas[0], TableId, CellId>,
-  TablesSchema extends OptionalTablesSchema = Schemas[0],
-> = (
-  store: Store<Schemas>,
-  tableId: TableId,
-  rowId: RowId,
-  cellId: CellId,
-  newCell: Cell,
-  oldCell: Cell,
-  getCellChange: GetCellChange<TablesSchema> | undefined,
-) => void;
+  Params extends any[] = (
+    TableIdOrNull extends null ? TableIdFromSchema<Schemas[0]> : TableIdOrNull
+  ) extends infer TableId
+    ? TableId extends TableIdFromSchema<Schemas[0]>
+      ? (
+          CellIdOrNull extends null
+            ? CellIdFromSchema<Schemas[0], TableId>
+            : CellIdOrNull
+        ) extends infer CellId
+        ? CellId extends CellIdFromSchema<Schemas[0], TableId>
+          ? [
+              store: Store<Schemas>,
+              tableId: TableId,
+              rowId: RowIdOrNull extends null ? Id : RowIdOrNull,
+              cellId: CellId,
+              newCell: Cell<Schemas[0], TableId, CellId>,
+              oldCell: Cell<Schemas[0], TableId, CellId>,
+              getCellChange: GetCellChange<Schemas[0]> | undefined,
+            ]
+          : never
+        : never
+      : never
+    : never,
+  Params7 extends any[] =
+    | Params
+    | [
+        store: never,
+        tableId: never,
+        rowId: never,
+        cellId: never,
+        newCell: never,
+        oldCell: never,
+        getCellChange: never,
+      ],
+  Params6 extends any[] = Truncate<Params7>,
+  Params5 extends any[] = Truncate<Params6>,
+  Params4 extends any[] = Truncate<Params5>,
+  // Params3 extends any[] = Truncate<Params4>,
+  // Params2 extends any[] = Truncate<Params3>,
+  // Params1 extends any[] = Truncate<Params2>,
+> = Params extends any
+  ?
+      | ((...params: Params7) => void)
+      | ((...params: Params6) => void)
+      | ((...params: Params5) => void)
+      | ((...params: Params4) => void)
+  : // The unions may no longer be discriminatory with fewer parameters, and
+    // TypeScript fails to resolve callback signatures in some cases.
+    // | ((...params: Params3) => void)
+    // | ((...params: Params2) => void)
+    // | ((...params: Params1) => void)
+    never;
 
 /**
  * The ValuesListener type describes a function that is used to listen to
  * changes to all the Values in a Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   store: Store,
+ *   getValueChange: GetValueChange | undefined,
+ * ) => void;
+ * ```
+ *
  * A ValuesListener is provided when using the addValuesListener method. See
  * that method for specific examples.
  *
@@ -868,18 +1134,21 @@ export type CellListener<
  * changes.
  * @category Listener
  */
-export type ValuesListener<
-  Schemas extends OptionalSchemas = NoSchemas,
-  ValuesSchema extends OptionalValuesSchema = Schemas[1],
-> = (
+export type ValuesListener<Schemas extends OptionalSchemas> = (
   store: Store<Schemas>,
-  getValueChange: GetValueChange<ValuesSchema> | undefined,
+  getValueChange: GetValueChange<Schemas[1]> | undefined,
 ) => void;
 
 /**
  * The ValueIdsListener type describes a function that is used to listen to
  * changes to the Value Ids in a Store.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (store: Store) => void;
+ * ```
+ *
  * A ValueIdsListener is provided when using the addValueIdsListener method. See
  * that method for specific examples.
  *
@@ -888,7 +1157,7 @@ export type ValuesListener<
  * @param store A reference to the Store that changed.
  * @category Listener
  */
-export type ValueIdsListener<Schemas extends OptionalSchemas = NoSchemas> = (
+export type ValueIdsListener<Schemas extends OptionalSchemas> = (
   store: Store<Schemas>,
 ) => void;
 
@@ -896,6 +1165,18 @@ export type ValueIdsListener<Schemas extends OptionalSchemas = NoSchemas> = (
  * The ValueListener type describes a function that is used to listen to changes
  * to a Value.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   store: Store,
+ *   valueId: Id,
+ *   newValue: Value,
+ *   oldValue: Value,
+ *   getValueChange: GetValueChange | undefined,
+ * ) => void;
+ * ```
+ *
  * A ValueListener is provided when using the addValueListener method. See that
  * method for specific examples.
  *
@@ -919,27 +1200,59 @@ export type ValueIdsListener<Schemas extends OptionalSchemas = NoSchemas> = (
  * @since v3.0.0
  */
 export type ValueListener<
-  Schemas extends OptionalSchemas = NoSchemas,
-  ValueIdOrNull extends ValueIdFromSchema<
-    Schemas[1]
-  > | null = ValueIdFromSchema<Schemas[1]> | null,
-  ValueId extends Id = ValueIdOrNull extends null
-    ? ValueIdFromSchema<Schemas[1]>
-    : ValueIdOrNull,
-  Value = ValueFromSchema<Schemas[1], ValueId>,
-  ValuesSchema extends OptionalValuesSchema = Schemas[1],
-> = (
-  store: Store<Schemas>,
-  valueId: ValueId,
-  newValue: Value,
-  oldValue: Value,
-  getValueChange: GetValueChange<ValuesSchema> | undefined,
-) => void;
+  Schemas extends OptionalSchemas,
+  ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null,
+  Params extends any[] = (
+    ValueIdOrNull extends null ? ValueIdFromSchema<Schemas[1]> : ValueIdOrNull
+  ) extends infer ValueId
+    ? ValueId extends ValueIdFromSchema<Schemas[1]>
+      ? [
+          store: Store<Schemas>,
+          valueId: ValueId,
+          newValue: Value<Schemas[1], ValueId>,
+          oldValue: Value<Schemas[1], ValueId>,
+          getValueChange: GetValueChange<Schemas[1]> | undefined,
+        ]
+      : never
+    : never,
+  Params5 extends any[] =
+    | Params
+    | [
+        store: never,
+        valueId: never,
+        newValue: never,
+        oldValue: never,
+        getValueChange: never,
+      ],
+  Params4 extends any[] = Truncate<Params5>,
+  Params3 extends any[] = Truncate<Params4>,
+  Params2 extends any[] = Truncate<Params3>,
+  //  Params1 extends any[] = Truncate<Params2>,
+> = Params extends any
+  ?
+      | ((...params: Params5) => void)
+      | ((...params: Params4) => void)
+      | ((...params: Params3) => void)
+      | ((...params: Params2) => void)
+  : // | ((...params: Params1) => void)
+    never;
 
 /**
  * The InvalidCellListener type describes a function that is used to listen to
  * attempts to set invalid data to a Cell.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   store: Store,
+ *   tableId: Id,
+ *   rowId: Id,
+ *   cellId: Id,
+ *   invalidCells: any[],
+ * ) => void;
+ * ```
+ *
  * A InvalidCellListener is provided when using the addInvalidCellListener
  * method. See that method for specific examples.
  *
@@ -958,7 +1271,7 @@ export type ValueListener<
  * @category Listener
  * @since v1.1.0
  */
-export type InvalidCellListener<Schemas extends OptionalSchemas = NoSchemas> = (
+export type InvalidCellListener<Schemas extends OptionalSchemas> = (
   store: Store<Schemas>,
   tableId: Id,
   rowId: Id,
@@ -970,6 +1283,16 @@ export type InvalidCellListener<Schemas extends OptionalSchemas = NoSchemas> = (
  * The InvalidValueListener type describes a function that is used to listen to
  * attempts to set invalid data to a Value.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   store: Store,
+ *   valueId: Id,
+ *   invalidValues: any[],
+ * ) => void;
+ * ```
+ *
  * A InvalidValueListener is provided when using the addInvalidValueListener
  * method. See that method for specific examples.
  *
@@ -986,13 +1309,22 @@ export type InvalidCellListener<Schemas extends OptionalSchemas = NoSchemas> = (
  * @category Listener
  * @since v3.0.0
  */
-export type InvalidValueListener<Schemas extends OptionalSchemas = NoSchemas> =
-  (store: Store<Schemas>, valueId: Id, invalidValues: any[]) => void;
+export type InvalidValueListener<Schemas extends OptionalSchemas> = (
+  store: Store<Schemas>,
+  valueId: Id,
+  invalidValues: any[],
+) => void;
 
 /**
  * The GetCellChange type describes a function that returns information about
  * any Cell's changes during a transaction.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (tableId: Id, rowId: Id, cellId: Id) => CellChange;
+ * ```
+ *
  * A GetCellChange function is provided to every listener when called due the
  * Store changing. The listener can then fetch the previous value of a Cell
  * before the current transaction, the new value after it, and a convenience
@@ -1004,9 +1336,7 @@ export type InvalidValueListener<Schemas extends OptionalSchemas = NoSchemas> =
  * @returns A CellChange array containing information about the Cell's changes.
  * @category Listener
  */
-export type GetCellChange<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-> = <
+export type GetCellChange<Schema extends OptionalTablesSchema> = <
   TableId extends TableIdFromSchema<Schema>,
   CellId extends CellIdFromSchema<Schema, TableId>,
 >(
@@ -1018,6 +1348,16 @@ export type GetCellChange<
 /**
  * The CellChange type describes a Cell's changes during a transaction.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * [
+ *   changed: boolean,
+ *   oldCell: CellOrUndefined,
+ *   newCell: CellOrUndefined,
+ * ];
+ * ```
+ *
  * This is returned by the GetCellChange function that is provided to every
  * listener when called. This array contains the previous value of a Cell before
  * the current transaction, the new value after it, and a convenience flag that
@@ -1026,12 +1366,9 @@ export type GetCellChange<
  * @category Listener
  */
 export type CellChange<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
-  CellId extends CellIdFromSchema<Schema, TableId> = CellIdFromSchema<
-    Schema,
-    TableId
-  >,
+  Schema extends OptionalTablesSchema,
+  TableId extends TableIdFromSchema<Schema>,
+  CellId extends CellIdFromSchema<Schema, TableId>,
   CellOrUndefined = Cell<Schema, TableId, CellId> | undefined,
 > = [changed: boolean, oldCell: CellOrUndefined, newCell: CellOrUndefined];
 
@@ -1039,6 +1376,12 @@ export type CellChange<
  * The GetValueChange type describes a function that returns information about
  * any Value's changes during a transaction.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (valueId: Id) => ValueChange;
+ * ```
+ *
  * A GetValueChange function is provided to every listener when called due the
  * Store changing. The listener can then fetch the previous value of a Value
  * before the current transaction, the new value after it, and a convenience
@@ -1049,15 +1392,25 @@ export type CellChange<
  * changes.
  * @category Listener
  */
-export type GetValueChange<
-  Schema extends OptionalValuesSchema = NoValuesSchema,
-> = <ValueId extends ValueIdFromSchema<Schema>>(
+export type GetValueChange<Schema extends OptionalValuesSchema> = <
+  ValueId extends ValueIdFromSchema<Schema>,
+>(
   valueId: ValueId,
 ) => ValueChange<Schema, ValueId>;
 
 /**
  * The ValueChange type describes a Value's changes during a transaction.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * [
+ *   changed: boolean,
+ *   oldValue: ValueOrUndefined,
+ *   newValue: ValueOrUndefined,
+ * ];
+ * ```
+ *
  * This is returned by the GetValueChange function that is provided to every
  * listener when called. This array contains the previous value of a Value
  * before the current transaction, the new value after it, and a convenience
@@ -1066,8 +1419,8 @@ export type GetValueChange<
  * @category Listener
  */
 export type ValueChange<
-  Schema extends OptionalValuesSchema = NoValuesSchema,
-  ValueId extends ValueIdFromSchema<Schema> = ValueIdFromSchema<Schema>,
+  Schema extends OptionalValuesSchema,
+  ValueId extends ValueIdFromSchema<Schema>,
   ValueOrUndefined = Value<Schema, ValueId> | undefined,
 > = [changed: boolean, oldValue: ValueOrUndefined, newValue: ValueOrUndefined];
 
@@ -1076,14 +1429,16 @@ export type ValueChange<
  * a transaction, primarily used so that you can indicate whether the
  * transaction should be rolled back.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
  * ```ts override
  * {
  *   [tableId: Id]: {
  *     [rowId: Id]: {
- *       [cellId: Id]: [CellOrUndefined, CellOrUndefined],
- *     },
- *   },
- * }
+ *       [cellId: Id]: [CellOrUndefined, CellOrUndefined];
+ *     };
+ *   };
+ * };
  * ```
  *
  * A ChangedCells object is provided to the `doRollback` callback when using the
@@ -1106,17 +1461,16 @@ export type ValueChange<
  * @category Transaction
  * @since v1.2.0
  */
-export type ChangedCells<Schema extends OptionalTablesSchema = NoTablesSchema> =
-  {
-    [TableId in TableIdFromSchema<Schema>]?: {
-      [rowId: Id]: {
-        [CellId in CellIdFromSchema<Schema, TableId>]?: [
-          CellOrUndefined<Schema, TableId, CellId>,
-          CellOrUndefined<Schema, TableId, CellId>,
-        ];
-      };
+export type ChangedCells<Schema extends OptionalTablesSchema> = {
+  [TableId in TableIdFromSchema<Schema>]?: {
+    [rowId: Id]: {
+      [CellId in CellIdFromSchema<Schema, TableId>]?: [
+        CellOrUndefined<Schema, TableId, CellId>,
+        CellOrUndefined<Schema, TableId, CellId>,
+      ];
     };
   };
+};
 
 /**
  * The InvalidCells type describes the invalid Cell values that have been
@@ -1148,8 +1502,12 @@ export type InvalidCells = {
  * transaction, primarily used so that you can indicate whether the transaction
  * should be rolled back.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
  * ```ts override
- * {[valueId: Id]: [ValueOrUndefined, ValueOrUndefined]}
+ * {
+ *   [valueId: Id]: [ValueOrUndefined, ValueOrUndefined];
+ * };
  * ```
  *
  * A ChangedValues object is provided to the `doRollback` callback when using
@@ -1171,14 +1529,13 @@ export type InvalidCells = {
  * @category Transaction
  * @since v3.0.0
  */
-export type ChangedValues<
-  Schema extends OptionalValuesSchema = NoValuesSchema,
-> = {
+export type ChangedValues<Schema extends OptionalValuesSchema> = {
   [ValueId in ValueIdFromSchema<Schema>]?: [
-    ValueOrUndefined<Schema, ValueId>,
-    ValueOrUndefined<Schema, ValueId>,
+    DefaultedValueFromSchema<Schema, ValueId>,
+    DefaultedValueFromSchema<Schema, ValueId>,
   ];
 };
+
 /**
  * The InvalidValues type describes the invalid Values that have been attempted
  * during a transaction, primarily used so that you can indicate whether the
@@ -1406,13 +1763,6 @@ export type StoreListenerStats = {
  * getSchemaJson method, and remove the schemas altogether with the
  * delValuesSchema method and delTablesSchema method.
  *
- * Throughout this API documentation, you will see the generic type parameter
- * `Schemas`, which refers to a pair of TablesSchema and ValuesSchema
- * respectively. These can be used on the Store interface to constrain its
- * methods, for example. This type parameter is defaulted if not provided, and
- * so if you are using a Store without schemas, you can ignore it and use the
- * Store type bare.
- *
  * Read more about schemas in the Using Schemas guide.
  *
  * # Convenience methods
@@ -1459,11 +1809,17 @@ export type StoreListenerStats = {
  * @see Todo App demos
  * @category Store
  */
-export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
+export interface Store<in out Schemas extends OptionalSchemas> {
   /**
    * The getTables method returns a Tables object containing the entire data of
    * the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getTables(): Tables;
+   * ```
+   *
    * Note that this returns a copy of, rather than a reference to the underlying
    * data, so changes made to the returned object are not made to the Store
    * itself.
@@ -1489,17 +1845,19 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * console.log(store.getTables());
    * // -> {}
    * ```
-   * @see
-   * # Guides
-   * Creating a Store
-   * @see Indexes
    * @category Getter
    */
-  getTables<Tables = TablesFromSchema<Schemas[0]>>(): Tables;
+  getTables(): Tables<Schemas[0]>;
 
   /**
    * The getTableIds method returns the Ids of every Table in the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getTableIds(): Ids;
+   * ```
+   *
    * Note that this returns a copy of, rather than a reference, to the list of
    * Ids, so changes made to the list are not made to the Store itself.
    *
@@ -1526,12 +1884,18 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Getter
    */
-  getTableIds<Ids = TableIdFromSchema<Schemas[0]>[]>(): Ids;
+  getTableIds(): TableIdFromSchema<Schemas[0]>[];
 
   /**
    * The getTable method returns an object containing the entire data of a
    * single Table in the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getTable(tableId: Id): Table;
+   * ```
+   *
    * Note that this returns a copy of, rather than a reference to the underlying
    * data, so changes made to the returned object are not made to the Store
    * itself.
@@ -1560,16 +1924,19 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Getter
    */
-  getTable<
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    Table = TableFromSchema<Schemas[0]>,
-  >(
+  getTable<TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: TableId,
-  ): Table;
+  ): Table<Schemas[0], TableId>;
 
   /**
    * The getRowIds method returns the Ids of every Row in a given Table.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getRowIds(tableId: Id): Ids;
+   * ```
+   *
    * Note that this returns a copy of, rather than a reference, to the list of
    * Ids, so changes made to the list are not made to the Store itself.
    *
@@ -1599,14 +1966,24 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Getter
    */
-  getRowIds<TableId extends TableIdFromSchema<Schemas[0]>>(
-    tableId: TableId,
-  ): Ids;
+  getRowIds(tableId: TableIdFromSchema<Schemas[0]>): Ids;
 
   /**
    * The getSortedRowIds method returns the Ids of every Row in a given Table,
    * sorted according to the values in a specified Cell.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getSortedRowIds(
+   *   tableId: Id,
+   *   cellId?: Id,
+   *   descending?: boolean,
+   *   offset?: number,
+   *   limit?: number,
+   * ): Ids;
+   * ```
+   *
    * The sorting of the rows is alphanumeric, and you can indicate whether it
    * should be in descending order. The `offset` and `limit` parameters are used
    * to paginate results, but default to `0` and `undefined` to return all
@@ -1702,12 +2079,9 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * @category Getter
    * @since v2.0.0
    */
-  getSortedRowIds<
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    CellId extends CellIdFromSchema<Schemas[0], TableId>,
-  >(
+  getSortedRowIds<TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: TableId,
-    cellId?: CellId,
+    cellId?: CellIdFromSchema<Schemas[0], TableId>,
     descending?: boolean,
     offset?: number,
     limit?: number,
@@ -1717,6 +2091,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The getRow method returns an object containing the entire data of a single
    * Row in a given Table.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getRow(tableId: Id, rowId: Id): Row;
+   * ```
+   *
    * Note that this returns a copy of, rather than a reference to the underlying
    * data, so changes made to the returned object are not made to the Store
    * itself.
@@ -1748,18 +2128,21 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Getter
    */
-  getRow<
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    Row = RowFromSchema<Schemas[0], TableId>,
-  >(
+  getRow<TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: TableId,
     rowId: Id,
-  ): Row;
+  ): Row<Schemas[0], TableId>;
 
   /**
    * The getCellIds method returns the Ids of every Cell in a given Row, in a
    * given Table.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getCellIds(tableId: Id, rowId: Id): Ids;
+   * ```
+   *
    * Note that this returns a copy of, rather than a reference, to the list of
    * Ids, so changes made to the list are not made to the Store itself.
    *
@@ -1789,18 +2172,21 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Getter
    */
-  getCellIds<
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    Ids extends CellIdFromSchema<Schemas[0], TableId>[],
-  >(
+  getCellIds<TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: TableId,
     rowId: Id,
-  ): Ids;
+  ): CellIdFromSchema<Schemas[0], TableId>[];
 
   /**
    * The getCell method returns the value of a single Cell in a given Row, in a
    * given Table.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getCell(tableId: Id, rowId: Id, cellId: Id): CellOrUndefined;
+   * ```
+   *
    * @param tableId The Id of the Table in the Store.
    * @param rowId The Id of the Row in the Table.
    * @param cellId The Id of the Cell in the Row.
@@ -1828,17 +2214,22 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
   getCell<
     TableId extends TableIdFromSchema<Schemas[0]>,
     CellId extends CellIdFromSchema<Schemas[0], TableId>,
-    CellOrUndefined = CellFromSchema<Schemas[0], TableId, CellId> | undefined,
   >(
     tableId: TableId,
     rowId: Id,
     cellId: CellId,
-  ): CellOrUndefined;
+  ): CellOrUndefined<Schemas[0], TableId, CellId>;
 
   /**
    * The getValues method returns an object containing the entire set of keyed
    * Values in the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getValues(): Values;
+   * ```
+   *
    * Note that this returns a copy of, rather than a reference to the underlying
    * data, so changes made to the returned object are not made to the Store
    * itself.
@@ -1864,11 +2255,17 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * @category Getter
    * @since v3.0.0
    */
-  getValues<Values = ValuesFromSchema<Schemas[1]>>(): Values;
+  getValues(): Values<Schemas[1]>;
 
   /**
    * The getValueIds method returns the Ids of every Value in a Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getValueIds(): Ids;
+   * ```
+   *
    * Note that this returns a copy of, rather than a reference, to the list of
    * Ids, so changes made to the list are not made to the Store itself.
    *
@@ -1893,11 +2290,17 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * @category Getter
    * @since v3.0.0
    */
-  getValueIds<Ids = ValueIdFromSchema<Schemas[1]>[]>(): Ids;
+  getValueIds(): ValueIdFromSchema<Schemas[1]>[];
 
   /**
    * The getValue method returns a single keyed Value in the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * getValue(valueId: Id): ValueOrUndefined;
+   * ```
+   *
    * @param valueId The Id of the Value in the Store.
    * @returns The Value, or `undefined`.
    * @example
@@ -1919,12 +2322,9 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * @category Getter
    * @since v3.0.0
    */
-  getValue<
-    ValueId extends ValueIdFromSchema<Schemas[1]>,
-    ValueOrUndefined = ValueFromSchema<Schemas[1], ValueId> | undefined,
-  >(
+  getValue<ValueId extends ValueIdFromSchema<Schemas[1]>>(
     valueId: ValueId,
-  ): ValueOrUndefined;
+  ): DefaultedValueFromSchema<Schemas[1], ValueId>;
 
   /**
    * The hasTables method returns a boolean indicating whether any Table objects
@@ -1950,6 +2350,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The hasTable method returns a boolean indicating whether a given Table
    * exists in the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * hasTable(tableId: Id): boolean;
+   * ```
+   *
    * @param tableId The Id of a possible Table in the Store.
    * @returns Whether a Table with that Id exists.
    * @example
@@ -1964,14 +2370,18 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Getter
    */
-  hasTable<TableId extends TableIdFromSchema<Schemas[0]>>(
-    tableId: TableId,
-  ): boolean;
+  hasTable(tableId: TableIdFromSchema<Schemas[0]>): boolean;
 
   /**
    * The hasRow method returns a boolean indicating whether a given Row exists
    * in the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * hasRow(tableId: Id, rowId: Id): boolean;
+   * ```
+   *
    * @param tableId The Id of a possible Table in the Store.
    * @param rowId The Id of a possible Row in the Table.
    * @returns Whether a Row with that Id exists in that Table.
@@ -1987,15 +2397,18 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Getter
    */
-  hasRow<TableId extends TableIdFromSchema<Schemas[0]>>(
-    tableId: TableId,
-    rowId: Id,
-  ): boolean;
+  hasRow(tableId: TableIdFromSchema<Schemas[0]>, rowId: Id): boolean;
 
   /**
    * The hasCell method returns a boolean indicating whether a given Cell exists
    * in the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * hasCell(tableId: Id, rowId: Id, cellId: Id): boolean;
+   * ```
+   *
    * @param tableId The Id of a possible Table in the Store.
    * @param rowId The Id of a possible Row in the Table.
    * @param cellId The Id of a possible Cell in the Row.
@@ -2012,13 +2425,10 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Getter
    */
-  hasCell<
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    CellId extends CellIdFromSchema<Schemas[0], TableId>,
-  >(
+  hasCell<TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: TableId,
     rowId: Id,
-    cellId: CellId,
+    cellId: CellIdFromSchema<Schemas[0], TableId>,
   ): boolean;
 
   /**
@@ -2046,6 +2456,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The hasValue method returns a boolean indicating whether a given Value
    * exists in the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * hasValue(valueId: Id): boolean;
+   * ```
+   *
    * @param valueId The Id of a possible Value in the Store.
    * @returns Whether a Value with that Id exists in the Store.
    * @example
@@ -2061,9 +2477,7 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * @category Getter
    * @since v3.0.0
    */
-  hasValue<ValueId extends ValueIdFromSchema<Schemas[1]>>(
-    valueId: ValueId,
-  ): boolean;
+  hasValue(valueId: ValueIdFromSchema<Schemas[1]>): boolean;
 
   /**
    * The getTablesJson method returns a string serialization of all of the
@@ -2259,6 +2673,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
   /**
    * The setTables method takes an object and sets the entire data of the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * setTables(tables: Tables): Store;
+   * ```
+   *
    * This method will cause listeners to be called for any Table, Row, Cell, or
    * Id changes resulting from it.
    *
@@ -2302,14 +2722,18 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Setter
    */
-  setTables<Tables = TablesFromSchema<Schemas[0], true>>(
-    tables: Tables,
-  ): Store<Schemas>;
+  setTables(tables: Tables<Schemas[0], true>): Store<Schemas>;
 
   /**
    * The setTable method takes an object and sets the entire data of a single
    * Table in the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * setTable(tableId: Id, table: Table): Store;
+   * ```
+   *
    * This method will cause listeners to be called for any Table, Row, Cell, or
    * Id changes resulting from it.
    *
@@ -2355,18 +2779,21 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Setter
    */
-  setTable<
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    Table = TableFromSchema<Schemas[0], TableId, true>,
-  >(
+  setTable<TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: TableId,
-    table: Table,
+    table: Table<Schemas[0], TableId, true>,
   ): Store<Schemas>;
 
   /**
    * The setRow method takes an object and sets the entire data of a single Row
    * in the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * setRow(tableId: Id, rowId: Id, row: Row): Store;
+   * ```
+   *
    * This method will cause listeners to be called for any Table, Row, Cell, or
    * Id changes resulting from it.
    *
@@ -2411,19 +2838,22 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Setter
    */
-  setRow<
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    Row = RowFromSchema<Schemas[0], TableId, true>,
-  >(
+  setRow<TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: TableId,
     rowId: Id,
-    row: Row,
+    row: Row<Schemas[0], TableId, true>,
   ): Store<Schemas>;
 
   /**
    * The addRow method takes an object and creates a new Row in the Store,
    * returning the unique Id assigned to it.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addRow(tableId: Id, row: Row): Id | undefined;
+   * ```
+   *
    * This method will cause listeners to be called for any Table, Row, Cell, or
    * Id changes resulting from it.
    *
@@ -2471,18 +2901,21 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Setter
    */
-  addRow<
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    Row = RowFromSchema<Schemas[0], TableId, true>,
-  >(
+  addRow<TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: TableId,
-    row: Row,
+    row: Row<Schemas[0], TableId, true>,
   ): Id | undefined;
 
   /**
    * The setPartialRow method takes an object and sets 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
+   * setPartialRow(tableId: Id, rowId: Id, partialRow: Row): Store;
+   * ```
+   *
    * This method will cause listeners to be called for any Table, Row, Cell, or
    * Id changes resulting from it.
    *
@@ -2529,18 +2962,21 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Setter
    */
-  setPartialRow<
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    Row = RowFromSchema<Schemas[0], TableId, true>,
-  >(
+  setPartialRow<TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: TableId,
     rowId: Id,
-    partialRow: Row,
+    partialRow: Row<Schemas[0], TableId, true>,
   ): Store<Schemas>;
 
   /**
    * The setCell method sets the value of a single Cell in the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * setCell(tableId: Id, rowId: Id, cellId: Id, cell: Cell | MapCell): Store;
+   * ```
+   *
    * This method will cause listeners to be called for any Table, Row, Cell, or
    * Id changes resulting from it.
    *
@@ -2597,18 +3033,24 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
   setCell<
     TableId extends TableIdFromSchema<Schemas[0]>,
     CellId extends CellIdFromSchema<Schemas[0], TableId>,
-    Cell = CellFromSchema<Schemas[0], TableId, CellId>,
-    MapCell = (cell: Cell | undefined) => Cell,
   >(
     tableId: TableId,
     rowId: Id,
     cellId: CellId,
-    cell: Cell | MapCell,
+    cell:
+      | Cell<Schemas[0], TableId, CellId>
+      | MapCell<Schemas[0], TableId, CellId>,
   ): Store<Schemas>;
 
   /**
    * The setValues method takes an object and sets all the Values in the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * setValues(values: Values): Store;
+   * ```
+   *
    * This method will cause listeners to be called for any Value or Id changes
    * resulting from it.
    *
@@ -2652,14 +3094,18 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * @category Setter
    * @since v3.0.0
    */
-  setValues<Values = ValuesFromSchema<Schemas[1], true>>(
-    values: Values,
-  ): Store<Schemas>;
+  setValues(values: Values<Schemas[1], true>): Store<Schemas>;
 
   /**
    * The setPartialValues method takes an object and sets its Values in the
    * Store, but leaving existing Values unaffected.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * setPartialValues(partialValues: Values): Store;
+   * ```
+   *
    * This method will cause listeners to be called for any Values or Id changes
    * resulting from it.
    *
@@ -2704,13 +3150,17 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * @category Setter
    * @since v3.0.0
    */
-  setPartialValues<Values = ValuesFromSchema<Schemas[1], true>>(
-    partialValues: Values,
-  ): Store<Schemas>;
+  setPartialValues(partialValues: Values<Schemas[1], true>): Store<Schemas>;
 
   /**
    * The setValue method sets a single keyed Value in the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * setValue(valueId: Id, value: Value | MapValue): Store;
+   * ```
+   *
    * This method will cause listeners to be called for any Value, or Id changes
    * resulting from it.
    *
@@ -2760,19 +3210,21 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * @category Setter
    * @since v3.0.0
    */
-  setValue<
-    ValueId extends ValueIdFromSchema<Schemas[1]>,
-    Value = ValueFromSchema<Schemas[1], ValueId>,
-    MapValue = (value: Value | undefined) => Value,
-  >(
+  setValue<ValueId extends ValueIdFromSchema<Schemas[1]>>(
     valueId: ValueId,
-    value: Value | MapValue,
+    value: Value<Schemas[1], ValueId> | MapValue<Schemas[1], ValueId>,
   ): Store<Schemas>;
 
   /**
    * The setTablesJson method takes a string serialization of all of the Tables
    * in the Store and attempts to update them to that.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * setTablesJson(tablesJson: Json): Store;
+   * ```
+   *
    * If the JSON cannot be parsed, this will fail silently. If it can be parsed,
    * it will then be subject to the same validation rules as the setTables
    * method (according to the Tables type, and matching any TablesSchema
@@ -2808,6 +3260,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The setValuesJson method takes a string serialization of all of the Values
    * in the Store and attempts to update them to those values.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * setValuesJson(valuesJson: Json): Store;
+   * ```
+   *
    * If the JSON cannot be parsed, this will fail silently. If it can be parsed,
    * it will then be subject to the same validation rules as the setValues
    * method (according to the Values type, and matching any ValuesSchema
@@ -2843,6 +3301,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The setJson method takes a string serialization of all of the Tables and
    * Values in the Store and attempts to update them to those values.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * setJson(tablesAndValuesJson: Json): Store;
+   * ```
+   *
    * From v3.0.0 onwards, the serialization should be of an array with two
    * entries. The first is the Tables object, the second the Values. In previous
    * versions (before the existence of the Values data structure), it was a sole
@@ -2902,18 +3366,16 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The setTablesSchema method lets you specify the TablesSchema of the tabular
    * part of the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
    * ```ts override
-   * setTablesSchema(tablesSchema: TablesSchema): Store<Schemas>
+   * setTablesSchema(tablesSchema: TablesSchema): Store;
    * ```
    *
    * Note that this may result in a change to data in the Store, as defaults are
    * applied or as invalid Table, Row, or Cell objects are removed. These
    * changes will fire any listeners to that data, as expected.
    *
-   * This method will return a Store that is typed according to the schema that
-   * you provided. To benefit from that, you may wish to assign it to a new
-   * variable so that TypeScript is able to reason about its subsequent usage.
-   *
    * When no longer needed, you can also completely remove an existing
    * TablesSchema with the delTablesSchema method.
    *
@@ -2937,29 +3399,24 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * @category Setter
    * @since v3.0.0
    */
-  setTablesSchema<
-    TablesSchema extends TablesSchemaAlias,
-    ValuesSchema extends OptionalValuesSchema = Schemas[1],
-  >(
-    tablesSchema: TablesSchema,
-  ): Store<[typeof tablesSchema, ValuesSchema]>;
+  setTablesSchema<TS extends TablesSchema>(
+    tablesSchema: TS,
+  ): Store<[typeof tablesSchema, Schemas[1]]>;
 
   /**
    * The setValuesSchema method lets you specify the ValuesSchema of the keyed
    * Values part of the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
    * ```ts override
-   * setValuesSchema(valuesSchema: ValuesSchema): Store<Schemas>
+   * setValuesSchema(valuesSchema: ValuesSchema): Store;
    * ```
    *
    * Note that this may result in a change to data in the Store, as defaults are
    * applied or as invalid Values are removed. These changes will fire any
    * listeners to that data, as expected.
    *
-   * This method will return a Store that is typed according to the schema that
-   * you provided. To benefit from that, you may wish to assign it to a new
-   * variable so that TypeScript is able to reason about its subsequent usage.
-   *
    * When no longer needed, you can also completely remove an existing
    * ValuesSchema with the delValuesSchema method.
    *
@@ -2980,32 +3437,24 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * @category Setter
    * @since v3.0.0
    */
-  setValuesSchema<
-    ValuesSchema extends ValuesSchemaAlias,
-    TablesSchema extends OptionalTablesSchema = Schemas[0],
-  >(
-    valuesSchema: ValuesSchema,
-  ): Store<[TablesSchema, typeof valuesSchema]>;
+  setValuesSchema<VS extends ValuesSchema>(
+    valuesSchema: VS,
+  ): Store<[Schemas[0], typeof valuesSchema]>;
 
   /**
    * The setSchema method lets you specify the TablesSchema and ValuesSchema of
    * the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
    * ```ts override
-   * setSchema(
-   *   tablesSchema: TablesSchema,
-   *   valuesSchema?: ValuesSchema,
-   * ): Store<Schemas>
+   * setSchema(tablesSchema: TablesSchema, valuesSchema?: ValuesSchema): Store;
    * ```
    *
    * Note that this may result in a change to data in the Store, as defaults are
    * applied or as invalid Table, Row, Cell, or Value objects are removed. These
    * changes will fire any listeners to that data, as expected.
    *
-   * This method will return a Store that is typed according to the schemas that
-   * you provided. To benefit from that, you may wish to assign it to a new
-   * variable so that TypeScript is able to reason about its subsequent usage.
-   *
    * From v3.0.0 onwards, this method takes two arguments. The first is the
    * TablesSchema object, the second the ValuesSchema. In previous versions
    * (before the existence of the ValuesSchema data structure), only the first
@@ -3055,16 +3504,13 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Setter
    */
-  setSchema<
-    TablesSchema extends TablesSchemaAlias,
-    ValuesSchema extends ValuesSchemaAlias,
-  >(
-    tablesSchema: TablesSchema,
-    valuesSchema?: ValuesSchema,
+  setSchema<TS extends TablesSchema, VS extends ValuesSchema>(
+    tablesSchema: TS,
+    valuesSchema?: VS,
   ): Store<
     [
       typeof tablesSchema,
-      Exclude<ValuesSchemaAlias, typeof valuesSchema> extends never
+      Exclude<ValuesSchema, typeof valuesSchema> extends never
         ? NoValuesSchema
         : NonNullable<typeof valuesSchema>,
     ]
@@ -3073,6 +3519,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
   /**
    * The delTables method lets you remove all of the data in a Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * delTables(): Store;
+   * ```
+   *
    * @returns A reference to the Store.
    * @example
    * This example removes the data of a Store.
@@ -3091,6 +3543,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
   /**
    * The delTable method lets you remove a single Table from the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * delTable(tableId: Id): Store;
+   * ```
+   *
    * @param tableId The Id of the Table in the Store.
    * @returns A reference to the Store.
    * @example
@@ -3108,13 +3566,17 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Deleter
    */
-  delTable<TableId extends TableIdFromSchema<Schemas[0]>>(
-    tableId: TableId,
-  ): Store<Schemas>;
+  delTable(tableId: TableIdFromSchema<Schemas[0]>): Store<Schemas>;
 
   /**
    * The delRow method lets you remove a single Row from a Table.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * delRow(tableId: Id, rowId: Id): Store;
+   * ```
+   *
    * If this is the last Row in its Table, then that Table will be removed.
    *
    * @param tableId The Id of the Table in the Store.
@@ -3134,14 +3596,17 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Deleter
    */
-  delRow<TableId extends TableIdFromSchema<Schemas[0]>>(
-    tableId: TableId,
-    rowId: Id,
-  ): Store<Schemas>;
+  delRow(tableId: TableIdFromSchema<Schemas[0]>, rowId: Id): Store<Schemas>;
 
   /**
    * The delCell method lets you remove a single Cell from a Row.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * delCell(tableId: Id, rowId: Id, cellId: Id, forceDel?: boolean): Store;
+   * ```
+   *
    * When there is no TablesSchema applied to the Store, then if this is the
    * last Cell in its Row, then that Row will be removed. If, in turn, that is
    * the last Row in its Table, then that Table will be removed.
@@ -3221,19 +3686,22 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Deleter
    */
-  delCell<
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    CellId extends CellIdFromSchema<Schemas[0], TableId>,
-  >(
+  delCell<TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: TableId,
     rowId: Id,
-    cellId: CellId,
+    cellId: CellIdFromSchema<Schemas[0], TableId>,
     forceDel?: boolean,
   ): Store<Schemas>;
 
   /**
    * The delValues method lets you remove all the Values from a Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * delValues(): Store;
+   * ```
+   *
    * If there is a ValuesSchema applied to the Store and it specifies a default
    * value for any Value Id, then deletion will result in it being set back to
    * its default value.
@@ -3273,6 +3741,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
   /**
    * The delValue method lets you remove a single Value from a Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * delValue(valueId: Id): Store;
+   * ```
+   *
    * If there is a ValuesSchema applied to the Store and it specifies a default
    * value for this Value Id, then deletion will result in it being set back to
    * its default value.
@@ -3308,13 +3782,17 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * @category Deleter
    * @since v3.0.0
    */
-  delValue<ValueId extends ValueIdFromSchema<Schemas[1]>>(
-    valueId: ValueId,
-  ): Store<Schemas>;
+  delValue(valueId: ValueIdFromSchema<Schemas[1]>): Store<Schemas>;
 
   /**
    * The delTablesSchema method lets you remove the TablesSchema of the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * delTablesSchema(): Store;
+   * ```
+   *
    * @returns A reference to the Store.
    * @example
    * This example removes the TablesSchema of a Store.
@@ -3336,6 +3814,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
   /**
    * The delValuesSchema method lets you remove the ValuesSchema of the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * delValuesSchema(): Store;
+   * ```
+   *
    * @returns A reference to the Store.
    * @example
    * This example removes the ValuesSchema of a Store.
@@ -3359,6 +3843,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The delSchema method lets you remove both the TablesSchema and ValuesSchema
    * of the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * delSchema(): Store;
+   * ```
+   *
    * Prior to v3.0.0, this method removed the TablesSchema only.
    *
    * @returns A reference to the Store.
@@ -3387,6 +3877,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * the Store, buffering all calls to the relevant listeners until it
    * completes.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * transaction<Return>(actions: () => Return, doRollback?: DoRollback): Return;
+   * ```
+   *
    * This method is useful for making bulk changes to the data in a Store, and
    * when you don't want listeners to be called as you make each change. Changes
    * are made silently during the transaction, and listeners relevant to the
@@ -3519,6 +4015,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * relevant listeners until it completes when you call the finishTransaction
    * method.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * startTransaction(): Store;
+   * ```
+   *
    * Transactions are useful for making bulk changes to the data in a Store, and
    * when you don't want listeners to be called as you make each change. Changes
    * are made silently during the transaction, and listeners relevant to the
@@ -3569,6 +4071,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * that has made multiple mutations to the Store, triggering all calls to the
    * relevant listeners.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * finishTransaction(doRollback?: DoRollback): Store;
+   * ```
+   *
    * Transactions are useful for making bulk changes to the data in a Store, and
    * when you don't want listeners to be called as you make each change. Changes
    * are made silently during the transaction, and listeners relevant to the
@@ -3666,6 +4174,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The forEachTable method takes a function that it will then call for each
    * Table in the Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * forEachTable(tableCallback: TableCallback): void;
+   * ```
+   *
    * This method is useful for iterating over the Table structure of the Store
    * in a functional style. The `tableCallback` parameter is a TableCallback
    * function that will be called with the Id of each Table, and with a function
@@ -3693,14 +4207,18 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Iterator
    */
-  forEachTable<TableCallback = TableCallbackAlias<Schemas[0]>>(
-    tableCallback: TableCallback,
-  ): void;
+  forEachTable(tableCallback: TableCallback<Schemas[0]>): void;
 
   /**
    * The forEachRow method takes a function that it will then call for each Row
    * in a specified Table.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * forEachRow(tableId: Id, rowCallback: RowCallback): void;
+   * ```
+   *
    * This method is useful for iterating over the Row structure of the Table in
    * a functional style. The `rowCallback` parameter is a RowCallback function
    * that will be called with the Id of each Row, and with a function that can
@@ -3730,18 +4248,21 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Iterator
    */
-  forEachRow<
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    RowCallback = RowCallbackAlias<Schemas[0], TableId>,
-  >(
+  forEachRow<TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: TableId,
-    rowCallback: RowCallback,
+    rowCallback: RowCallback<Schemas[0], TableId>,
   ): void;
 
   /**
    * The forEachCell method takes a function that it will then call for each
    * Cell in a specified Row.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * forEachCell(tableId: Id, rowId: Id, cellCallback: CellCallback): void;
+   * ```
+   *
    * This method is useful for iterating over the Cell structure of the Row in a
    * functional style. The `cellCallback` parameter is a CellCallback function
    * that will be called with the Id and value of each Cell.
@@ -3764,19 +4285,22 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * ```
    * @category Iterator
    */
-  forEachCell<
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    CellCallback = CellCallbackAlias<Schemas[0], TableId>,
-  >(
+  forEachCell<TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: TableId,
     rowId: Id,
-    cellCallback: CellCallback,
+    cellCallback: CellCallback<Schemas[0], TableId>,
   ): void;
 
   /**
    * The forEachValue method takes a function that it will then call for each
    * Value in a Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * forEachValue(valueCallback: ValueCallback): void;
+   * ```
+   *
    * This method is useful for iterating over the Value structure of the Store
    * in a functional style. The `valueCallback` parameter is a ValueCallback
    * function that will be called with the Id and value of each Value.
@@ -3796,14 +4320,18 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * @category Iterator
    * @since v3.0.0
    */
-  forEachValue<ValueCallback = ValueCallbackAlias<Schemas[1]>>(
-    valueCallback: ValueCallback,
-  ): void;
+  forEachValue(valueCallback: ValueCallback<Schemas[1]>): void;
 
   /**
    * The addTablesListener method registers a listener function with the Store
    * that will be called whenever data in the Store changes.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addTablesListener(listener: TablesListener, mutator?: boolean): Id;
+   * ```
+   *
    * The provided listener is a TablesListener function, and will be called with
    * a reference to the Store and a GetCellChange function in case you need to
    * inspect any changes that occurred.
@@ -3868,6 +4396,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The addTableIdsListener method registers a listener function with the Store
    * that will be called whenever the Table Ids in the Store change.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addTableIdsListener(listener: TableIdsListener, mutator?: boolean): Id;
+   * ```
+   *
    * The provided listener is a TableIdsListener function, and will be called
    * with a reference to the Store.
    *
@@ -3934,6 +4468,16 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The addTableListener method registers a listener function with the Store
    * that will be called whenever data in a Table changes.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addTableListener(
+   *   tableId: IdOrNull,
+   *   listener: TableListener,
+   *   mutator?: boolean,
+   * ): Id;
+   * ```
+   *
    * The provided listener is a TableListener function, and will be called with
    * a reference to the Store, the Id of the Table that changed, and a
    * GetCellChange function in case you need to inspect any changes that
@@ -4031,6 +4575,16 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The addRowIdsListener method registers a listener function with the 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
+   * addRowIdsListener(
+   *   tableId: IdOrNull,
+   *   listener: RowIdsListener,
+   *   mutator?: boolean,
+   * ): Id;
+   * ```
+   *
    * The provided listener is a RowIdsListener function, and will be called with
    * a reference to the Store and the Id of the Table that changed.
    *
@@ -4124,6 +4678,20 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * Store that will be called whenever sorted (and optionally, paginated) Row
    * Ids in a Table change.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addSortedRowIdsListener(
+   *   tableId: Id,
+   *   cellId: Id | undefined,
+   *   descending: boolean,
+   *   offset: number,
+   *   limit: number | undefined,
+   *   listener: SortedRowIdsListener,
+   *   mutator?: boolean,
+   * ): Id;
+   * ```
+   *
    * The provided listener is a SortedRowIdsListener function, and will be
    * called with a reference to the Store, the Id of the Table whose Row Ids
    * sorting changed, the Cell Id being used to sort them, whether descending or
@@ -4337,20 +4905,20 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    */
   addSortedRowIdsListener<
     TableId extends TableIdFromSchema<Schemas[0]>,
-    CellId extends CellIdFromSchema<Schemas[0], TableId> | undefined,
+    CellIdOrUndefined extends CellIdFromSchema<Schemas[0], TableId> | undefined,
     Descending extends boolean,
     Offset extends number,
     Limit extends number | undefined,
   >(
     tableId: TableId,
-    cellId: CellId,
+    cellId: CellIdOrUndefined,
     descending: Descending,
     offset: Offset,
     limit: Limit,
     listener: SortedRowIdsListener<
       Schemas,
       TableId,
-      CellId,
+      CellIdOrUndefined,
       Descending,
       Offset,
       Limit
@@ -4362,6 +4930,17 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The addRowListener method registers a listener function with the Store that
    * will be called whenever data in a Row changes.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addRowListener(
+   *   tableId: IdOrNull,
+   *   rowId: IdOrNull,
+   *   listener: RowListener,
+   *   mutator?: boolean,
+   * ): Id;
+   * ```
+   *
    * The provided listener is a RowListener function, and will be called with a
    * reference to the Store, the Id of the Table that changed, the Id of the Row
    * that changed, and a GetCellChange function in case you need to inspect any
@@ -4475,6 +5054,17 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The addCellIdsListener method registers a listener function with the 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
+   * addCellIdsListener(
+   *   tableId: IdOrNull,
+   *   rowId: IdOrNull,
+   *   listener: CellIdsListener,
+   *   mutator?: boolean,
+   * ): Id;
+   * ```
+   *
    * The provided listener is a CellIdsListener function, and will be called
    * with a reference to the Store, the Id of the Table, and the Id of the Row
    * that changed.
@@ -4584,6 +5174,18 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The addCellListener method registers a listener function with the Store
    * that will be called whenever data in a Cell changes.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addCellListener(
+   *   tableId: IdOrNull,
+   *   rowId: IdOrNull,
+   *   cellId: IdOrNull,
+   *   listener: CellListener,
+   *   mutator?: boolean,
+   * ): Id;
+   * ```
+   *
    * The provided listener is a CellListener function, and will be called with a
    * reference to the Store, the Id of the Table that changed, the Id of the Row
    * that changed, the Id of the Cell that changed, the new Cell value, the old
@@ -4700,17 +5302,11 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
           ? CellIdFromSchema<Schemas[0], TableIdOrNull>
           : AllCellIdFromSchema<Schemas[0]>)
       | null,
-    CellListener extends CellListenerAlias<
-      Schemas,
-      TableIdOrNull,
-      RowIdOrNull,
-      CellIdOrNull
-    >,
   >(
     tableId: TableIdOrNull,
     rowId: RowIdOrNull,
     cellId: CellIdOrNull,
-    listener: CellListener,
+    listener: CellListener<Schemas, TableIdOrNull, RowIdOrNull, CellIdOrNull>,
     mutator?: boolean,
   ): Id;
 
@@ -4718,6 +5314,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The addValuesListener method registers a listener function with the Store
    * that will be called whenever the Values change.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addValuesListener(listener: ValuesListener, mutator?: boolean): Id;
+   * ```
+   *
    * The provided listener is a ValuesListener function, and will be called with
    * a reference to the Store and a GetValueChange function in case you need to
    * inspect any changes that occurred.
@@ -4779,6 +5381,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The addValueIdsListener method registers a listener function with the Store
    * that will be called whenever the Value Ids in a Store change.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addValueIdsListener(listener: ValueIdsListener, mutator?: boolean): Id;
+   * ```
+   *
    * The provided listener is a ValueIdsListener function, and will be called
    * with a reference to the Store.
    *
@@ -4846,6 +5454,16 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The addValueListener method registers a listener function with the Store
    * that will be called whenever data in a Value changes.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addValueListener(
+   *   valueId: IdOrNull,
+   *   listener: ValueListener,
+   *   mutator?: boolean,
+   * ): Id;
+   * ```
+   *
    * The provided listener is a ValueListener function, and will be called with
    * a reference to the Store, the Id of the Value that changed, the new Value
    * value, the old Value, and a GetValueChange function in case you need to
@@ -4929,12 +5547,9 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * @category Listener
    * @since v3.0.0
    */
-  addValueListener<
-    ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null,
-    ValueListener = ValueListenerAlias<Schemas, ValueIdOrNull>,
-  >(
+  addValueListener<ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null>(
     valueId: ValueIdOrNull,
-    listener: ValueListener,
+    listener: ValueListener<Schemas, ValueIdOrNull>,
     mutator?: boolean,
   ): Id;
 
@@ -4943,6 +5558,18 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * Store that will be called whenever invalid data was attempted to be written
    * to a Cell.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addInvalidCellListener(
+   *   tableId: IdOrNull,
+   *   rowId: IdOrNull,
+   *   cellId: IdOrNull,
+   *   listener: InvalidCellListener,
+   *   mutator?: boolean,
+   * ): Id;
+   * ```
+   *
    * The provided listener is an InvalidCellListener function, and will be
    * called with a reference to the Store, the Id of the Table, the Id of the
    * Row, and the Id of Cell that was being attempted to be changed. It is also
@@ -5174,6 +5801,16 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * Store that will be called whenever invalid data was attempted to be written
    * to a Value.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addInvalidValueListener(
+   *   valueId: IdOrNull,
+   *   listener: InvalidValueListener,
+   *   mutator?: boolean,
+   * ): Id;
+   * ```
+   *
    * The provided listener is an InvalidValueListener function, and will be
    * called with a reference to the Store and the Id of Value that was being
    * attempted to be changed. It is also given the invalid value of the Value,
@@ -5350,6 +5987,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * with the Store that will be called just before other non-mutating listeners
    * are called at the end of the transaction.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addWillFinishTransactionListener(listener: TransactionListener): Id;
+   * ```
+   *
    * This is useful if you need to know that a set of listeners are about to be
    * called at the end of a transaction, perhaps to batch _their_ consequences
    * together.
@@ -5442,6 +6085,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * with the Store that will be called just after other non-mutating listeners
    * are called at the end of the transaction.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addDidFinishTransactionListener(listener: TransactionListener): Id;
+   * ```
+   *
    * This is useful if you need to know that a set of listeners have just been
    * called at the end of a transaction, perhaps to batch _their_ consequences
    * together.
@@ -5534,6 +6183,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The callListener method provides a way for you to manually provoke a
    * listener to be called, even if the underlying data hasn't changed.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * callListener(listenerId: Id): Store;
+   * ```
+   *
    * This is useful when you are using mutator listeners to guarantee that data
    * conforms to programmatic conditions, and those conditions change such that
    * you need to update the Store in bulk.
@@ -5651,6 +6306,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
    * The delListener method removes a listener that was previously added to the
    * Store.
    *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * delListener(listenerId: Id): Store;
+   * ```
+   *
    * Use the Id returned by whichever method was used to add the listener. Note
    * that the Store may re-use this Id for future listeners added to it.
    *
@@ -5716,6 +6377,12 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
  * The createStore function creates a Store, and is the main entry point into
  * the store module.
  *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * createStore(): Store;
+ * ```
+ *
  * Since (or perhaps _because_) it is the most important function in the whole
  * module, it is trivially simple.
  *
@@ -5754,390 +6421,4 @@ export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
  * @see The Basics guides
  * @category Creation
  */
-export function createStore(): Store;
-
-/**
- * The TablesFromSchema type is a utility for determining a Tables structure
- * from a provided TablesSchema.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type TablesFromSchema<
-  Schema extends OptionalTablesSchema,
-  WhenSet extends boolean = false,
-> = {
-  -readonly [TableId in TableIdFromSchema<Schema>]?: TableFromSchema<
-    Schema,
-    TableId,
-    WhenSet
-  >;
-};
-
-/**
- * The TableIdFromSchema type is a utility for determining the Id of Tables from
- * a provided TablesSchema.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type TableIdFromSchema<Schema extends OptionalTablesSchema> = AsId<
-  keyof Schema
->;
-
-/**
- * The TableFromSchema type is a utility for determining a Table structure from
- * a provided TablesSchema.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type TableFromSchema<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
-  WhenSet extends boolean = false,
-> = {[rowId: Id]: RowFromSchema<Schema, TableId, WhenSet>};
-
-/**
- * The RowFromSchema type is a utility for determining a Row structure from a
- * provided TablesSchema.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type RowFromSchema<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
-  WhenSet extends boolean = false,
-> = (WhenSet extends true
-  ? {
-      -readonly [CellId in DefaultCellIdFromSchema<
-        Schema,
-        TableId
-      >]?: CellFromSchema<Schema, TableId, CellId>;
-    }
-  : {
-      -readonly [CellId in DefaultCellIdFromSchema<
-        Schema,
-        TableId
-      >]: CellFromSchema<Schema, TableId, CellId>;
-    }) & {
-  -readonly [CellId in DefaultCellIdFromSchema<
-    Schema,
-    TableId,
-    false
-  >]?: CellFromSchema<Schema, TableId, CellId>;
-};
-
-/**
- * The CellIdFromSchema type is a utility for determining the Id of Cells from a
- * provided TablesSchema.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type CellIdFromSchema<
-  Schema extends OptionalTablesSchema,
-  TableId extends TableIdFromSchema<Schema>,
-> = AsId<keyof Schema[TableId]>;
-
-/**
- * The DefaultCellIdFromSchema type is a utility for determining Cells with or
- * without default status from a provided TablesSchema.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type DefaultCellIdFromSchema<
-  Schema extends OptionalTablesSchema,
-  TableId extends TableIdFromSchema<Schema>,
-  IsDefaulted extends boolean = true,
-> = AsId<
-  {
-    [CellId in CellIdFromSchema<
-      Schema,
-      TableId
-    >]: Schema[TableId][CellId] extends {
-      default: string | number | boolean;
-    }
-      ? IsDefaulted extends true
-        ? CellId
-        : never
-      : IsDefaulted extends true
-      ? never
-      : CellId;
-  }[CellIdFromSchema<Schema, TableId>]
->;
-
-/**
- * The AllCellIdFromSchema type is a utility for determining the Id of Cells
- * across all Tables, from a provided TablesSchema.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type AllCellIdFromSchema<
-  Schema extends OptionalTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
-> = TableId extends TableIdFromSchema<Schema>
-  ? CellIdFromSchema<Schema, TableId>
-  : never;
-
-/**
- * The CellFromSchema type is a utility for determining a Cell type from a
- * provided TablesSchema.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type CellFromSchema<
-  Schema extends OptionalTablesSchema,
-  TableId extends TableIdFromSchema<Schema>,
-  CellId extends CellIdFromSchema<Schema, TableId>,
-  CellType = Schema[TableId][CellId]['type'],
-> = CellType extends 'string'
-  ? string
-  : CellType extends 'number'
-  ? number
-  : CellType extends 'boolean'
-  ? boolean
-  : string | number | boolean;
-
-/**
- * The ValuesFromSchema type is a utility for determining a Values structure
- * from a provided ValuesSchema.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type ValuesFromSchema<
-  Schema extends OptionalValuesSchema,
-  WhenSet extends boolean = false,
-> = (WhenSet extends true
-  ? {
-      -readonly [ValueId in DefaultValueIdFromSchema<Schema>]?: ValueFromSchema<
-        Schema,
-        ValueId
-      >;
-    }
-  : {
-      -readonly [ValueId in DefaultValueIdFromSchema<Schema>]: ValueFromSchema<
-        Schema,
-        ValueId
-      >;
-    }) & {
-  -readonly [ValueId in DefaultValueIdFromSchema<
-    Schema,
-    false
-  >]?: ValueFromSchema<Schema, ValueId>;
-};
-
-/**
- * The ValueIdFromSchema type is a utility for determining the Id of Values from
- * a provided ValuesSchema.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type ValueIdFromSchema<Schema extends OptionalValuesSchema> = AsId<
-  keyof Schema
->;
-
-/**
- * The DefaultValueIdFromSchema type is a utility for determining Values with or
- * without default status from a provided ValuesSchema.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type DefaultValueIdFromSchema<
-  Schema extends OptionalValuesSchema,
-  IsDefaulted extends boolean = true,
-> = {
-  [ValueId in ValueIdFromSchema<Schema>]: Schema[ValueId] extends {
-    default: string | number | boolean;
-  }
-    ? IsDefaulted extends true
-      ? ValueId
-      : never
-    : IsDefaulted extends true
-    ? never
-    : ValueId;
-}[ValueIdFromSchema<Schema>];
-
-/**
- * The ValueFromSchema type is a utility for determining a Value type from a
- * provided ValuesSchema.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type ValueFromSchema<
-  Schema extends OptionalValuesSchema,
-  ValueId extends ValueIdFromSchema<Schema>,
-  ValueType = Schema[ValueId]['type'],
-> = ValueType extends 'string'
-  ? string
-  : ValueType extends 'number'
-  ? number
-  : ValueType extends 'boolean'
-  ? boolean
-  : string | number | boolean;
-
-/**
- * The AsId type is a utility for coercing keys to be Id-like.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type AsId<Key> = Exclude<Key & Id, number>;
-
-/**
- * The TablesSchemaAlias type is a duplicate of TablesSchema, used to mask
- * complex generics from documentation.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type TablesSchemaAlias = TablesSchema;
-
-/**
- * The ValuesSchemaAlias type is a duplicate of ValuesSchema, used to mask
- * complex generics from documentation.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type ValuesSchemaAlias = ValuesSchema;
-
-/**
- * The TableCallbackAlias type is a duplicate of TableCallback, used to mask
- * complex generics from documentation.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type TableCallbackAlias<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
-> = TableCallback<Schema, TableId>;
-
-/**
- * The RowCallbackAlias type is a duplicate of RowCallback, used to mask complex
- * generics from documentation.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type RowCallbackAlias<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
-> = RowCallback<Schema, TableId>;
-
-/**
- * The CellCallbackAlias type is a duplicate of CellCallback, used to mask
- * complex generics from documentation.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type CellCallbackAlias<
-  Schema extends OptionalTablesSchema = NoTablesSchema,
-  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
-  CellId extends CellIdFromSchema<Schema, TableId> = CellIdFromSchema<
-    Schema,
-    TableId
-  >,
-> = CellCallback<Schema, TableId, CellId>;
-
-/**
- * The ValueCallbackAlias type is a duplicate of ValueCallback, used to mask
- * complex generics from documentation.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type ValueCallbackAlias<
-  Schema extends OptionalValuesSchema = NoValuesSchema,
-  ValueId extends ValueIdFromSchema<Schema> = ValueIdFromSchema<Schema>,
-> = ValueCallback<Schema, ValueId>;
-
-/**
- * The CellListenerAlias type is a duplicate of CellListener, used to mask
- * complex generics from documentation.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type CellListenerAlias<
-  Schemas extends OptionalSchemas = NoSchemas,
-  TableIdOrNull extends TableIdFromSchema<
-    Schemas[0]
-  > | null = TableIdFromSchema<Schemas[0]> | null,
-  RowIdOrNull extends IdOrNull = IdOrNull,
-  CellIdOrNull extends
-    | (TableIdOrNull extends TableIdFromSchema<Schemas[0]>
-        ? CellIdFromSchema<Schemas[0], TableIdOrNull>
-        : AllCellIdFromSchema<Schemas[0]>)
-    | null =
-    | (TableIdOrNull extends TableIdFromSchema<Schemas[0]>
-        ? CellIdFromSchema<Schemas[0], TableIdOrNull>
-        : AllCellIdFromSchema<Schemas[0]>)
-    | null,
-> = CellListener<Schemas, TableIdOrNull, RowIdOrNull, CellIdOrNull>;
-
-/**
- * The ValueListenerAlias type is a duplicate of ValueListener, used to mask
- * complex generics from documentation.
- *
- * This type is used internally to the TinyBase type system and you are not
- * expected to need to use it directly.
- *
- * @category Internal
- */
-export type ValueListenerAlias<
-  Schemas extends OptionalSchemas = NoSchemas,
-  ValueIdOrNull extends ValueIdFromSchema<
-    Schemas[1]
-  > | null = ValueIdFromSchema<Schemas[1]> | null,
-> = ValueListener<Schemas, ValueIdOrNull>;
+export function createStore(): Store<NoSchemas>;