tinybase 3.1.0-beta.2 → 3.1.0-beta.4

package/lib/cjs-es6/store.d.ts

@@ -13,10 +13,173 @@
 
 import {Id, IdOrNull, Ids, Json} from './common.d';
 
+/**
+ * The TablesSchema type describes the tabular structure of a Store in terms of
+ * valid Table Ids and the types of Cell that can exist within them.
+ *
+ * A TablesSchema comprises a JavaScript object describing each Table, in turn a
+ * nested JavaScript object containing information about each Cell and its
+ * CellSchema. It is provided to the setTablesSchema method.
+ *
+ * @example
+ * When applied to a Store, this TablesSchema only allows one Table called
+ * `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
+ * const tableSchema: TablesSchema = {
+ *   pets: {
+ *     species: {type: 'string'},
+ *     sold: {type: 'boolean', default: false},
+ *   },
+ * };
+ * ```
+ * @category Schema
+ */
+export type TablesSchema = {[tableId: Id]: {[cellId: Id]: CellSchema}};
+
+/**
+ * The CellSchema type describes what values are allowed for each Cell in a
+ * Table.
+ *
+ * A CellSchema specifies the type of the Cell (`string`, `boolean`, or
+ * `number`), and what the default value can be when an explicit value is not
+ * specified.
+ *
+ * If a default value is provided (and its type is correct), you can be certain
+ * that that Cell will always be present in a Row.
+ *
+ * If the default value is _not_ provided (or its type is incorrect), the Cell
+ * may be missing from the Row, but when present you can be guaranteed it is of
+ * the correct type.
+ *
+ * @example
+ * When applied to a Store, this CellSchema ensures a boolean Cell is always
+ * present, and defaults it to `false`.
+ *
+ *```js
+ * const requiredBoolean: CellSchema = {type: 'boolean', default: false};
+ * ```
+ * @category Schema
+ */
+export type CellSchema =
+  | {type: 'string'; default?: string}
+  | {type: 'number'; default?: number}
+  | {type: 'boolean'; default?: boolean};
+
+/**
+ * The ValuesSchema type describes the keyed Values that can be set in a Store
+ * and their types.
+ *
+ * A ValuesSchema comprises a JavaScript object describing each Value and its
+ * ValueSchema. It is provided to the setValuesSchema method.
+ *
+ * @example
+ * When applied to a Store, this ValuesSchema only allows one boolean Value
+ * called `open`, that defaults to `false`.
+ *
+ *```js
+ * const valuesSchema: ValuesSchema = {
+ *   open: {type: 'boolean', default: false},
+ * };
+ * ```
+ * @category Schema
+ * @since v3.0.0
+ */
+export type ValuesSchema = {[valueId: Id]: ValueSchema};
+
+/**
+ * The ValueSchema type describes what values are allowed for keyed Values in a
+ * Store.
+ *
+ * A ValueSchema specifies the type of the Value (`string`, `boolean`, or
+ * `number`), and what the default value can be when an explicit value is not
+ * specified.
+ *
+ * If a default value is provided (and its type is correct), you can be certain
+ * that the Value will always be present in a Store.
+ *
+ * If the default value is _not_ provided (or its type is incorrect), the Value
+ * may not be present in the Store, but when present you can be guaranteed it is
+ * of the correct type.
+ *
+ * @example
+ * When applied to a Store, this ValueSchema ensures a boolean Value is always
+ * present, and defaults it to `false`.
+ *
+ *```js
+ * const requiredBoolean: ValueSchema = {type: 'boolean', default: false};
+ * ```
+ * @category Schema
+ * @since v3.0.0
+ */
+export type ValueSchema =
+  | {type: 'string'; default?: string}
+  | {type: 'number'; default?: number}
+  | {type: 'boolean'; default?: boolean};
+
+/**
+ * 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
+ */
+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
+ */
+export type NoValuesSchema = {[valueId: Id]: {type: 'any'}};
+
+/**
+ * The OptionalTablesSchema type is used by generic types that can optionally
+ * take a TablesSchema.
+ *
+ * @category Schema
+ */
+export type OptionalTablesSchema = TablesSchema | NoTablesSchema;
+
+/**
+ * The OptionalValuesSchema type is used by generic types that can optionally
+ * take a ValuesSchema.
+ *
+ * @category Schema
+ */
+export type OptionalValuesSchema = ValuesSchema | NoValuesSchema;
+
+/**
+ * The OptionalSchemas type is used by generic types that can optionally take
+ * either or both of a TablesSchema and ValuesSchema.
+ *
+ * @category Schema
+ */
+export type OptionalSchemas = [OptionalTablesSchema, OptionalValuesSchema];
+
+/**
+ * The NoSchemas type is used as a default by generic types that can optionally
+ * take either or both of a TablesSchema and ValuesSchema.
+ *
+ * @category Schema
+ */
+export type NoSchemas = [NoTablesSchema, NoValuesSchema];
+
 /**
  * The Tables type is the data structure representing all of the data in a
  * Store.
  *
+ * ```ts override
+ * {[tableId: Id]: Table}
+ * ```
+ *
  * A Tables object is used when setting all of the tables together with the
  * setTables method, and when getting them back out again with the getTables
  * method. A Tables object is a regular JavaScript object containing individual
@@ -37,11 +200,18 @@ import {Id, IdOrNull, Ids, Json} from './common.d';
  * ```
  * @category Store
  */
-export type Tables = {[tableId: Id]: Table};
+export type Tables<
+  Schema extends OptionalTablesSchema = NoTablesSchema,
+  WhenSet extends boolean = false,
+> = TablesFromSchema<Schema, WhenSet>;
 
 /**
  * The Table type is the data structure representing the data in a single table.
  *
+ * ```ts override
+ * {[rowId: Id]: Row}
+ * ```
+ *
  * A Table is used when setting a table with the setTable method, and when
  * getting it back out again with the getTable method. A Table object is a
  * regular JavaScript object containing individual Row objects, keyed by their
@@ -56,11 +226,19 @@ export type Tables = {[tableId: Id]: Table};
  * ```
  * @category Store
  */
-export type Table = {[rowId: Id]: Row};
+export type Table<
+  Schema extends OptionalTablesSchema = NoTablesSchema,
+  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
+  WhenSet extends boolean = false,
+> = TableFromSchema<Schema, TableId, WhenSet>;
 
 /**
  * The Row type is the data structure representing the data in a single row.
  *
+ * ```ts override
+ * {[cellId: Id]: Cell}
+ * ```
+ *
  * A Row is used when setting a row with the setRow method, and when getting it
  * back out again with the getRow method. A Row object is a regular JavaScript
  * object containing individual Cell objects, keyed by their Id.
@@ -71,11 +249,19 @@ export type Table = {[rowId: Id]: Row};
  * ```
  * @category Store
  */
-export type Row = {[cellId: Id]: Cell};
+export type Row<
+  Schema extends OptionalTablesSchema = NoTablesSchema,
+  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
+  WhenSet extends boolean = false,
+> = RowFromSchema<Schema, TableId, WhenSet>;
 
 /**
  * The Cell type is the data structure representing the data in a single cell.
  *
+ * ```ts override
+ * string | number | boolean
+ * ```
+ *
  * A Cell is used when setting a cell with the setCell method, and when getting
  * it back out again with the getCell method. A Cell is a JavaScript string,
  * number, or boolean.
@@ -86,7 +272,14 @@ export type Row = {[cellId: Id]: Cell};
  * ```
  * @category Store
  */
-export type Cell = string | number | boolean;
+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>;
 
 /**
  * The CellOrUndefined type is a data structure representing the data in a
@@ -98,12 +291,24 @@ export type Cell = string | number | boolean;
  *
  * @category Store
  */
-export type CellOrUndefined = Cell | undefined;
+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;
 
 /**
  * The Values type is the data structure representing all the keyed values in a
  * Store.
  *
+ * ```ts override
+ * {[valueId: Id]: Value}
+ * ```
+ *
  * A Values object is used when setting values with the setValues method, and
  * when getting them back out again with the getValues method. A Values object
  * is a regular JavaScript object containing individual Value objects, keyed by
@@ -116,12 +321,19 @@ export type CellOrUndefined = Cell | undefined;
  * @category Store
  * @since v3.0.0
  */
-export type Values = {[valueId: Id]: Value};
+export type Values<
+  Schema extends OptionalValuesSchema = NoValuesSchema,
+  WhenSet extends boolean = false,
+> = ValuesFromSchema<Schema, WhenSet>;
 
 /**
  * The Value type is the data structure representing the data in a single keyed
  * value.
  *
+ * ```ts override
+ * string | number | boolean
+ * ```
+ *
  * A Value is used when setting a value with the setValue method, and when
  * getting it back out again with the getValue method. A Value is a JavaScript
  * string, number, or boolean.
@@ -133,7 +345,10 @@ export type Values = {[valueId: Id]: Value};
  * @category Store
  * @since v3.0.0
  */
-export type Value = string | number | boolean;
+export type Value<
+  Schema extends OptionalValuesSchema = NoValuesSchema,
+  ValueId extends ValueIdFromSchema<Schema> = ValueIdFromSchema<Schema>,
+> = ValueFromSchema<Schema, ValueId>;
 
 /**
  * The ValueOrUndefined type is a data structure representing the data in a
@@ -146,7 +361,11 @@ export type Value = string | number | boolean;
  * @category Store
  * @since v3.0.0
  */
-export type ValueOrUndefined = Value | undefined;
+export type ValueOrUndefined<
+  Schema extends OptionalValuesSchema = NoValuesSchema,
+  ValueId extends ValueIdFromSchema<Schema> = ValueIdFromSchema<Schema>,
+  Value = ValueFromSchema<Schema, ValueId>,
+> = Value | undefined;
 
 /**
  * The TableCallback type describes a function that takes a Table's Id and a
@@ -161,9 +380,12 @@ export type ValueOrUndefined = Value | undefined;
  * in this Table.
  * @category Callback
  */
-export type TableCallback = (
-  tableId: Id,
-  forEachRow: (rowCallback: RowCallback) => void,
+export type TableCallback<
+  Schema extends OptionalTablesSchema = NoTablesSchema,
+  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
+> = (
+  tableId: TableId,
+  forEachRow: (rowCallback: RowCallback<Schema, TableId>) => void,
 ) => void;
 
 /**
@@ -179,9 +401,12 @@ export type TableCallback = (
  * in this Row.
  * @category Callback
  */
-export type RowCallback = (
+export type RowCallback<
+  Schema extends OptionalTablesSchema = NoTablesSchema,
+  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
+> = (
   rowId: Id,
-  forEachCell: (cellCallback: CellCallback) => void,
+  forEachCell: (cellCallback: CellCallback<Schema, TableId>) => void,
 ) => void;
 
 /**
@@ -196,7 +421,14 @@ export type RowCallback = (
  * @param cell The value of the Cell.
  * @category Callback
  */
-export type CellCallback = (cellId: Id, cell: Cell) => void;
+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;
 
 /**
  * The ValueCallback type describes a function that takes a Value's Id and its
@@ -211,7 +443,10 @@ export type CellCallback = (cellId: Id, cell: Cell) => void;
  * @category Callback
  * @since v3.0.0
  */
-export type ValueCallback = (valueId: Id, value: Value) => void;
+export type ValueCallback<
+  Schema extends OptionalValuesSchema = NoValuesSchema,
+  ValueId extends ValueIdFromSchema<Schema> = ValueIdFromSchema<Schema>,
+> = (valueId: ValueId, value: Value<Schema, ValueId>) => void;
 
 /**
  * The MapCell type describes a function that takes an existing Cell value and
@@ -224,7 +459,16 @@ export type ValueCallback = (valueId: Id, value: Value) => void;
  * @param cell The current value of the Cell to map to a new value.
  * @category Callback
  */
-export type MapCell = (cell: CellOrUndefined) => Cell;
+export type MapCell<
+  Schema extends OptionalTablesSchema = NoTablesSchema,
+  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
+  CellId extends CellIdFromSchema<Schema, TableId> = CellIdFromSchema<
+    Schema,
+    TableId
+  >,
+> = (
+  cell: CellOrUndefined<Schema, TableId, CellId>,
+) => Cell<Schema, TableId, CellId>;
 
 /**
  * The MapValue type describes a function that takes an existing Value and
@@ -238,7 +482,10 @@ export type MapCell = (cell: CellOrUndefined) => Cell;
  * @category Callback
  * @since v3.0.0
  */
-export type MapValue = (value: ValueOrUndefined) => Value;
+export type MapValue<
+  Schema extends OptionalValuesSchema = NoValuesSchema,
+  ValueId extends ValueIdFromSchema<Schema> = ValueIdFromSchema<Schema>,
+> = (value: ValueOrUndefined<Schema, ValueId>) => Value<Schema, ValueId>;
 
 /**
  * The GetCell type describes a function that takes a Id and returns the Cell
@@ -251,7 +498,14 @@ export type MapValue = (value: ValueOrUndefined) => Value;
  * @param cellId The Id of the Cell to fetch the value for.
  * @category Callback
  */
-export type GetCell = (cellId: Id) => CellOrUndefined;
+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>;
 
 /**
  * The DoRollback type describes a function that you can use to rollback the
@@ -272,10 +526,14 @@ export type GetCell = (cellId: Id) => CellOrUndefined;
  * @param invalidValues Any invalid attempts to change Values, since v3.0.0.
  * @category Callback
  */
-export type DoRollback = (
-  changedCells: ChangedCells,
+export type DoRollback<
+  Schemas extends OptionalSchemas = NoSchemas,
+  TablesSchema extends OptionalTablesSchema = Schemas[0],
+  ValuesSchema extends OptionalValuesSchema = Schemas[1],
+> = (
+  changedCells: ChangedCells<TablesSchema>,
   invalidCells: InvalidCells,
-  changedValues: ChangedValues,
+  changedValues: ChangedValues<ValuesSchema>,
   invalidValues: InvalidValues,
 ) => boolean;
 
@@ -301,12 +559,12 @@ export type DoRollback = (
  * @param store A reference to the Store that is completing a transaction.
  * @param cellsTouched Whether Cell values have been touched during the
  * transaction.
- * @param valuesTouched Whether Values have been touched during the
- * transaction, since v3.0.0.
+ * @param valuesTouched Whether Values have been touched during the transaction,
+ * since v3.0.0.
  * @category Listener
  */
-export type TransactionListener = (
-  store: Store,
+export type TransactionListener<Schemas extends OptionalSchemas = NoSchemas> = (
+  store: Store<Schemas>,
   cellsTouched: boolean,
   valuesTouched: boolean,
 ) => void;
@@ -331,9 +589,12 @@ export type TransactionListener = (
  * changes.
  * @category Listener
  */
-export type TablesListener = (
-  store: Store,
-  getCellChange: GetCellChange | undefined,
+export type TablesListener<
+  Schemas extends OptionalSchemas = NoSchemas,
+  TablesSchema extends OptionalTablesSchema = Schemas[0],
+> = (
+  store: Store<Schemas>,
+  getCellChange: GetCellChange<TablesSchema> | undefined,
 ) => void;
 
 /**
@@ -348,7 +609,9 @@ export type TablesListener = (
  * @param store A reference to the Store that changed.
  * @category Listener
  */
-export type TableIdsListener = (store: Store) => void;
+export type TableIdsListener<Schemas extends OptionalSchemas = NoSchemas> = (
+  store: Store<Schemas>,
+) => void;
 
 /**
  * The TableListener type describes a function that is used to listen to changes
@@ -371,10 +634,19 @@ export type TableIdsListener = (store: Store) => void;
  * changes.
  * @category Listener
  */
-export type TableListener = (
-  store: Store,
-  tableId: Id,
-  getCellChange: GetCellChange | undefined,
+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],
+> = (
+  store: Store<Schemas>,
+  tableId: TableId,
+  getCellChange: GetCellChange<TablesSchema> | undefined,
 ) => void;
 
 /**
@@ -391,7 +663,15 @@ export type TableListener = (
  * @param tableId The Id of the Table that changed.
  * @category Listener
  */
-export type RowIdsListener = (store: Store, tableId: Id) => void;
+export type RowIdsListener<
+  Schemas extends OptionalSchemas = NoSchemas,
+  TableIdOrNull extends TableIdFromSchema<
+    Schemas[0]
+  > | null = TableIdFromSchema<Schemas[0]> | null,
+  TableId = TableIdOrNull extends null
+    ? TableIdFromSchema<Schemas[0]>
+    : TableIdOrNull,
+> = (store: Store<Schemas>, tableId: TableId) => void;
 
 /**
  * The SortedRowIdsListener type describes a function that is used to listen to
@@ -417,13 +697,22 @@ export type RowIdsListener = (store: Store, tableId: Id) => void;
  * @category Listener
  * @since v2.0.0
  */
-export type SortedRowIdsListener = (
-  store: Store,
-  tableId: Id,
-  cellId: Id | undefined,
-  descending: boolean,
-  offset: number,
-  limit: number | undefined,
+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,
+> = (
+  store: Store<Schemas>,
+  tableId: TableId,
+  cellId: CellId,
+  descending: Descending,
+  offset: Offset,
+  limit: Limit,
   sortedRowIds: Ids,
 ) => void;
 
@@ -450,11 +739,22 @@ export type SortedRowIdsListener = (
  * changes.
  * @category Listener
  */
-export type RowListener = (
-  store: Store,
-  tableId: Id,
-  rowId: Id,
-  getCellChange: GetCellChange | undefined,
+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],
+> = (
+  store: Store<Schemas>,
+  tableId: TableId,
+  rowId: RowId,
+  getCellChange: GetCellChange<TablesSchema> | undefined,
 ) => void;
 
 /**
@@ -472,7 +772,17 @@ export type RowListener = (
  * @param rowId The Id of the Row that changed.
  * @category Listener
  */
-export type CellIdsListener = (store: Store, tableId: Id, rowId: Id) => void;
+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
+    ? TableIdFromSchema<Schemas[0]>
+    : TableIdOrNull,
+  RowId = RowIdOrNull extends null ? Id : RowIdOrNull,
+> = (store: Store<Schemas>, tableId: TableId, rowId: RowId) => void;
 
 /**
  * The CellListener type describes a function that is used to listen to changes
@@ -502,14 +812,40 @@ export type CellIdsListener = (store: Store, tableId: Id, rowId: Id) => void;
  * changes.
  * @category Listener
  */
-export type CellListener = (
-  store: Store,
-  tableId: Id,
-  rowId: Id,
-  cellId: Id,
+export type CellListener<
+  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,
+  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 | undefined,
+  getCellChange: GetCellChange<TablesSchema> | undefined,
 ) => void;
 
 /**
@@ -532,9 +868,12 @@ export type CellListener = (
  * changes.
  * @category Listener
  */
-export type ValuesListener = (
-  store: Store,
-  getValueChange: GetValueChange | undefined,
+export type ValuesListener<
+  Schemas extends OptionalSchemas = NoSchemas,
+  ValuesSchema extends OptionalValuesSchema = Schemas[1],
+> = (
+  store: Store<Schemas>,
+  getValueChange: GetValueChange<ValuesSchema> | undefined,
 ) => void;
 
 /**
@@ -549,7 +888,9 @@ export type ValuesListener = (
  * @param store A reference to the Store that changed.
  * @category Listener
  */
-export type ValueIdsListener = (store: Store) => void;
+export type ValueIdsListener<Schemas extends OptionalSchemas = NoSchemas> = (
+  store: Store<Schemas>,
+) => void;
 
 /**
  * The ValueListener type describes a function that is used to listen to changes
@@ -577,12 +918,22 @@ export type ValueIdsListener = (store: Store) => void;
  * @category Listener
  * @since v3.0.0
  */
-export type ValueListener = (
-  store: Store,
-  valueId: Id,
+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 | undefined,
+  getValueChange: GetValueChange<ValuesSchema> | undefined,
 ) => void;
 
 /**
@@ -607,8 +958,8 @@ export type ValueListener = (
  * @category Listener
  * @since v1.1.0
  */
-export type InvalidCellListener = (
-  store: Store,
+export type InvalidCellListener<Schemas extends OptionalSchemas = NoSchemas> = (
+  store: Store<Schemas>,
   tableId: Id,
   rowId: Id,
   cellId: Id,
@@ -635,11 +986,8 @@ export type InvalidCellListener = (
  * @category Listener
  * @since v3.0.0
  */
-export type InvalidValueListener = (
-  store: Store,
-  valueId: Id,
-  invalidValues: any[],
-) => void;
+export type InvalidValueListener<Schemas extends OptionalSchemas = NoSchemas> =
+  (store: Store<Schemas>, valueId: Id, invalidValues: any[]) => void;
 
 /**
  * The GetCellChange type describes a function that returns information about
@@ -656,7 +1004,16 @@ export type InvalidValueListener = (
  * @returns A CellChange array containing information about the Cell's changes.
  * @category Listener
  */
-export type GetCellChange = (tableId: Id, rowId: Id, cellId: Id) => CellChange;
+export type GetCellChange<
+  Schema extends OptionalTablesSchema = NoTablesSchema,
+> = <
+  TableId extends TableIdFromSchema<Schema>,
+  CellId extends CellIdFromSchema<Schema, TableId>,
+>(
+  tableId: TableId,
+  rowId: Id,
+  cellId: CellId,
+) => CellChange<Schema, TableId, CellId>;
 
 /**
  * The CellChange type describes a Cell's changes during a transaction.
@@ -668,11 +1025,15 @@ export type GetCellChange = (tableId: Id, rowId: Id, cellId: Id) => CellChange;
  *
  * @category Listener
  */
-export type CellChange = [
-  changed: boolean,
-  oldCell: CellOrUndefined,
-  newCell: CellOrUndefined,
-];
+export type CellChange<
+  Schema extends OptionalTablesSchema = NoTablesSchema,
+  TableId extends TableIdFromSchema<Schema> = TableIdFromSchema<Schema>,
+  CellId extends CellIdFromSchema<Schema, TableId> = CellIdFromSchema<
+    Schema,
+    TableId
+  >,
+  CellOrUndefined = Cell<Schema, TableId, CellId> | undefined,
+> = [changed: boolean, oldCell: CellOrUndefined, newCell: CellOrUndefined];
 
 /**
  * The GetValueChange type describes a function that returns information about
@@ -688,7 +1049,11 @@ export type CellChange = [
  * changes.
  * @category Listener
  */
-export type GetValueChange = (valueId: Id) => ValueChange;
+export type GetValueChange<
+  Schema extends OptionalValuesSchema = NoValuesSchema,
+> = <ValueId extends ValueIdFromSchema<Schema>>(
+  valueId: ValueId,
+) => ValueChange<Schema, ValueId>;
 
 /**
  * The ValueChange type describes a Value's changes during a transaction.
@@ -700,128 +1065,27 @@ export type GetValueChange = (valueId: Id) => ValueChange;
  *
  * @category Listener
  */
-export type ValueChange = [
-  changed: boolean,
-  oldValue: ValueOrUndefined,
-  newValue: ValueOrUndefined,
-];
-
-/**
- * The TablesSchema type describes the tabular structure of a Store in terms of
- * valid Table Ids and the types of Cell that can exist within them.
- *
- * A TablesSchema comprises a JavaScript object describing each Table, in turn a
- * nested JavaScript object containing information about each Cell and its
- * CellSchema. It is provided to the setTablesSchema method.
- *
- * @example
- * When applied to a Store, this TablesSchema only allows one Table called
- * `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
- * const tableSchema: TablesSchema = {
- *   pets: {
- *     species: {type: 'string'},
- *     sold: {type: 'boolean', default: false},
- *   },
- * };
- * ```
- * @category Schema
- */
-export type TablesSchema = {
-  [tableId: Id]: {
-    [cellId: Id]: CellSchema;
-  };
-};
-
-/**
- * The CellSchema type describes what values are allowed for each Cell in a
- * Table.
- *
- * A CellSchema specifies the type of the Cell (`string`, `boolean`, or
- * `number`), and what the default value can be when an explicit value is not
- * specified.
- *
- * If a default value is provided (and its type is correct), you can be certain
- * that that Cell will always be present in a Row.
- *
- * If the default value is _not_ provided (or its type is incorrect), the Cell
- * may be missing from the Row, but when present you can be guaranteed it is of
- * the correct type.
- *
- * @example
- * When applied to a Store, this CellSchema ensures a boolean Cell is always
- * present, and defaults it to `false`.
- *
- *```js
- * const requiredBoolean: CellSchema = {type: 'boolean', default: false};
- * ```
- * @category Schema
- */
-export type CellSchema =
-  | {type: 'string'; default?: string}
-  | {type: 'number'; default?: number}
-  | {type: 'boolean'; default?: boolean};
-
-/**
- * The ValuesSchema type describes the keyed Values that can be set in a Store
- * and their types.
- *
- * A ValuesSchema comprises a JavaScript object describing each Value and its
- * ValueSchema. It is provided to the setValuesSchema method.
- *
- * @example
- * When applied to a Store, this ValuesSchema only allows one boolean Value
- * called `open`, that defaults to `false`.
- *
- *```js
- * const valuesSchema: ValuesSchema = {
- *   open: {type: 'boolean', default: false},
- * };
- * ```
- * @category Schema
- * @since v3.0.0
- */
-export type ValuesSchema = {
-  [valueId: Id]: ValueSchema;
-};
-
-/**
- * The ValueSchema type describes what values are allowed for keyed Values in a
- * Store.
- *
- * A ValueSchema specifies the type of the Value (`string`, `boolean`, or
- * `number`), and what the default value can be when an explicit value is not
- * specified.
- *
- * If a default value is provided (and its type is correct), you can be certain
- * that the Value will always be present in a Store.
- *
- * If the default value is _not_ provided (or its type is incorrect), the Value
- * may not be present in the Store, but when present you can be guaranteed it is
- * of the correct type.
- *
- * @example
- * When applied to a Store, this ValueSchema ensures a boolean Value is always
- * present, and defaults it to `false`.
- *
- *```js
- * const requiredBoolean: ValueSchema = {type: 'boolean', default: false};
- * ```
- * @category Schema
- * @since v3.0.0
- */
-export type ValueSchema =
-  | {type: 'string'; default?: string}
-  | {type: 'number'; default?: number}
-  | {type: 'boolean'; default?: boolean};
+export type ValueChange<
+  Schema extends OptionalValuesSchema = NoValuesSchema,
+  ValueId extends ValueIdFromSchema<Schema> = ValueIdFromSchema<Schema>,
+  ValueOrUndefined = Value<Schema, ValueId> | undefined,
+> = [changed: boolean, oldValue: ValueOrUndefined, newValue: ValueOrUndefined];
 
 /**
  * The ChangedCells type describes the Cell values that have been changed during
  * a transaction, primarily used so that you can indicate whether the
  * transaction should be rolled back.
  *
+ * ```ts override
+ * {
+ *   [tableId: Id]: {
+ *     [rowId: Id]: {
+ *       [cellId: Id]: [CellOrUndefined, CellOrUndefined],
+ *     },
+ *   },
+ * }
+ * ```
+ *
  * A ChangedCells object is provided to the `doRollback` callback when using the
  * transaction method and the finishTransaction method. See those methods for
  * specific examples.
@@ -842,13 +1106,17 @@ export type ValueSchema =
  * @category Transaction
  * @since v1.2.0
  */
-export type ChangedCells = {
-  [tableId: Id]: {
-    [rowId: Id]: {
-      [cellId: Id]: [CellOrUndefined, CellOrUndefined];
+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>,
+        ];
+      };
     };
   };
-};
 
 /**
  * The InvalidCells type describes the invalid Cell values that have been
@@ -880,6 +1148,10 @@ export type InvalidCells = {
  * transaction, primarily used so that you can indicate whether the transaction
  * should be rolled back.
  *
+ * ```ts override
+ * {[valueId: Id]: [ValueOrUndefined, ValueOrUndefined]}
+ * ```
+ *
  * A ChangedValues object is provided to the `doRollback` callback when using
  * the transaction method and the finishTransaction method. See those methods
  * for specific examples.
@@ -899,8 +1171,13 @@ export type InvalidCells = {
  * @category Transaction
  * @since v3.0.0
  */
-export type ChangedValues = {
-  [valueId: Id]: [ValueOrUndefined, ValueOrUndefined];
+export type ChangedValues<
+  Schema extends OptionalValuesSchema = NoValuesSchema,
+> = {
+  [ValueId in ValueIdFromSchema<Schema>]?: [
+    ValueOrUndefined<Schema, ValueId>,
+    ValueOrUndefined<Schema, ValueId>,
+  ];
 };
 /**
  * The InvalidValues type describes the invalid Values that have been attempted
@@ -1125,9 +1402,16 @@ export type StoreListenerStats = {
  * requires its type to be specified, and can also take a default value for when
  * it's not specified.
  *
- * You can also get a serialization of the schemas out of the Store with
- * the getSchemaJson method, and remove the schemas altogether with
- * the delValuesSchema method and delTablesSchema method.
+ * You can also get a serialization of the schemas out of the Store with the
+ * 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.
  *
@@ -1175,7 +1459,7 @@ export type StoreListenerStats = {
  * @see Todo App demos
  * @category Store
  */
-export interface Store {
+export interface Store<Schemas extends OptionalSchemas = NoSchemas> {
   /**
    * The getTables method returns a Tables object containing the entire data of
    * the Store.
@@ -1211,7 +1495,7 @@ export interface Store {
    * @see Indexes
    * @category Getter
    */
-  getTables(): Tables;
+  getTables<Tables = TablesFromSchema<Schemas[0]>>(): Tables;
 
   /**
    * The getTableIds method returns the Ids of every Table in the Store.
@@ -1242,7 +1526,7 @@ export interface Store {
    * ```
    * @category Getter
    */
-  getTableIds(): Ids;
+  getTableIds<Ids = TableIdFromSchema<Schemas[0]>[]>(): Ids;
 
   /**
    * The getTable method returns an object containing the entire data of a
@@ -1276,7 +1560,12 @@ export interface Store {
    * ```
    * @category Getter
    */
-  getTable(tableId: Id): Table;
+  getTable<
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    Table = TableFromSchema<Schemas[0]>,
+  >(
+    tableId: TableId,
+  ): Table;
 
   /**
    * The getRowIds method returns the Ids of every Row in a given Table.
@@ -1310,7 +1599,9 @@ export interface Store {
    * ```
    * @category Getter
    */
-  getRowIds(tableId: Id): Ids;
+  getRowIds<TableId extends TableIdFromSchema<Schemas[0]>>(
+    tableId: TableId,
+  ): Ids;
 
   /**
    * The getSortedRowIds method returns the Ids of every Row in a given Table,
@@ -1411,9 +1702,12 @@ export interface Store {
    * @category Getter
    * @since v2.0.0
    */
-  getSortedRowIds(
-    tableId: Id,
-    cellId?: Id,
+  getSortedRowIds<
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    CellId extends CellIdFromSchema<Schemas[0], TableId>,
+  >(
+    tableId: TableId,
+    cellId?: CellId,
     descending?: boolean,
     offset?: number,
     limit?: number,
@@ -1454,7 +1748,13 @@ export interface Store {
    * ```
    * @category Getter
    */
-  getRow(tableId: Id, rowId: Id): Row;
+  getRow<
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    Row = RowFromSchema<Schemas[0], TableId>,
+  >(
+    tableId: TableId,
+    rowId: Id,
+  ): Row;
 
   /**
    * The getCellIds method returns the Ids of every Cell in a given Row, in a
@@ -1489,7 +1789,13 @@ export interface Store {
    * ```
    * @category Getter
    */
-  getCellIds(tableId: Id, rowId: Id): Ids;
+  getCellIds<
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    Ids extends CellIdFromSchema<Schemas[0], TableId>[],
+  >(
+    tableId: TableId,
+    rowId: Id,
+  ): Ids;
 
   /**
    * The getCell method returns the value of a single Cell in a given Row, in a
@@ -1519,7 +1825,15 @@ export interface Store {
    * ```
    * @category Getter
    */
-  getCell(tableId: Id, rowId: Id, cellId: Id): CellOrUndefined;
+  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;
 
   /**
    * The getValues method returns an object containing the entire set of keyed
@@ -1550,7 +1864,7 @@ export interface Store {
    * @category Getter
    * @since v3.0.0
    */
-  getValues(): Values;
+  getValues<Values = ValuesFromSchema<Schemas[1]>>(): Values;
 
   /**
    * The getValueIds method returns the Ids of every Value in a Store.
@@ -1579,7 +1893,7 @@ export interface Store {
    * @category Getter
    * @since v3.0.0
    */
-  getValueIds(): Ids;
+  getValueIds<Ids = ValueIdFromSchema<Schemas[1]>[]>(): Ids;
 
   /**
    * The getValue method returns a single keyed Value in the Store.
@@ -1605,7 +1919,12 @@ export interface Store {
    * @category Getter
    * @since v3.0.0
    */
-  getValue(valueId: Id): ValueOrUndefined;
+  getValue<
+    ValueId extends ValueIdFromSchema<Schemas[1]>,
+    ValueOrUndefined = ValueFromSchema<Schemas[1], ValueId> | undefined,
+  >(
+    valueId: ValueId,
+  ): ValueOrUndefined;
 
   /**
    * The hasTables method returns a boolean indicating whether any Table objects
@@ -1645,7 +1964,9 @@ export interface Store {
    * ```
    * @category Getter
    */
-  hasTable(tableId: Id): boolean;
+  hasTable<TableId extends TableIdFromSchema<Schemas[0]>>(
+    tableId: TableId,
+  ): boolean;
 
   /**
    * The hasRow method returns a boolean indicating whether a given Row exists
@@ -1666,7 +1987,10 @@ export interface Store {
    * ```
    * @category Getter
    */
-  hasRow(tableId: Id, rowId: Id): boolean;
+  hasRow<TableId extends TableIdFromSchema<Schemas[0]>>(
+    tableId: TableId,
+    rowId: Id,
+  ): boolean;
 
   /**
    * The hasCell method returns a boolean indicating whether a given Cell exists
@@ -1688,7 +2012,14 @@ export interface Store {
    * ```
    * @category Getter
    */
-  hasCell(tableId: Id, rowId: Id, cellId: Id): boolean;
+  hasCell<
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    CellId extends CellIdFromSchema<Schemas[0], TableId>,
+  >(
+    tableId: TableId,
+    rowId: Id,
+    cellId: CellId,
+  ): boolean;
 
   /**
    * The hasTables method returns a boolean indicating whether any Values exist
@@ -1730,7 +2061,9 @@ export interface Store {
    * @category Getter
    * @since v3.0.0
    */
-  hasValue(valueId: Id): boolean;
+  hasValue<ValueId extends ValueIdFromSchema<Schemas[1]>>(
+    valueId: ValueId,
+  ): boolean;
 
   /**
    * The getTablesJson method returns a string serialization of all of the
@@ -1759,8 +2092,8 @@ export interface Store {
   getTablesJson(): Json;
 
   /**
-   * The getValuesJson method returns a string serialization of all of the
-   * keyed Values in the Store.
+   * The getValuesJson method returns a string serialization of all of the keyed
+   * Values in the Store.
    *
    * @returns A string serialization of all of the Values in the Store.
    * @example
@@ -1969,7 +2302,9 @@ export interface Store {
    * ```
    * @category Setter
    */
-  setTables(tables: Tables): Store;
+  setTables<Tables = TablesFromSchema<Schemas[0], true>>(
+    tables: Tables,
+  ): Store<Schemas>;
 
   /**
    * The setTable method takes an object and sets the entire data of a single
@@ -2020,7 +2355,13 @@ export interface Store {
    * ```
    * @category Setter
    */
-  setTable(tableId: Id, table: Table): Store;
+  setTable<
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    Table = TableFromSchema<Schemas[0], TableId, true>,
+  >(
+    tableId: TableId,
+    table: Table,
+  ): Store<Schemas>;
 
   /**
    * The setRow method takes an object and sets the entire data of a single Row
@@ -2070,7 +2411,14 @@ export interface Store {
    * ```
    * @category Setter
    */
-  setRow(tableId: Id, rowId: Id, row: Row): Store;
+  setRow<
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    Row = RowFromSchema<Schemas[0], TableId, true>,
+  >(
+    tableId: TableId,
+    rowId: Id,
+    row: Row,
+  ): Store<Schemas>;
 
   /**
    * The addRow method takes an object and creates a new Row in the Store,
@@ -2123,7 +2471,13 @@ export interface Store {
    * ```
    * @category Setter
    */
-  addRow(tableId: Id, row: Row): Id | undefined;
+  addRow<
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    Row = RowFromSchema<Schemas[0], TableId, true>,
+  >(
+    tableId: TableId,
+    row: Row,
+  ): Id | undefined;
 
   /**
    * The setPartialRow method takes an object and sets partial data of a single
@@ -2175,7 +2529,14 @@ export interface Store {
    * ```
    * @category Setter
    */
-  setPartialRow(tableId: Id, rowId: Id, partialRow: Row): Store;
+  setPartialRow<
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    Row = RowFromSchema<Schemas[0], TableId, true>,
+  >(
+    tableId: TableId,
+    rowId: Id,
+    partialRow: Row,
+  ): Store<Schemas>;
 
   /**
    * The setCell method sets the value of a single Cell in the Store.
@@ -2233,7 +2594,17 @@ export interface Store {
    * ```
    * @category Setter
    */
-  setCell(tableId: Id, rowId: Id, cellId: Id, cell: Cell | MapCell): Store;
+  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,
+  ): Store<Schemas>;
 
   /**
    * The setValues method takes an object and sets all the Values in the Store.
@@ -2281,7 +2652,9 @@ export interface Store {
    * @category Setter
    * @since v3.0.0
    */
-  setValues(values: Values): Store;
+  setValues<Values = ValuesFromSchema<Schemas[1], true>>(
+    values: Values,
+  ): Store<Schemas>;
 
   /**
    * The setPartialValues method takes an object and sets its Values in the
@@ -2331,7 +2704,9 @@ export interface Store {
    * @category Setter
    * @since v3.0.0
    */
-  setPartialValues(partialValues: Values): Store;
+  setPartialValues<Values = ValuesFromSchema<Schemas[1], true>>(
+    partialValues: Values,
+  ): Store<Schemas>;
 
   /**
    * The setValue method sets a single keyed Value in the Store.
@@ -2385,7 +2760,14 @@ export interface Store {
    * @category Setter
    * @since v3.0.0
    */
-  setValue(valueId: Id, value: Value | MapValue): Store;
+  setValue<
+    ValueId extends ValueIdFromSchema<Schemas[1]>,
+    Value = ValueFromSchema<Schemas[1], ValueId>,
+    MapValue = (value: Value | undefined) => Value,
+  >(
+    valueId: ValueId,
+    value: Value | MapValue,
+  ): Store<Schemas>;
 
   /**
    * The setTablesJson method takes a string serialization of all of the Tables
@@ -2420,7 +2802,7 @@ export interface Store {
    * @category Setter
    * @since v3.0.0
    */
-  setTablesJson(tablesJson: Json): Store;
+  setTablesJson(tablesJson: Json): Store<Schemas>;
 
   /**
    * The setValuesJson method takes a string serialization of all of the Values
@@ -2455,7 +2837,7 @@ export interface Store {
    * @category Setter
    * @since v3.0.0
    */
-  setValuesJson(valuesJson: Json): Store;
+  setValuesJson(valuesJson: Json): Store<Schemas>;
 
   /**
    * The setJson method takes a string serialization of all of the Tables and
@@ -2514,16 +2896,24 @@ export interface Store {
    * ```
    * @category Setter
    */
-  setJson(tablesAndValuesJson: Json): Store;
+  setJson(tablesAndValuesJson: Json): Store<Schemas>;
 
   /**
    * The setTablesSchema method lets you specify the TablesSchema of the tabular
    * part of the Store.
    *
+   * ```ts override
+   * setTablesSchema(tablesSchema: TablesSchema): Store<Schemas>
+   * ```
+   *
    * 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.
    *
@@ -2547,16 +2937,29 @@ export interface Store {
    * @category Setter
    * @since v3.0.0
    */
-  setTablesSchema(tablesSchema: TablesSchema): Store;
+  setTablesSchema<
+    TablesSchema extends TablesSchemaAlias,
+    ValuesSchema extends OptionalValuesSchema = Schemas[1],
+  >(
+    tablesSchema: TablesSchema,
+  ): Store<[typeof tablesSchema, ValuesSchema]>;
 
   /**
    * The setValuesSchema method lets you specify the ValuesSchema of the keyed
    * Values part of the Store.
    *
+   * ```ts override
+   * setValuesSchema(valuesSchema: ValuesSchema): Store<Schemas>
+   * ```
+   *
    * 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.
    *
@@ -2577,16 +2980,32 @@ export interface Store {
    * @category Setter
    * @since v3.0.0
    */
-  setValuesSchema(valuesSchema: ValuesSchema): Store;
+  setValuesSchema<
+    ValuesSchema extends ValuesSchemaAlias,
+    TablesSchema extends OptionalTablesSchema = Schemas[0],
+  >(
+    valuesSchema: ValuesSchema,
+  ): Store<[TablesSchema, typeof valuesSchema]>;
 
   /**
    * The setSchema method lets you specify the TablesSchema and ValuesSchema of
    * the Store.
    *
+   * ```ts override
+   * setSchema(
+   *   tablesSchema: TablesSchema,
+   *   valuesSchema?: ValuesSchema,
+   * ): Store<Schemas>
+   * ```
+   *
    * 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
@@ -2636,7 +3055,20 @@ export interface Store {
    * ```
    * @category Setter
    */
-  setSchema(tablesSchema: TablesSchema, valuesSchema?: ValuesSchema): Store;
+  setSchema<
+    TablesSchema extends TablesSchemaAlias,
+    ValuesSchema extends ValuesSchemaAlias,
+  >(
+    tablesSchema: TablesSchema,
+    valuesSchema?: ValuesSchema,
+  ): Store<
+    [
+      typeof tablesSchema,
+      Exclude<ValuesSchemaAlias, typeof valuesSchema> extends never
+        ? NoValuesSchema
+        : NonNullable<typeof valuesSchema>,
+    ]
+  >;
 
   /**
    * The delTables method lets you remove all of the data in a Store.
@@ -2654,7 +3086,7 @@ export interface Store {
    * ```
    * @category Deleter
    */
-  delTables(): Store;
+  delTables(): Store<Schemas>;
 
   /**
    * The delTable method lets you remove a single Table from the Store.
@@ -2676,7 +3108,9 @@ export interface Store {
    * ```
    * @category Deleter
    */
-  delTable(tableId: Id): Store;
+  delTable<TableId extends TableIdFromSchema<Schemas[0]>>(
+    tableId: TableId,
+  ): Store<Schemas>;
 
   /**
    * The delRow method lets you remove a single Row from a Table.
@@ -2700,7 +3134,10 @@ export interface Store {
    * ```
    * @category Deleter
    */
-  delRow(tableId: Id, rowId: Id): Store;
+  delRow<TableId extends TableIdFromSchema<Schemas[0]>>(
+    tableId: TableId,
+    rowId: Id,
+  ): Store<Schemas>;
 
   /**
    * The delCell method lets you remove a single Cell from a Row.
@@ -2784,7 +3221,15 @@ export interface Store {
    * ```
    * @category Deleter
    */
-  delCell(tableId: Id, rowId: Id, cellId: Id, forceDel?: boolean): Store;
+  delCell<
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    CellId extends CellIdFromSchema<Schemas[0], TableId>,
+  >(
+    tableId: TableId,
+    rowId: Id,
+    cellId: CellId,
+    forceDel?: boolean,
+  ): Store<Schemas>;
 
   /**
    * The delValues method lets you remove all the Values from a Store.
@@ -2823,7 +3268,7 @@ export interface Store {
    * @category Deleter
    * @since v3.0.0
    */
-  delValues(): Store;
+  delValues(): Store<Schemas>;
 
   /**
    * The delValue method lets you remove a single Value from a Store.
@@ -2863,7 +3308,9 @@ export interface Store {
    * @category Deleter
    * @since v3.0.0
    */
-  delValue(valueId: Id): Store;
+  delValue<ValueId extends ValueIdFromSchema<Schemas[1]>>(
+    valueId: ValueId,
+  ): Store<Schemas>;
 
   /**
    * The delTablesSchema method lets you remove the TablesSchema of the Store.
@@ -2882,7 +3329,9 @@ export interface Store {
    * ```
    * @category Deleter
    */
-  delTablesSchema(): Store;
+  delTablesSchema<
+    ValuesSchema extends OptionalValuesSchema = Schemas[1],
+  >(): Store<[NoTablesSchema, ValuesSchema]>;
 
   /**
    * The delValuesSchema method lets you remove the ValuesSchema of the Store.
@@ -2902,7 +3351,9 @@ export interface Store {
    * @category Deleter
    * @since v3.0.0
    */
-  delValuesSchema(): Store;
+  delValuesSchema<
+    TablesSchema extends OptionalTablesSchema = Schemas[0],
+  >(): Store<[TablesSchema, NoValuesSchema]>;
 
   /**
    * The delSchema method lets you remove both the TablesSchema and ValuesSchema
@@ -2929,7 +3380,7 @@ export interface Store {
    * @category Deleter
    * @since v3.0.0
    */
-  delSchema(): Store;
+  delSchema(): Store<NoSchemas>;
 
   /**
    * The transaction method takes a function that makes multiple mutations to
@@ -3057,7 +3508,10 @@ export interface Store {
    * ```
    * @category Transaction
    */
-  transaction<Return>(actions: () => Return, doRollback?: DoRollback): Return;
+  transaction<Return>(
+    actions: () => Return,
+    doRollback?: DoRollback<Schemas>,
+  ): Return;
 
   /**
    * The startTransaction method allows you to explicitly start a transaction
@@ -3108,7 +3562,7 @@ export interface Store {
    * @category Transaction
    * @since v1.3.0
    */
-  startTransaction(): Store;
+  startTransaction(): Store<Schemas>;
 
   /**
    * The finishTransaction method allows you to explicitly finish a transaction
@@ -3132,8 +3586,8 @@ export interface Store {
    * been a corresponding startTransaction method that this completes, of
    * course, otherwise this function has no effect.
    *
-   * The optional parameter, `doRollback` is a DoRollback callback that
-   * you can use to rollback the transaction if it did not complete to your
+   * The optional parameter, `doRollback` is a DoRollback callback that you can
+   * use to rollback the transaction if it did not complete to your
    * satisfaction. It is called with `changedCells`, `invalidCells`,
    * `changedValues`, and `invalidValues` parameters, which inform you of the
    * net changes that have been made during the transaction, and any invalid
@@ -3206,7 +3660,7 @@ export interface Store {
    * @category Transaction
    * @since v1.3.0
    */
-  finishTransaction(doRollback?: DoRollback): Store;
+  finishTransaction(doRollback?: DoRollback<Schemas>): Store<Schemas>;
 
   /**
    * The forEachTable method takes a function that it will then call for each
@@ -3239,7 +3693,9 @@ export interface Store {
    * ```
    * @category Iterator
    */
-  forEachTable(tableCallback: TableCallback): void;
+  forEachTable<TableCallback = TableCallbackAlias<Schemas[0]>>(
+    tableCallback: TableCallback,
+  ): void;
 
   /**
    * The forEachRow method takes a function that it will then call for each Row
@@ -3274,7 +3730,13 @@ export interface Store {
    * ```
    * @category Iterator
    */
-  forEachRow(tableId: Id, rowCallback: RowCallback): void;
+  forEachRow<
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    RowCallback = RowCallbackAlias<Schemas[0], TableId>,
+  >(
+    tableId: TableId,
+    rowCallback: RowCallback,
+  ): void;
 
   /**
    * The forEachCell method takes a function that it will then call for each
@@ -3302,7 +3764,14 @@ export interface Store {
    * ```
    * @category Iterator
    */
-  forEachCell(tableId: Id, rowId: Id, cellCallback: CellCallback): void;
+  forEachCell<
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    CellCallback = CellCallbackAlias<Schemas[0], TableId>,
+  >(
+    tableId: TableId,
+    rowId: Id,
+    cellCallback: CellCallback,
+  ): void;
 
   /**
    * The forEachValue method takes a function that it will then call for each
@@ -3327,7 +3796,9 @@ export interface Store {
    * @category Iterator
    * @since v3.0.0
    */
-  forEachValue(valueCallback: ValueCallback): void;
+  forEachValue<ValueCallback = ValueCallbackAlias<Schemas[1]>>(
+    valueCallback: ValueCallback,
+  ): void;
 
   /**
    * The addTablesListener method registers a listener function with the Store
@@ -3391,7 +3862,7 @@ export interface Store {
    * ```
    * @category Listener
    */
-  addTablesListener(listener: TablesListener, mutator?: boolean): Id;
+  addTablesListener(listener: TablesListener<Schemas>, mutator?: boolean): Id;
 
   /**
    * The addTableIdsListener method registers a listener function with the Store
@@ -3454,7 +3925,10 @@ export interface Store {
    * ```
    * @category Listener
    */
-  addTableIdsListener(listener: TableIdsListener, mutator?: boolean): Id;
+  addTableIdsListener(
+    listener: TableIdsListener<Schemas>,
+    mutator?: boolean,
+  ): Id;
 
   /**
    * The addTableListener method registers a listener function with the Store
@@ -3547,9 +4021,9 @@ export interface Store {
    * ```
    * @category Listener
    */
-  addTableListener(
-    tableId: IdOrNull,
-    listener: TableListener,
+  addTableListener<TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null>(
+    tableId: TableIdOrNull,
+    listener: TableListener<Schemas, TableIdOrNull>,
     mutator?: boolean,
   ): Id;
 
@@ -3639,9 +4113,9 @@ export interface Store {
    * ```
    * @category Listener
    */
-  addRowIdsListener(
-    tableId: IdOrNull,
-    listener: RowIdsListener,
+  addRowIdsListener<TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null>(
+    tableId: TableIdOrNull,
+    listener: RowIdsListener<Schemas, TableIdOrNull>,
     mutator?: boolean,
   ): Id;
 
@@ -3861,13 +4335,26 @@ export interface Store {
    * @category Listener
    * @since v2.0.0
    */
-  addSortedRowIdsListener(
-    tableId: Id,
-    cellId: Id | undefined,
-    descending: boolean,
-    offset: number,
-    limit: number | undefined,
-    listener: SortedRowIdsListener,
+  addSortedRowIdsListener<
+    TableId extends TableIdFromSchema<Schemas[0]>,
+    CellId extends CellIdFromSchema<Schemas[0], TableId> | undefined,
+    Descending extends boolean,
+    Offset extends number,
+    Limit extends number | undefined,
+  >(
+    tableId: TableId,
+    cellId: CellId,
+    descending: Descending,
+    offset: Offset,
+    limit: Limit,
+    listener: SortedRowIdsListener<
+      Schemas,
+      TableId,
+      CellId,
+      Descending,
+      Offset,
+      Limit
+    >,
     mutator?: boolean,
   ): Id;
 
@@ -3974,10 +4461,13 @@ export interface Store {
    * ```
    * @category Listener
    */
-  addRowListener(
-    tableId: IdOrNull,
-    rowId: IdOrNull,
-    listener: RowListener,
+  addRowListener<
+    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+    RowIdOrNull extends IdOrNull,
+  >(
+    tableId: TableIdOrNull,
+    rowId: RowIdOrNull,
+    listener: RowListener<Schemas, TableIdOrNull, RowIdOrNull>,
     mutator?: boolean,
   ): Id;
 
@@ -4080,10 +4570,13 @@ export interface Store {
    * ```
    * @category Listener
    */
-  addCellIdsListener(
-    tableId: IdOrNull,
-    rowId: IdOrNull,
-    listener: CellIdsListener,
+  addCellIdsListener<
+    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+    RowIdOrNull extends IdOrNull,
+  >(
+    tableId: TableIdOrNull,
+    rowId: RowIdOrNull,
+    listener: CellIdsListener<Schemas, TableIdOrNull, RowIdOrNull>,
     mutator?: boolean,
   ): Id;
 
@@ -4199,10 +4692,24 @@ export interface Store {
    * ```
    * @category Listener
    */
-  addCellListener(
-    tableId: IdOrNull,
-    rowId: IdOrNull,
-    cellId: IdOrNull,
+  addCellListener<
+    TableIdOrNull extends TableIdFromSchema<Schemas[0]> | null,
+    RowIdOrNull extends IdOrNull,
+    CellIdOrNull extends
+      | (TableIdOrNull extends TableIdFromSchema<Schemas[0]>
+          ? CellIdFromSchema<Schemas[0], TableIdOrNull>
+          : AllCellIdFromSchema<Schemas[0]>)
+      | null,
+    CellListener extends CellListenerAlias<
+      Schemas,
+      TableIdOrNull,
+      RowIdOrNull,
+      CellIdOrNull
+    >,
+  >(
+    tableId: TableIdOrNull,
+    rowId: RowIdOrNull,
+    cellId: CellIdOrNull,
     listener: CellListener,
     mutator?: boolean,
   ): Id;
@@ -4266,7 +4773,7 @@ export interface Store {
    * @category Listener
    * @since v3.0.0
    */
-  addValuesListener(listener: ValuesListener, mutator?: boolean): Id;
+  addValuesListener(listener: ValuesListener<Schemas>, mutator?: boolean): Id;
 
   /**
    * The addValueIdsListener method registers a listener function with the Store
@@ -4330,7 +4837,10 @@ export interface Store {
    * @category Listener
    * @since v3.0.0
    */
-  addValueIdsListener(listener: ValueIdsListener, mutator?: boolean): Id;
+  addValueIdsListener(
+    listener: ValueIdsListener<Schemas>,
+    mutator?: boolean,
+  ): Id;
 
   /**
    * The addValueListener method registers a listener function with the Store
@@ -4419,8 +4929,11 @@ export interface Store {
    * @category Listener
    * @since v3.0.0
    */
-  addValueListener(
-    valueId: IdOrNull,
+  addValueListener<
+    ValueIdOrNull extends ValueIdFromSchema<Schemas[1]> | null,
+    ValueListener = ValueListenerAlias<Schemas, ValueIdOrNull>,
+  >(
+    valueId: ValueIdOrNull,
     listener: ValueListener,
     mutator?: boolean,
   ): Id;
@@ -4652,7 +5165,7 @@ export interface Store {
     tableId: IdOrNull,
     rowId: IdOrNull,
     cellId: IdOrNull,
-    listener: InvalidCellListener,
+    listener: InvalidCellListener<Schemas>,
     mutator?: boolean,
   ): Id;
 
@@ -4828,7 +5341,7 @@ export interface Store {
    */
   addInvalidValueListener(
     valueId: IdOrNull,
-    listener: InvalidValueListener,
+    listener: InvalidValueListener<Schemas>,
     mutator?: boolean,
   ): Id;
 
@@ -4922,7 +5435,7 @@ export interface Store {
    * @category Listener
    * @since v1.3.0
    */
-  addWillFinishTransactionListener(listener: TransactionListener): Id;
+  addWillFinishTransactionListener(listener: TransactionListener<Schemas>): Id;
 
   /**
    * The addDidFinishTransactionListener method registers a listener function
@@ -5015,7 +5528,7 @@ export interface Store {
    * @category Listener
    * @since v1.3.0
    */
-  addDidFinishTransactionListener(listener: TransactionListener): Id;
+  addDidFinishTransactionListener(listener: TransactionListener<Schemas>): Id;
 
   /**
    * The callListener method provides a way for you to manually provoke a
@@ -5132,7 +5645,7 @@ export interface Store {
    * ```
    * @category Listener
    */
-  callListener(listenerId: Id): Store;
+  callListener(listenerId: Id): Store<Schemas>;
 
   /**
    * The delListener method removes a listener that was previously added to the
@@ -5165,7 +5678,7 @@ export interface Store {
    * ```
    * @category Listener
    */
-  delListener(listenerId: Id): Store;
+  delListener(listenerId: Id): Store<Schemas>;
 
   /**
    * The getListenerStats method provides a set of statistics about the
@@ -5242,3 +5755,389 @@ export interface Store {
  * @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>;