tinybase 2.2.6 → 3.0.0-beta.1

package/lib/es6/store.d.ts

@@ -90,16 +90,61 @@ export type Cell = string | number | boolean;
 
 /**
  * The CellOrUndefined type is a data structure representing the data in a
- * single cell or the value `undefined`.
+ * single cell, or the value `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
+ * 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.
  *
  * @category Store
  */
 export type CellOrUndefined = Cell | undefined;
 
+/**
+ * The Values type is the data structure representing all the keyed values in a
+ * Store.
+ *
+ * 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
+ * their Id.
+ *
+ * @example
+ * ```js
+ * const values: Values = {open: true, employees: 4};
+ * ```
+ * @category Store
+ */
+export type Values = {[valueId: Id]: Value};
+
+/**
+ * The Value type is the data structure representing the data in a single keyed
+ * value.
+ *
+ * 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.
+ *
+ * @example
+ * ```js
+ * const value: Value = 'dog';
+ * ```
+ * @category Store
+ */
+export type Value = string | number | boolean;
+
+/**
+ * The ValueOrUndefined type is a data structure representing the data in a
+ * single value, or the 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.
+ *
+ * @category Store
+ */
+export type ValueOrUndefined = Value | undefined;
+
 /**
  * The TableCallback type describes a function that takes a Table's Id and a
  * callback to loop over each Row within it.
@@ -150,6 +195,20 @@ export type RowCallback = (
  */
 export type CellCallback = (cellId: Id, cell: Cell) => void;
 
+/**
+ * The ValueCallback type describes a function that takes a Value's Id and its
+ * actual value.
+ *
+ * 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.
+ *
+ * @param valueId The Id of the Value that the callback can operate on.
+ * @param value The Value itself.
+ * @category Callback
+ */
+export type ValueCallback = (valueId: Id, value: Value) => void;
+
 /**
  * The MapCell type describes a function that takes an existing Cell value and
  * returns another.
@@ -163,6 +222,19 @@ export type CellCallback = (cellId: Id, cell: Cell) => void;
  */
 export type MapCell = (cell: CellOrUndefined) => Cell;
 
+/**
+ * The MapValue type describes a function that takes an existing Value and
+ * returns another.
+ *
+ * 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.
+ *
+ * @param value The current Value to map to a new Value.
+ * @category Callback
+ */
+export type MapValue = (value: ValueOrUndefined) => Value;
+
 /**
  * The GetCell type describes a function that takes a Id and returns the Cell
  * value for a particular Row.
@@ -176,6 +248,32 @@ export type MapCell = (cell: CellOrUndefined) => Cell;
  */
 export type GetCell = (cellId: Id) => CellOrUndefined;
 
+/**
+ * The DoRollback type describes a function that you can use to rollback the
+ * transaction if it did not complete to your satisfaction.
+ *
+ * A DoRollback can be provided when calling the transaction method or the
+ * finishTransaction method. See those methods for specific examples.
+ *
+ * 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 attempts to do so,
+ * respectively.
+ *
+ * @param changedCells Any Cells that were changed during the transaction.
+ * @param invalidCells Any invalid attempts to change Cells.
+ * @param changedValues Any Values that were changed during the transaction,
+ * since v3.0.0.
+ * @param invalidValues Any invalid attempts to change Values, since v3.0.0.
+ * @category Callback
+ */
+export type DoRollback = (
+  changedCells: ChangedCells,
+  invalidCells: InvalidCells,
+  changedValues: ChangedValues,
+  invalidValues: InvalidValues,
+) => boolean;
+
 /**
  * The TransactionListener type describes a function that is used to listen to
  * the completion of a transaction for the Store.
@@ -185,22 +283,28 @@ export type GetCell = (cellId: Id) => CellOrUndefined;
  * See those methods for specific examples.
  *
  * When called, a TransactionListener is simply given a reference to the Store
- * and a boolean to indicate whether Cell values have been touched during the
- * transaction. The latter flag is intended as a hint about whether non-mutating
- * listeners might be being called at the end of the transaction.
+ * and booleans to indicate whether Cell or Value data has been touched during
+ * the transaction. The two flags are intended as a hint about whether
+ * non-mutating listeners might be being called at the end of the transaction.
  *
- * Here, 'touched' means that Cell values have either been changed, or changed
- * and then changed back to its original value during the transaction. The
- * exception is a transaction that has been rolled back, for which the value of
- * `cellsTouched` in the listener will be `false` because all changes have been
- * reverted.
+ * Here, 'touched' means that Cell or Value data has either been changed, or
+ * changed and then changed back to its original value during the transaction.
+ * The exception is a transaction that has been rolled back, for which the value
+ * of `cellsTouched` and `valuesTouched` in the listener will be `false` because
+ * all changes have been reverted.
  *
  * @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.
  * @category Listener
  */
-export type TransactionListener = (store: Store, cellsTouched: boolean) => void;
+export type TransactionListener = (
+  store: Store,
+  cellsTouched: boolean,
+  valuesTouched: boolean,
+) => void;
 
 /**
  * The TablesListener type describes a function that is used to listen to
@@ -403,6 +507,78 @@ export type CellListener = (
   getCellChange: GetCellChange | undefined,
 ) => void;
 
+/**
+ * The ValuesListener type describes a function that is used to listen to
+ * changes to all the Values in a Store.
+ *
+ * A ValuesListener is provided when using the addValuesListener method. See
+ * that method for specific examples.
+ *
+ * When called, a ValuesListener is given a reference to the Store and a
+ * GetValueChange function that can be used to query Values before and after the
+ * current transaction.
+ *
+ * Note that if the listener was manually forced to be called (with the
+ * callListener method rather than due to a real change in the Store), the
+ * GetValueChange function will not be present.
+ *
+ * @param store A reference to the Store that changed.
+ * @param getValueChange A function that returns information about any Value's
+ * changes.
+ * @category Listener
+ */
+export type ValuesListener = (
+  store: Store,
+  getValueChange: GetValueChange | undefined,
+) => void;
+
+/**
+ * The ValueIdsListener type describes a function that is used to listen to
+ * changes to the Value Ids in a Store.
+ *
+ * A ValueIdsListener is provided when using the addValueIdsListener method. See
+ * that method for specific examples.
+ *
+ * When called, a ValueIdsListener is given a reference to the Store.
+ *
+ * @param store A reference to the Store that changed.
+ * @category Listener
+ */
+export type ValueIdsListener = (store: Store) => void;
+
+/**
+ * The ValueListener type describes a function that is used to listen to changes
+ * to a Value.
+ *
+ * A ValueListener is provided when using the addValueListener method. See that
+ * method for specific examples.
+ *
+ * When called, a ValueListener is given a reference to the Store and the Id of
+ * Value that changed. It is also given the new value of the Value, the old
+ * value of the Value, and a GetValueChange function that can be used to query
+ * Values before and after the current transaction.
+ *
+ * Note that if the listener was manually forced to be called (with the
+ * callListener method rather than due to a real change in the Store), the
+ * GetValueChange function will not be present and the new and old values of the
+ * Value will be the same.
+ *
+ * @param store A reference to the Store that changed.
+ * @param valueId The Id of the Value that changed.
+ * @param newValue The new value of the Value that changed.
+ * @param oldValue The old value of the Value that changed.
+ * @param getValueChange A function that returns information about any Value's
+ * changes.
+ * @category Listener
+ */
+export type ValueListener = (
+  store: Store,
+  valueId: Id,
+  newValue: Value,
+  oldValue: Value,
+  getValueChange: GetValueChange | undefined,
+) => void;
+
 /**
  * The InvalidCellListener type describes a function that is used to listen to
  * attempts to set invalid data to a Cell.
@@ -411,7 +587,7 @@ export type CellListener = (
  * method. See that method for specific examples.
  *
  * When called, a InvalidCellListener is given a reference to the Store, the Id
- * of the Table, the Id of the Row, and the Id of Cell that were being attempted
+ * of the Table, the Id of the Row, and the Id of Cell that was being attempted
  * to be changed. It is also given the invalid value of the Cell, which could
  * have been of absolutely any type. Since there could have been multiple failed
  * attempts to set the Cell within a single transaction, this is an array
@@ -433,6 +609,32 @@ export type InvalidCellListener = (
   invalidCells: any[],
 ) => void;
 
+/**
+ * The InvalidValueListener type describes a function that is used to listen to
+ * attempts to set invalid data to a Value.
+ *
+ * A InvalidValueListener is provided when using the addInvalidValueListener
+ * method. See that method for specific examples.
+ *
+ * When called, a InvalidValueListener is given 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, which could have been of absolutely any type.
+ * Since there could have been multiple failed attempts to set the Value within
+ * a single transaction, this is an array containing each attempt,
+ * chronologically.
+ *
+ * @param store A reference to the Store that was being changed.
+ * @param valueId The Id of the Value that was being changed.
+ * @param invalidValues An array of the Values that were invalid.
+ * @category Listener
+ * @since v3.0.0
+ */
+export type InvalidValueListener = (
+  store: Store,
+  valueId: Id,
+  invalidValues: any[],
+) => void;
+
 /**
  * The GetCellChange type describes a function that returns information about
  * any Cell's changes during a transaction.
@@ -467,20 +669,52 @@ export type CellChange = [
 ];
 
 /**
- * The Schema type describes the structure of a Store in terms of valid Table
- * Ids and the types of Cell that can exist within them.
+ * The GetValueChange type describes a function that returns information about
+ * any Value's changes during a transaction.
+ *
+ * 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
+ * flag that indicates that the value has changed.
+ *
+ * @param valueId The Id of the Value to inspect.
+ * @returns A ValueChange array containing information about the Value's
+ * changes.
+ * @category Listener
+ */
+export type GetValueChange = (valueId: Id) => ValueChange;
+
+/**
+ * The ValueChange type describes a Value's changes during a transaction.
+ *
+ * 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
+ * flag that indicates that the value has changed.
+ *
+ * @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 Schema comprises a JavaScript object describing each Table, in turn a
+ * 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 setSchema method.
+ * CellSchema. It is provided to the setTablesSchema method.
  *
  * @example
- * When applied to a Store, this Schema 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`.
+ * 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 schema: Schema = {
+ * const tableSchema: TablesSchema = {
  *   pets: {
  *     species: {type: 'string'},
  *     sold: {type: 'boolean', default: false},
@@ -489,7 +723,7 @@ export type CellChange = [
  * ```
  * @category Schema
  */
-export type Schema = {
+export type TablesSchema = {
   [tableId: Id]: {
     [cellId: Id]: CellSchema;
   };
@@ -520,18 +754,62 @@ export type Schema = {
  * @category Schema
  */
 export type CellSchema =
-  | {
-      type: 'string';
-      default?: string;
-    }
-  | {
-      type: 'number';
-      default?: number;
-    }
-  | {
-      type: 'boolean';
-      default?: boolean;
-    };
+  | {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 ChangedCells type describes the Cell values that have been changed during
@@ -539,7 +817,8 @@ export type CellSchema =
  * transaction should be rolled back.
  *
  * A ChangedCells object is provided to the `doRollback` callback when using the
- * transaction method. See that method for specific examples.
+ * transaction method and the finishTransaction method. See those methods for
+ * specific examples.
  *
  * This type is a nested structure of Table, Row, and Cell objects, much like
  * the Tables object, but one which provides both the old and new Cell values in
@@ -564,13 +843,15 @@ export type ChangedCells = {
     };
   };
 };
+
 /**
  * The InvalidCells type describes the invalid Cell values that have been
  * attempted during a transaction, primarily used so that you can indicate
  * whether the transaction should be rolled back.
  *
  * An InvalidCells object is provided to the `doRollback` callback when using
- * the transaction method. See that method for specific examples.
+ * the transaction method and the finishTransaction method. See those methods
+ * for specific examples.
  *
  * This type is a nested structure of Table, Row, and Cell objects, much like
  * the Tables object, but one for which Cell values are listed in array (much
@@ -588,6 +869,53 @@ export type InvalidCells = {
   };
 };
 
+/**
+ * The ChangedValues type describes the Values that have been changed during a
+ * transaction, primarily used so that you can indicate whether the transaction
+ * should be rolled back.
+ *
+ * A ChangedValues object is provided to the `doRollback` callback when using
+ * the transaction method and the finishTransaction method. See those methods
+ * for specific examples.
+ *
+ * This type is an object containing the old and new Values in two-part arrays.
+ * These are describing the state of each changed Value in Store at the _start_
+ * of the transaction, and by the _end_ of the transaction.
+ *
+ * Hence, an `undefined` value for the first item in the array means that the
+ * Value was added during the transaction. An `undefined` value for the second
+ * item in the array means that the Value was removed during the transaction. An
+ * array with two different Values indicates that it was changed. The two-part
+ * array will never contain two items of the same value (including two
+ * `undefined` values), even if, during the transaction, a Value was changed to
+ * a different value and then changed back.
+ *
+ * @category Transaction
+ * @since v3.0.0
+ */
+export type ChangedValues = {
+  [valueId: Id]: [ValueOrUndefined, ValueOrUndefined];
+};
+/**
+ * The InvalidValues type describes the invalid Values that have been attempted
+ * during a transaction, primarily used so that you can indicate whether the
+ * transaction should be rolled back.
+ *
+ * An InvalidValues object is provided to the `doRollback` callback when using
+ * the transaction method and the finishTransaction method. See those methods
+ * for specific examples.
+ *
+ * This type is an object containing each invalid Value's attempt listed in
+ * array (much like the InvalidValueListener type) so that multiple failed
+ * attempts to change a Value during the transaction are described.
+ *
+ * @category Transaction
+ * @since v3.0.0
+ */
+export type InvalidValues = {
+  [valueId: Id]: any[];
+};
+
 /**
  * The StoreListenerStats type describes the number of listeners registered with
  * the Store, and can be used for debugging purposes.
@@ -636,6 +964,26 @@ export type StoreListenerStats = {
    * The number of InvalidCellListener functions registered with the Store.
    */
   invalidCell?: number;
+  /**
+   * The number of ValuesListener functions registered with the Store, since
+   * v3.0.0.
+   */
+  values?: number;
+  /**
+   * The number of ValueIdsListener functions registered with the Store, since
+   * v3.0.0.
+   */
+  valueIds?: number;
+  /**
+   * The number of ValueListener functions registered with the Store, since
+   * v3.0.0.
+   */
+  value?: number;
+  /**
+   * The number of InvalidValueListener functions registered with the Store,
+   * since v3.0.0.
+   */
+  invalidValue?: number;
   /**
    * The number of TransactionListener functions registered with the Store.
    */
@@ -643,13 +991,39 @@ export type StoreListenerStats = {
 };
 
 /**
- * A Store is the main location for keeping structured state and tabular data.
+ * A Store is the main location for keeping both tabular data and keyed values.
  *
  * Create a Store easily with the createStore function. From there, you can set
- * and get data, add listeners for when the data changes, set a Schema, and so
+ * and get data, add listeners for when the data changes, set schemas, and so
  * on.
  *
- * A Store has a simple hierarchical structure:
+ * A Store has two facets. It can contain keyed Values, and independently, it
+ * can contain tabular Tables data. These two facets have similar APIs but can
+ * be used entirely independently: you can use only tables, only keyed Values,
+ * or both tables _and_ keyed Values - all in a single Store.
+ *
+ * # Keyed values
+ *
+ * The keyed value support is best thought of as a flat JavaScript object. The
+ * Store contains a number of Value objects, each with a unique ID, and which is
+ * a string, boolean, or number:
+ *
+ * ```json
+ * {                  // Store
+ *   "value1": "one",   // Value (string)
+ *   "value2": true,    // Value (boolean)
+ *   "value3": 3,       // Value (number)
+ *   ...
+ * }
+ * ```
+ *
+ * In its default form, a Store has no sense of a structured schema for the
+ * Values. However, you _can_ optionally specify a ValuesSchema for a Store,
+ * which then usefully constrains and defaults the Values you can use.
+ *
+ * # Tabular data
+ *
+ * The tabular data exists in a simple hierarchical structure:
  *
  * - The Store contains a number of Table objects.
  * - Each Table contains a number of Row objects.
@@ -676,11 +1050,11 @@ export type StoreListenerStats = {
  * }
  * ```
  *
- * In its default form, a Store has no sense of a structured schema, so, as long
- * as they are unique within their own parent, the Id keys can each be any
- * string you want. However, you _can_ optionally specify a Schema for a Store,
- * which then usefully constrains the Table and Cell Ids (and Cell values) you
- * can use.
+ * Again, by default Store has no sense of a structured schema. As long as they
+ * are unique within their own parent, the Id keys can each be any string you
+ * want. However, as you _can_ optionally specify a TablesSchema for the tabular
+ * data in a Store, which then usefully constrains the Table and Cell Ids (and
+ * Cell values) you can use.
  *
  * # Setting and getting data
  *
@@ -700,6 +1074,9 @@ export type StoreListenerStats = {
  *
  * |Type|Get data|Set data|Delete data|Add a listener|
  * |-|-|-|-|-|
+ * |Values|getValues|setValues|delValues|addValuesListener|
+ * |Value Ids|getValueIds|-|-|addValueIdsListener|
+ * |Value|getValue|setValue|delValue|addValueListener|
  * |Tables|getTables|setTables|delTables|addTablesListener|
  * |Table Ids|getTableIds|-|-|addTableIdsListener|
  * |Table|getTable|setTable|delTable|addTableListener|
@@ -709,13 +1086,14 @@ export type StoreListenerStats = {
  * |Cell Ids|getCellIds|-|-|addCellIdsListener|
  * |Cell|getCell|setCell|delCell|addCellListener|
  *
- * Additionally, there are two extra methods to manipulate Row objects. The
- * addRow method is like the setRow method but automatically assigns it a new
- * unique Id. And the setPartialRow method lets you update multiple Cell values
- * in a Row without affecting the others.
+ * There are two extra methods to manipulate Row objects. The addRow method is
+ * like the setRow method but automatically assigns it a new unique Id. And the
+ * setPartialRow method lets you update multiple Cell values in a Row without
+ * affecting the others. (There is a similar setPartialValues method to do the
+ * same for the Values in a Store.)
  *
- * You can listen to attempts to write invalid data to a Cell with the
- * addInvalidCellListener method.
+ * You can listen to attempts to write invalid data to a Value or Cell with the
+ * addInvalidValueListener method or addInvalidCellListener method.
  *
  * The transaction method is used to wrap multiple changes to the Store so that
  * the relevant listeners only fire once.
@@ -733,17 +1111,17 @@ export type StoreListenerStats = {
  * Read more about setting and changing data in The Basics guides, and about
  * listeners in the Listening to Stores guide.
  *
- * # Creating a Schema
+ * # Creating a schema
  *
- * You can set a Schema on a Store when you create it with createStore function,
- * or at a later stage with the setSchema method. A Schema constrains the Table
+ * You can set a ValuesSchema and a TablesSchema with the setValuesSchema method
+ * and setTablesSchema method respectively. A TablesSchema constrains the Table
  * Ids the Store can have, and the types of Cell data in each Table. Each Cell
  * 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 Schema out of the Store with the
- * getSchemaJson method, and remove the Schema altogether with the delSchema
- * 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.
  *
  * Read more about schemas in the Using Schemas guide.
  *
@@ -755,6 +1133,7 @@ export type StoreListenerStats = {
  *
  * ||Checking existence|Iterator|
  * |-|-|-|
+ * |Value|hasValue|forEachValue|
  * |Table|hasTable|forEachTable|
  * |Row|hasRow|forEachRow|
  * |Cell|hasCell|forEachCell|
@@ -1136,6 +1515,92 @@ export interface Store {
    */
   getCell(tableId: Id, rowId: Id, cellId: Id): CellOrUndefined;
 
+  /**
+   * The getValues method returns an object containing the entire set of keyed
+   * Values in the Store.
+   *
+   * 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.
+   *
+   * @returns An object containing the entire data of the Values.
+   * @example
+   * This example retrieves the keyed Values data in a Store.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * console.log(store.getValues());
+   * // -> {open: true, employees: 3}
+   * ```
+   * @example
+   * This example retrieves a Values from a Store that has none, returning an
+   * empty object.
+   *
+   * ```js
+   * const store = createStore();
+   * console.log(store.getValues());
+   * // -> {}
+   * ```
+   * @category Getter
+   * @since v3.0.0
+   */
+  getValues(): Values;
+
+  /**
+   * The getValueIds method returns the Ids of every Value in a Store.
+   *
+   * 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.
+   *
+   * @returns An array of the Ids of every Value in the Store.
+   * @example
+   * This example retrieves the Value Ids in a Store.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * console.log(store.getValueIds());
+   * // -> ['open', 'employees']
+   * ```
+   * @example
+   * This example retrieves the Value Ids of a Store that has had none set,
+   * returning an empty array.
+   *
+   * ```js
+   * const store = createStore();
+   * console.log(store.getValueIds());
+   * // -> []
+   * ```
+   * @category Getter
+   * @since v3.0.0
+   */
+  getValueIds(): Ids;
+
+  /**
+   * The getValue method returns a single keyed Value in the Store.
+   *
+   * @param valueId The Id of the Value in the Store.
+   * @returns The Value, or `undefined`.
+   * @example
+   * This example retrieves a single Value.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * console.log(store.getValue('employees'));
+   * // -> 3
+   * ```
+   * @example
+   * This example retrieves a Value that does not exist, returning `undefined`.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * console.log(store.getValue('website'));
+   * // -> undefined
+   * ```
+   * @category Getter
+   * @since v3.0.0
+   */
+  getValue(valueId: Id): ValueOrUndefined;
+
   /**
    * The hasTables method returns a boolean indicating whether any Table objects
    * exist in the Store.
@@ -1220,61 +1685,235 @@ export interface Store {
   hasCell(tableId: Id, rowId: Id, cellId: Id): boolean;
 
   /**
-   * The getJson method returns a string serialization of all of the Tables in
-   * the Store.
-   *
-   * @returns A string serialization of all of the Tables in the Store.
-   * @example
-   * This example serializes the contents of a Store.
+   * The hasTables method returns a boolean indicating whether any Values exist
+   * in the Store.
    *
-   * ```js
-   * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
-   * console.log(store.getJson());
-   * // -> '{"pets":{"fido":{"species":"dog"}}}'
-   * ```
+   * @returns Whether any Values exist.
    * @example
-   * This example serializes the contents of an empty Store.
+   * This example shows simple existence checks.
    *
    * ```js
    * const store = createStore();
-   * console.log(store.getJson());
-   * // -> '{}'
+   * console.log(store.hasValues());
+   * // -> false
+   * store.setValues({open: true});
+   * console.log(store.hasValues());
+   * // -> true
+   * ```
+   * @category Getter
+   * @since v3.0.0
+   */
+  hasValues(): boolean;
+
+  /**
+   * The hasValue method returns a boolean indicating whether a given Value
+   * exists in the Store.
+   *
+   * @param valueId The Id of a possible Value in the Store.
+   * @returns Whether a Value with that Id exists in the Store.
+   * @example
+   * This example shows two simple Value existence checks.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true});
+   * console.log(store.hasValue('open'));
+   * // -> true
+   * console.log(store.hasValue('employees'));
+   * // -> false
+   * ```
+   * @category Getter
+   * @since v3.0.0
+   */
+  hasValue(valueId: Id): boolean;
+
+  /**
+   * The getTablesJson method returns a string serialization of all of the
+   * Tables in the Store.
+   *
+   * @returns A string serialization of all of the Tables in the Store.
+   * @example
+   * This example serializes the contents of a Store.
+   *
+   * ```js
+   * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
+   * console.log(store.getTablesJson());
+   * // -> '{"pets":{"fido":{"species":"dog"}}}'
+   * ```
+   * @example
+   * This example serializes the contents of an empty Store.
+   *
+   * ```js
+   * const store = createStore();
+   * console.log(store.getTablesJson());
+   * // -> '{}'
+   * ```
+   * @category Getter
+   * @since v3.0.0
+   */
+  getTablesJson(): Json;
+
+  /**
+   * 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
+   * This example serializes the keyed value contents of a Store.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true});
+   * console.log(store.getValuesJson());
+   * // -> '{"open":true}'
+   * ```
+   * @example
+   * This example serializes the contents of an empty Store.
+   *
+   * ```js
+   * const store = createStore();
+   * console.log(store.getValuesJson());
+   * // -> '{}'
+   * ```
+   * @category Getter
+   * @since v3.0.0
+   */
+  getValuesJson(): Json;
+
+  /**
+   * The getJson method returns a string serialization of all the Store content:
+   * both the Tables and the keyed Values.
+   *
+   * From v3.0.0 onwards, the serialization is 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 object
+   * of Tables.
+   *
+   * @returns A string serialization of the Tables and Values in the Store.
+   * @example
+   * This example serializes the tabular and keyed value contents of a Store.
+   *
+   * ```js
+   * const store = createStore()
+   *   .setTables({pets: {fido: {species: 'dog'}}})
+   *   .setValues({open: true});
+   * console.log(store.getJson());
+   * // -> '[{"pets":{"fido":{"species":"dog"}}},{"open":true}]'
+   * ```
+   * @example
+   * This example serializes the contents of an empty Store.
+   *
+   * ```js
+   * const store = createStore();
+   * console.log(store.getJson());
+   * // -> '[{},{}]'
    * ```
    * @category Getter
    */
   getJson(): Json;
 
   /**
-   * The getSchemaJson method returns a string serialization of the Schema of
-   * the Store.
+   * The getTablesSchemaJson method returns a string serialization of the
+   * TablesSchema of the Store.
    *
-   * If no Schema has been set on the Store (or if it has been removed with the
-   * delSchema method), then it will return the serialization of an empty
-   * object, `{}`.
+   * If no TablesSchema has been set on the Store (or if it has been removed
+   * with the delTablesSchema method), then it will return the serialization of
+   * an empty object, `{}`.
    *
-   * @returns A string serialization of the Schema of the Store.
+   * @returns A string serialization of the TablesSchema of the Store.
    * @example
-   * This example serializes the Schema of a Store.
+   * This example serializes the TablesSchema of a Store.
    *
    * ```js
-   * const store = createStore().setSchema({
+   * const store = createStore().setTablesSchema({
    *   pets: {
    *     species: {type: 'string'},
    *     sold: {type: 'boolean'},
    *   },
    * });
-   * console.log(store.getSchemaJson());
+   * console.log(store.getTablesSchemaJson());
    * // -> '{"pets":{"species":{"type":"string"},"sold":{"type":"boolean"}}}'
    * ```
    * @example
-   * This example serializes the Schema of an empty Store.
+   * This example serializes the TablesSchema of an empty Store.
    *
    * ```js
    * const store = createStore();
-   * console.log(store.getSchemaJson());
+   * console.log(store.getTablesSchemaJson());
+   * // -> '{}'
+   * ```
+   * @category Getter
+   * @since v3.0.0
+   */
+  getTablesSchemaJson(): Json;
+
+  /**
+   * The getValuesSchemaJson method returns a string serialization of the
+   * ValuesSchema of the Store.
+   *
+   * If no ValuesSchema has been set on the Store (or if it has been removed
+   * with the delValuesSchema method), then it will return the serialization of
+   * an empty object, `{}`.
+   *
+   * @returns A string serialization of the ValuesSchema of the Store.
+   * @example
+   * This example serializes the ValuesSchema of a Store.
+   *
+   * ```js
+   * const store = createStore().setValuesSchema({
+   *   open: {type: 'boolean', default: false},
+   * });
+   * console.log(store.getValuesSchemaJson());
+   * // -> '{"open":{"type":"boolean","default":false}}'
+   * ```
+   * @example
+   * This example serializes the ValuesSchema of an empty Store.
+   *
+   * ```js
+   * const store = createStore();
+   * console.log(store.getValuesSchemaJson());
    * // -> '{}'
    * ```
    * @category Getter
+   * @since v3.0.0
+   */
+  getValuesSchemaJson(): Json;
+
+  /**
+   * The getSchemaJson method returns a string serialization of both the
+   * TablesSchema and ValuesSchema of the Store.
+   *
+   * From v3.0.0 onwards, the serialization is of an array with two entries. The
+   * first is the TablesSchema object, the second the ValuesSchema. In previous
+   * versions (before the existence of the ValuesSchema data structure), it was
+   * a sole object of TablesSchema.
+   *
+   * @returns A string serialization of the TablesSchema and ValuesSchema of the
+   * Store.
+   * @example
+   * This example serializes the TablesSchema and ValuesSchema of a Store.
+   *
+   * ```js
+   * const store = createStore()
+   *   .setTablesSchema({
+   *     pets: {
+   *       price: {type: 'number'},
+   *     },
+   *   })
+   *   .setValuesSchema({
+   *     open: {type: 'boolean'},
+   *   });
+   * console.log(store.getSchemaJson());
+   * // -> '[{"pets":{"price":{"type":"number"}}},{"open":{"type":"boolean"}}]'
+   * ```
+   * @example
+   * This example serializes the TablesSchema and ValuesSchema of an empty
+   * Store.
+   *
+   * ```js
+   * const store = createStore();
+   * console.log(store.getSchemaJson());
+   * // -> '[{},{}]'
+   * ```
+   * @category Getter
    */
   getSchemaJson(): Json;
 
@@ -1285,14 +1924,14 @@ export interface Store {
    * Id changes resulting from it.
    *
    * Any part of the provided object that is invalid (either according to the
-   * Tables type, or because it does not match a Schema associated with the
-   * Store), will be ignored silently.
+   * Tables type, or because it does not match a TablesSchema associated with
+   * the Store), will be ignored silently.
    *
    * Assuming that at least some of the provided Tables object is valid, any
    * data that was already present in the Store will be completely overwritten.
    * If the object is completely invalid, no change will be made to the Store.
    *
-   * The method returns a reference to the Store to that subsequent operations
+   * The method returns a reference to the Store so that subsequent operations
    * can be chained in a fluent style.
    *
    * @param tables The data of the Store to be set.
@@ -1334,7 +1973,7 @@ export interface Store {
    * Id changes resulting from it.
    *
    * Any part of the provided object that is invalid (either according to the
-   * Table type, or because it does not match a Schema associated with the
+   * Table type, or because it does not match a TablesSchema associated with the
    * Store), will be ignored silently.
    *
    * Assuming that at least some of the provided Table object is valid, any data
@@ -1342,7 +1981,7 @@ export interface Store {
    * overwritten. If the object is completely invalid, no change will be made to
    * the Store.
    *
-   * The method returns a reference to the Store to that subsequent operations
+   * The method returns a reference to the Store so that subsequent operations
    * can be chained in a fluent style.
    *
    * @param tableId The Id of the Table in the Store.
@@ -1385,15 +2024,15 @@ export interface Store {
    * Id changes resulting from it.
    *
    * Any part of the provided object that is invalid (either according to the
-   * Row type, or because it does not match a Schema associated with the Store),
-   * will be ignored silently.
+   * Row type, or because it does not match a TablesSchema associated with the
+   * Store), will be ignored silently.
    *
    * Assuming that at least some of the provided Row object is valid, any data
    * that was already present in the Store for that Row will be completely
    * overwritten. If the object is completely invalid, no change will be made to
    * the Store.
    *
-   * The method returns a reference to the Store to that subsequent operations
+   * The method returns a reference to the Store so that subsequent operations
    * can be chained in a fluent style.
    *
    * @param tableId The Id of the Table in the Store.
@@ -1435,8 +2074,8 @@ export interface Store {
    * Id changes resulting from it.
    *
    * Any part of the provided object that is invalid (either according to the
-   * Row type, or because it does not match a Schema associated with the Store),
-   * will be ignored silently.
+   * Row type, or because it does not match a TablesSchema associated with the
+   * Store), will be ignored silently.
    *
    * Assuming that at least some of the provided Row object is valid, a new Row
    * will be created. If the object is completely invalid, no change will be
@@ -1489,13 +2128,13 @@ export interface Store {
    *
    * Any part of the provided object that is invalid (either according to the
    * Row type, or because, when combined with the current Row data, it does not
-   * match a Schema associated with the Store), will be ignored silently.
+   * match a TablesSchema associated with the Store), will be ignored silently.
    *
    * Assuming that at least some of the provided Row object is valid, it will be
    * merged with the data that was already present in the Store. If the object
    * is completely invalid, no change will be made to the Store.
    *
-   * The method returns a reference to the Store to that subsequent operations
+   * The method returns a reference to the Store so that subsequent operations
    * can be chained in a fluent style.
    *
    * @param tableId The Id of the Table in the Store.
@@ -1539,7 +2178,7 @@ export interface Store {
    * Id changes resulting from it.
    *
    * If the Cell value is invalid (either because of its type, or because it
-   * does not match a Schema associated with the Store), will be ignored
+   * does not match a TablesSchema associated with the Store), will be ignored
    * silently.
    *
    * As well as string, number, or boolean Cell types, this method can also take
@@ -1547,7 +2186,7 @@ export interface Store {
    * maps it. This is useful if you want to efficiently increment a value
    * without fetching it first, for example.
    *
-   * The method returns a reference to the Store to that subsequent operations
+   * The method returns a reference to the Store so that subsequent operations
    * can be chained in a fluent style.
    *
    * @param tableId The Id of the Table in the Store.
@@ -1591,53 +2230,391 @@ export interface Store {
   setCell(tableId: Id, rowId: Id, cellId: Id, cell: Cell | MapCell): Store;
 
   /**
-   * The setJson method takes a string serialization of all of the Tables in the
-   * Store and attempts to update it to that value
+   * The setValues method takes an object and sets all the Values in the Store.
+   *
+   * This method will cause listeners to be called for any Value or Id changes
+   * resulting from it.
+   *
+   * Any part of the provided object that is invalid (either according to the
+   * Values type, or because it does not match a ValuesSchema associated with
+   * the Store), will be ignored silently.
+   *
+   * Assuming that at least some of the provided Values object is valid, any
+   * data that was already present in the Store for that Values will be
+   * completely overwritten. If the object is completely invalid, no change will
+   * be made to the Store.
+   *
+   * The method returns a reference to the Store so that subsequent operations
+   * can be chained in a fluent style.
+   *
+   * @param values The Values object to be set.
+   * @returns A reference to the Store.
+   * @example
+   * This example sets the Values of a Store.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * console.log(store.getValues());
+   * // -> {open: true, employees: 3}
+   * ```
+   * @example
+   * This example attempts to set the data of an existing Store with partly
+   * invalid, and then completely invalid, Values objects.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true});
+   *
+   * store.setValues({employees: 3, bug: []});
+   * console.log(store.getValues());
+   * // -> {employees: 3}
+   *
+   * store.setValues(42);
+   * console.log(store.getValues());
+   * // -> {employees: 3}
+   * ```
+   * @category Setter
+   * @since v3.0.0
+   */
+  setValues(values: Values): Store;
+
+  /**
+   * The setPartialValues method takes an object and sets its Values in the
+   * Store, but leaving existing Values unaffected.
+   *
+   * This method will cause listeners to be called for any Values or Id changes
+   * resulting from it.
+   *
+   * Any part of the provided object that is invalid (either according to the
+   * Values type, or because, when combined with the current Values data, it
+   * does not match a ValuesSchema associated with the Store), will be ignored
+   * silently.
+   *
+   * Assuming that at least some of the provided Values object is valid, it will
+   * be merged with the data that was already present in the Store. If the
+   * object is completely invalid, no change will be made to the Store.
+   *
+   * The method returns a reference to the Store so that subsequent operations
+   * can be chained in a fluent style.
+   *
+   * @param partialValues The Values to be set.
+   * @returns A reference to the Store.
+   * @example
+   * This example sets some of the keyed value data in a Store.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true});
+   * store.setPartialValues({employees: 3});
+   * console.log(store.getValues());
+   * // -> {open: true, employees: 3}
+   * ```
+   * @example
+   * This example attempts to set some of the data of an existing Store with
+   * partly invalid, and then completely invalid, Values objects.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true});
+   *
+   * store.setPartialValues({employees: 3, bug: []});
+   * console.log(store.getValues());
+   * // -> {open: true, employees: 3}
+   *
+   * store.setPartialValues(42);
+   * console.log(store.getValues());
+   * // -> {open: true, employees: 3}
+   * ```
+   * @category Setter
+   * @since v3.0.0
+   */
+  setPartialValues(partialValues: Values): Store;
+
+  /**
+   * The setValue method sets a single keyed Value in the Store.
+   *
+   * This method will cause listeners to be called for any Value, or Id changes
+   * resulting from it.
+   *
+   * If the Value is invalid (either because of its type, or because it does not
+   * match a ValuesSchema associated with the Store), will be ignored silently.
+   *
+   * As well as string, number, or boolean Value types, this method can also
+   * take a MapValue function that takes the current Value as a parameter and
+   * maps it. This is useful if you want to efficiently increment a value
+   * without fetching it first, for example.
+   *
+   * The method returns a reference to the Store so that subsequent operations
+   * can be chained in a fluent style.
+   *
+   * @param valueId The Id of the Value in the Store.
+   * @param value The Value to be set, or a MapValue function to update it.
+   * @returns A reference to the Store.
+   * @example
+   * This example sets a single Value.
+   *
+   * ```js
+   * const store = createStore().setValue('open', true);
+   * console.log(store.getValues());
+   * // -> {open: true}
+   * ```
+   * @example
+   * This example sets the data of a single Value by mapping the existing Value.
+   *
+   * ```js
+   * const increment = (value) => value + 1;
+   * const store = createStore().setValues({employees: 3});
+   *
+   * store.setValue('employees', increment);
+   * console.log(store.getValue('employees'));
+   * // -> 4
+   * ```
+   * @example
+   * This example attempts to set an invalid Value.
+   *
+   * ```js
+   * const store = createStore().setValues({employees: 3});
+   *
+   * store.setValue('bug', []);
+   * console.log(store.getValues());
+   * // -> {employees: 3}
+   * ```
+   * @category Setter
+   * @since v3.0.0
+   */
+  setValue(valueId: Id, value: Value | MapValue): Store;
+
+  /**
+   * The setTablesJson method takes a string serialization of all of the Tables
+   * in the Store and attempts to update them to that.
    *
    * 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 Schema associated
-   * with the Store).
+   * method (according to the Tables type, and matching any TablesSchema
+   * associated with the Store).
    *
-   * @param json A string serialization of all of the Tables in the Store.
+   * @param tablesJson A string serialization of all of the Tables in the Store.
    * @returns A reference to the Store.
    * @example
-   * This example sets the contents of a Store from a serialization.
+   * This example sets the tabular contents of a Store from a serialization.
    *
    * ```js
    * const store = createStore();
-   * store.setJson('{"pets":{"fido":{"species":"dog"}}}');
+   * store.setTablesJson('{"pets": {"fido": {"species": "dog"}}}');
    * console.log(store.getTables());
    * // -> {pets: {fido: {species: 'dog'}}}
    * ```
    * @example
-   * This example attempts to set the contents of a Store from an invalid
+   * This example attempts to set the tabular contents of a Store from an
+   * invalid serialization.
+   *
+   * ```js
+   * const store = createStore();
+   * store.setTablesJson('{"pets": {"fido": {');
+   * console.log(store.getTables());
+   * // -> {}
+   * ```
+   * @category Setter
+   * @since v3.0.0
+   */
+  setTablesJson(tablesJson: Json): Store;
+
+  /**
+   * The setValuesJson method takes a string serialization of all of the Values
+   * in the Store and attempts to update them to those values.
+   *
+   * 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
+   * associated with the Store).
+   *
+   * @param valuesJson A string serialization of all of the Values in the Store.
+   * @returns A reference to the Store.
+   * @example
+   * This example sets the keyed value contents of a Store from a serialization.
+   *
+   * ```js
+   * const store = createStore();
+   * store.setValuesJson('{"open": true}');
+   * console.log(store.getValues());
+   * // -> {open: true}
+   * ```
+   * @example
+   * This example attempts to set the keyed value contents of a Store from an
+   * invalid serialization.
+   *
+   * ```js
+   * const store = createStore();
+   * store.setValuesJson('{"open": false');
+   * console.log(store.getValues());
+   * // -> {}
+   * ```
+   * @category Setter
+   * @since v3.0.0
+   */
+  setValuesJson(valuesJson: Json): Store;
+
+  /**
+   * 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.
+   *
+   * 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
+   * object of Tables. For backwards compatibility, if a serialization of a
+   * single object is provided, it will be treated as the Tables type.
+   *
+   * 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
+   * associated with the Store), and the setValues method (according to the
+   * Values type, and matching any ValuesSchema associated with the Store).
+   *
+   * @param tablesAndValuesJson A string serialization of all of the Tables and
+   * Values in the Store.
+   * @returns A reference to the Store.
+   * @example
+   * This example sets the tabular and keyed value contents of a Store from a
    * serialization.
    *
    * ```js
    * const store = createStore();
-   * store.setJson('{"pets":{"fido":{');
+   * store.setJson('[{"pets": {"fido": {"species": "dog"}}}, {"open": true}]');
    * console.log(store.getTables());
+   * // -> {pets: {fido: {species: 'dog'}}}
+   * console.log(store.getValues());
+   * // -> {open: true}
+   * ```
+   * @example
+   * This example sets the tabular contents of a Store from a
+   * legacy single-object serialization (compatible with v2.x and earlier).
+   *
+   * ```js
+   * const store = createStore();
+   * store.setJson('{"pets": {"fido": {"species": "dog"}}}');
+   * console.log(store.getTables());
+   * // -> {pets: {fido: {species: 'dog'}}}
+   * console.log(store.getValues());
+   * // -> {}
+   * ```
+   * @example
+   * This example attempts to set the the tabular and keyed value contents of a
+   * Store from an invalid serialization.
+   *
+   * ```js
+   * const store = createStore();
+   * store.setValuesJson('[{"pets": {"fido": {"species": "do');
+   * console.log(store.getTables());
+   * // -> {}
+   * console.log(store.getValues());
    * // -> {}
    * ```
    * @category Setter
    */
-  setJson(json: Json): Store;
+  setJson(tablesAndValuesJson: Json): Store;
 
   /**
-   * The setSchema method lets you specify the Schema of the Store.
+   * The setTablesSchema method lets you specify the TablesSchema of the tabular
+   * part of the 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.
    *
-   * When no longer needed, you can also completely remove an existing Schema
-   * with the delSchema method.
+   * When no longer needed, you can also completely remove an existing
+   * TablesSchema with the delTablesSchema method.
    *
-   * @param schema The Schema to be set for the Store.
+   * @param tablesSchema The TablesSchema to be set for the Store.
    * @returns A reference to the Store.
    * @example
-   * This example sets the Schema of a Store after it has been created.
+   * This example sets the TablesSchema of a Store after it has been created.
+   *
+   * ```js
+   * const store = createStore().setTablesSchema({
+   *   pets: {
+   *     species: {type: 'string'},
+   *     sold: {type: 'boolean', default: false},
+   *   },
+   * });
+   * store.addRow('pets', {species: 'dog', color: 'brown', sold: 'maybe'});
+   *
+   * console.log(store.getTables());
+   * // -> {pets: {0: {species: 'dog', sold: false}}}
+   * ```
+   * @category Setter
+   * @since v3.0.0
+   */
+  setTablesSchema(tablesSchema: TablesSchema): Store;
+
+  /**
+   * The setValuesSchema method lets you specify the ValuesSchema of the keyed
+   * Values part of the 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.
+   *
+   * When no longer needed, you can also completely remove an existing
+   * ValuesSchema with the delValuesSchema method.
+   *
+   * @param valuesSchema The ValuesSchema to be set for the Store.
+   * @returns A reference to the Store.
+   * @example
+   * This example sets the ValuesSchema of a Store after it has been created.
+   *
+   * ```js
+   * const store = createStore().setValuesSchema({
+   *   open: {type: 'boolean', default: false},
+   * });
+   * store.setValue('open', 'maybe');
+   *
+   * console.log(store.getValues());
+   * // -> {open: false}
+   * ```
+   * @category Setter
+   * @since v3.0.0
+   */
+  setValuesSchema(valuesSchema: ValuesSchema): Store;
+
+  /**
+   * The setSchema method lets you specify the TablesSchema and ValuesSchema of
+   * the 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.
+   *
+   * 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
+   * was present. For backwards compatibility the new second parameter is
+   * optional.
+   *
+   * @param tablesSchema The TablesSchema to be set for the Store.
+   * @param valuesSchema The ValuesSchema to be set for the Store.
+   * @returns A reference to the Store.
+   * @example
+   * This example sets the TablesSchema and ValuesSchema of a Store after it has
+   * been created.
+   *
+   * ```js
+   * const store = createStore().setSchema(
+   *   {
+   *     pets: {
+   *       species: {type: 'string'},
+   *       sold: {type: 'boolean', default: false},
+   *     },
+   *   },
+   *   {open: {type: 'boolean', default: false}},
+   * );
+   * store.addRow('pets', {species: 'dog', color: 'brown', sold: 'maybe'});
+   * store.setValue('open', 'maybe');
+   *
+   * console.log(store.getTables());
+   * // -> {pets: {0: {species: 'dog', sold: false}}}
+   * console.log(store.getValues());
+   * // -> {open: false}
+   * ```
+   * @example
+   * This example sets just the TablesSchema of a Store after it has been
+   * created.
    *
    * ```js
    * const store = createStore().setSchema({
@@ -1647,12 +2624,13 @@ export interface Store {
    *   },
    * });
    * store.addRow('pets', {species: 'dog', color: 'brown', sold: 'maybe'});
+   *
    * console.log(store.getTables());
    * // -> {pets: {0: {species: 'dog', sold: false}}}
    * ```
    * @category Setter
    */
-  setSchema(schema: Schema): Store;
+  setSchema(tablesSchema: TablesSchema, valuesSchema?: ValuesSchema): Store;
 
   /**
    * The delTables method lets you remove all of the data in a Store.
@@ -1721,32 +2699,33 @@ export interface Store {
   /**
    * The delCell method lets you remove a single Cell from a Row.
    *
-   * When there is no Schema 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.
+   * 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.
    *
-   * If there is a Schema applied to the Store and it specifies a default value
-   * for this Cell, then deletion will result in it being set back to its
+   * If there is a TablesSchema applied to the Store and it specifies a default
+   * value for this Cell, then deletion will result in it being set back to its
    * default value. To override this, use the `forceDel` parameter, as described
    * below.
    *
    * The `forceDel` parameter is an optional flag that is only relevant if a
-   * Schema provides a default value for this Cell. Under such circumstances,
-   * deleting a Cell value will normally restore it to the default value. If
-   * this flag is set to `true`, the complete removal of the Cell is instead
-   * guaranteed. But since doing do so would result in an invalid Row (according
-   * to the Schema), in fact the whole Row is deleted to retain the integrity of
-   * the Table. Therefore, this flag should be used with caution.
+   * TablesSchema provides a default value for this Cell. Under such
+   * circumstances, deleting a Cell value will normally restore it to the
+   * default value. If this flag is set to `true`, the complete removal of the
+   * Cell is instead guaranteed. But since doing do so would result in an
+   * invalid Row (according to the TablesSchema), in fact the whole Row is
+   * deleted to retain the integrity of the Table. Therefore, this flag should
+   * be used with caution.
    *
    * @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.
    * @param forceDel An optional flag to indicate that the whole Row should be
-   * deleted, even if a Schema provides a default value for this Cell. Defaults
-   * to `false`.
+   * deleted, even if a TablesSchema provides a default value for this Cell.
+   * Defaults to `false`.
    * @returns A reference to the Store.
    * @example
-   * This example removes a Cell from a Row without a Schema.
+   * This example removes a Cell from a Row without a TablesSchema.
    *
    * ```js
    * const store = createStore().setTables({
@@ -1758,15 +2737,15 @@ export interface Store {
    * // -> {pets: {fido: {species: 'dog'}}}
    * ```
    * @example
-   * This example removes a Cell from a Row with a Schema that defaults its
-   * value.
+   * This example removes a Cell from a Row with a TablesSchema that defaults
+   * its value.
    *
    * ```js
    * const store = createStore()
    *   .setTables({
    *     pets: {fido: {species: 'dog', sold: true}},
    *   })
-   *   .setSchema({
+   *   .setTablesSchema({
    *     pets: {
    *       species: {type: 'string'},
    *       sold: {type: 'boolean', default: false},
@@ -1778,15 +2757,15 @@ export interface Store {
    * // -> {pets: {fido: {species: 'dog', sold: false}}}
    * ```
    * @example
-   * This example removes a Cell from a Row with a Schema that defaults its
-   * value, but uses the `forceDel` parameter to override it.
+   * This example removes a Cell from a Row with a TablesSchema that defaults
+   * its value, but uses the `forceDel` parameter to override it.
    *
    * ```js
    * const store = createStore()
    *   .setTables({
    *     pets: {fido: {species: 'dog', sold: true}, felix: {species: 'cat'}},
    *   })
-   *   .setSchema({
+   *   .setTablesSchema({
    *     pets: {
    *       species: {type: 'string'},
    *       sold: {type: 'boolean', default: false},
@@ -1802,21 +2781,122 @@ export interface Store {
   delCell(tableId: Id, rowId: Id, cellId: Id, forceDel?: boolean): Store;
 
   /**
-   * The delSchema method lets you remove the Schema of the Store.
+   * The delValues method lets you remove all the Values from a 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.
    *
    * @returns A reference to the Store.
    * @example
-   * This example removes the Schema of a Store.
+   * This example removes all Values from a Store without a ValuesSchema.
    *
    * ```js
-   * const store = createStore().setSchema({pets: {species: {type: 'string'}}});
-   * store.delSchema();
-   * console.log(store.getSchemaJson());
+   * const store = createStore().setValues({open: true, employees: 3});
+   * store.delValues();
+   *
+   * console.log(store.getValues());
+   * // -> {}
+   * ```
+   * @example
+   * This example removes all Values from a Store with a ValuesSchema that
+   * defaults one of its values.
+   *
+   * ```js
+   * const store = createStore()
+   *   .setValues({open: true, employees: 3})
+   *   .setValuesSchema({
+   *     open: {type: 'boolean', default: false},
+   *     employees: {type: 'number'},
+   *   });
+   * store.delValues();
+   *
+   * console.log(store.getValues());
+   * // -> {open: false}
+   * ```
+   * @category Deleter
+   * @since v3.0.0
+   */
+  delValues(): Store;
+
+  /**
+   * The delValue method lets you remove a single Value from a 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.
+   *
+   * @param valueId The Id of the Value in the Row.
+   * @returns A reference to the Store.
+   * @example
+   * This example removes a Value from a Store without a ValuesSchema.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * store.delValue('employees');
+   *
+   * console.log(store.getValues());
+   * // -> {open: true}
+   * ```
+   * @example
+   * This example removes a Value from a Store with a ValuesSchema that defaults
+   * its value.
+   *
+   * ```js
+   * const store = createStore()
+   *   .setValues({open: true, employees: 3})
+   *   .setValuesSchema({
+   *     open: {type: 'boolean', default: false},
+   *     employees: {type: 'number'},
+   *   });
+   * store.delValue('open');
+   *
+   * console.log(store.getValues());
+   * // -> {open: false, employees: 3}
+   * ```
+   * @category Deleter
+   * @since v3.0.0
+   */
+  delValue(valueId: Id): Store;
+
+  /**
+   * The delTablesSchema method lets you remove the TablesSchema of the Store.
+   *
+   * @returns A reference to the Store.
+   * @example
+   * This example removes the TablesSchema of a Store.
+   *
+   * ```js
+   * const store = createStore().setTablesSchema({
+   *   pets: {species: {type: 'string'}},
+   * });
+   * store.delTablesSchema();
+   * console.log(store.getTablesSchemaJson());
    * // -> '{}'
    * ```
    * @category Deleter
    */
-  delSchema(): Store;
+  delTablesSchema(): Store;
+
+  /**
+   * The delValuesSchema method lets you remove the ValuesSchema of the Store.
+   *
+   * @returns A reference to the Store.
+   * @example
+   * This example removes the ValuesSchema of a Store.
+   *
+   * ```js
+   * const store = createStore().setValuesSchema({
+   *   sold: {type: 'boolean', default: false},
+   * });
+   * store.delValuesSchema();
+   * console.log(store.getValuesSchemaJson());
+   * // -> '{}'
+   * ```
+   * @category Deleter
+   * @since v3.0.0
+   */
+  delValuesSchema(): Store;
 
   /**
    * The transaction method takes a function that makes multiple mutations to
@@ -1840,11 +2920,12 @@ export interface Store {
    * Transactions can be nested. Relevant listeners will be called only when the
    * outermost one completes.
    *
-   * The second, optional parameter, `doRollback` is a callback that you can use
-   * to rollback the transaction if it did not complete to your satisfaction. It
-   * is called with `changedCells` and `invalidCells` parameters, which inform
-   * you of the net changes that have been made during the transaction, and any
-   * invalid attempts to do so, respectively.
+   * The second, 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
+   * attempts to do so, respectively.
    *
    * @param actions The function to be executed as a transaction.
    * @param doRollback An optional callback that should return `true` if you
@@ -1859,15 +2940,17 @@ export interface Store {
    * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
    * store.addRowListener('pets', 'fido', () => console.log('Fido changed'));
    *
-   * store.setCell('pets', 'fido', 'color', 'brown');
-   * store.setCell('pets', 'fido', 'sold', false);
+   * store
+   *   .setCell('pets', 'fido', 'color', 'brown')
+   *   .setCell('pets', 'fido', 'sold', false);
    * // -> 'Fido changed'
    * // -> 'Fido changed'
    *
-   * store.transaction(() => {
-   *   store.setCell('pets', 'fido', 'color', 'walnut');
-   *   store.setCell('pets', 'fido', 'sold', true);
-   * });
+   * store.transaction(() =>
+   *   store
+   *     .setCell('pets', 'fido', 'color', 'walnut')
+   *     .setCell('pets', 'fido', 'sold', true),
+   * );
    * // -> 'Fido changed'
    * ```
    * @example
@@ -1884,60 +2967,64 @@ export interface Store {
    *   (store, tableId, rowId, cellId, newCell) => console.log(newCell),
    * );
    *
-   * store.transaction(() => {
-   *   store.setCell('pets', 'fido', 'color', 'black');
-   *   store.setCell('pets', 'fido', 'color', 'brown');
-   *   store.setCell('pets', 'fido', 'color', 'walnut');
-   * });
+   * store.transaction(() =>
+   *   store
+   *     .setCell('pets', 'fido', 'color', 'black')
+   *     .setCell('pets', 'fido', 'color', 'brown')
+   *     .setCell('pets', 'fido', 'color', 'walnut'),
+   * );
    * // -> 'walnut'
    *
-   * store.transaction(() => {
-   *   store.setCell('pets', 'fido', 'color', 'black');
-   *   store.setCell('pets', 'fido', 'color', 'walnut');
-   * });
+   * store.transaction(() =>
+   *   store
+   *     .setCell('pets', 'fido', 'color', 'black')
+   *     .setCell('pets', 'fido', 'color', 'walnut'),
+   * );
    * // -> undefined
    * // No net change during the transaction, so the listener is not called.
    * ```
-   * @example
-   * This example makes multiple changes to the Store, including some attempts
-   * to update a Cell with invalid values. The `doRollback` callback receives
-   * information about the changes and invalid attempts, and then judges that
-   * the transaction should be rolled back to its original state.
+   * @example
+   * This example makes multiple changes to the Store, including some attempts
+   * to update a Cell and Value with invalid values. The `doRollback` callback
+   * receives information about the changes and invalid attempts, and then
+   * judges that the transaction should be rolled back to its original state.
    *
    * ```js
-   * const store = createStore().setTables({
-   *   pets: {fido: {species: 'dog', color: 'brown'}},
-   * });
+   * const store = createStore()
+   *   .setTables({pets: {fido: {species: 'dog', color: 'brown'}}})
+   *   .setValues({open: true});
    *
    * store.transaction(
-   *   () => {
-   *     store.setCell('pets', 'fido', 'color', 'black');
-   *     store.setCell('pets', 'fido', 'eyes', ['left', 'right']);
-   *     store.setCell('pets', 'fido', 'info', {sold: null});
-   *   },
-   *   (changedCells, invalidCells) => {
+   *   () =>
+   *     store
+   *       .setCell('pets', 'fido', 'color', 'black')
+   *       .setCell('pets', 'fido', 'eyes', ['left', 'right'])
+   *       .setCell('pets', 'fido', 'info', {sold: null})
+   *       .setValue('open', false)
+   *       .setValue('employees', ['alice', 'bob']),
+   *   (changedCells, invalidCells, changedValues, invalidValues) => {
    *     console.log(store.getTables());
-   *     // -> {pets: {fido: {species: 'dog', color: 'black'}}}
    *     console.log(changedCells);
-   *     // -> {pets: {fido: {color: ['brown', 'black']}}}
    *     console.log(invalidCells);
-   *     // -> {pets: {fido: {eyes: [['left', 'right']], info: [{sold: null}]}}}
+   *     console.log(changedValues);
+   *     console.log(invalidValues);
    *     return invalidCells['pets'] != null;
    *   },
    * );
+   * // -> {pets: {fido: {species: 'dog', color: 'black'}}}
+   * // -> {pets: {fido: {color: ['brown', 'black']}}}
+   * // -> {pets: {fido: {eyes: [['left', 'right']], info: [{sold: null}]}}}
+   * // -> {open: [true, false]}
+   * // -> {employees: [['alice', 'bob']]}
    *
    * console.log(store.getTables());
    * // -> {pets: {fido: {species: 'dog', color: 'brown'}}}
+   * console.log(store.getValues());
+   * // -> {open: true}
    * ```
    * @category Transaction
    */
-  transaction<Return>(
-    actions: () => Return,
-    doRollback?: (
-      changedCells: ChangedCells,
-      invalidCells: InvalidCells,
-    ) => boolean,
-  ): Return;
+  transaction<Return>(actions: () => Return, doRollback?: DoRollback): Return;
 
   /**
    * The startTransaction method allows you to explicitly start a transaction
@@ -1972,15 +3059,17 @@ export interface Store {
    * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
    * store.addRowListener('pets', 'fido', () => console.log('Fido changed'));
    *
-   * store.setCell('pets', 'fido', 'color', 'brown');
-   * store.setCell('pets', 'fido', 'sold', false);
+   * store
+   *   .setCell('pets', 'fido', 'color', 'brown')
+   *   .setCell('pets', 'fido', 'sold', false);
    * // -> 'Fido changed'
    * // -> 'Fido changed'
    *
-   * store.startTransaction();
-   * store.setCell('pets', 'fido', 'color', 'walnut');
-   * store.setCell('pets', 'fido', 'sold', true);
-   * store.finishTransaction();
+   * store
+   *   .startTransaction()
+   *   .setCell('pets', 'fido', 'color', 'walnut')
+   *   .setCell('pets', 'fido', 'sold', true)
+   *   .finishTransaction();
    * // -> 'Fido changed'
    * ```
    * @category Transaction
@@ -2010,6 +3099,13 @@ 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
+   * 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
+   * attempts to do so, respectively.
+   *
    * @param doRollback An optional callback that should return `true` if you
    * want to rollback the transaction at the end.
    * @returns A reference to the Store.
@@ -2022,15 +3118,17 @@ export interface Store {
    * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
    * store.addRowListener('pets', 'fido', () => console.log('Fido changed'));
    *
-   * store.setCell('pets', 'fido', 'color', 'brown');
-   * store.setCell('pets', 'fido', 'sold', false);
+   * store
+   *   .setCell('pets', 'fido', 'color', 'brown')
+   *   .setCell('pets', 'fido', 'sold', false);
    * // -> 'Fido changed'
    * // -> 'Fido changed'
    *
-   * store.startTransaction();
-   * store.setCell('pets', 'fido', 'color', 'walnut');
-   * store.setCell('pets', 'fido', 'sold', true);
-   * store.finishTransaction();
+   * store
+   *   .startTransaction()
+   *   .setCell('pets', 'fido', 'color', 'walnut')
+   *   .setCell('pets', 'fido', 'sold', true)
+   *   .finishTransaction();
    * // -> 'Fido changed'
    * ```
    * @example
@@ -2040,36 +3138,42 @@ export interface Store {
    * the transaction should be rolled back to its original state.
    *
    * ```js
-   * const store = createStore().setTables({
-   *   pets: {fido: {species: 'dog', color: 'brown'}},
-   * });
-   *
-   * store.startTransaction();
-   * store.setCell('pets', 'fido', 'color', 'black');
-   * store.setCell('pets', 'fido', 'eyes', ['left', 'right']);
-   * store.setCell('pets', 'fido', 'info', {sold: null});
-   * store.finishTransaction((changedCells, invalidCells) => {
-   *   console.log(store.getTables());
-   *   // -> {pets: {fido: {species: 'dog', color: 'black'}}}
-   *   console.log(changedCells);
-   *   // -> {pets: {fido: {color: ['brown', 'black']}}}
-   *   console.log(invalidCells);
-   *   // -> {pets: {fido: {eyes: [['left', 'right']], info: [{sold: null}]}}}
-   *   return invalidCells['pets'] != null;
-   * });
+   * const store = createStore()
+   *   .setTables({pets: {fido: {species: 'dog', color: 'brown'}}})
+   *   .setValues({open: true});
+   *
+   * store
+   *   .startTransaction()
+   *   .setCell('pets', 'fido', 'color', 'black')
+   *   .setCell('pets', 'fido', 'eyes', ['left', 'right'])
+   *   .setCell('pets', 'fido', 'info', {sold: null})
+   *   .setValue('open', false)
+   *   .setValue('employees', ['alice', 'bob'])
+   *   .finishTransaction(
+   *     (changedCells, invalidCells, changedValues, invalidValues) => {
+   *       console.log(store.getTables());
+   *       console.log(changedCells);
+   *       console.log(invalidCells);
+   *       console.log(changedValues);
+   *       console.log(invalidValues);
+   *       return invalidCells['pets'] != null;
+   *     },
+   *   );
+   * // -> {pets: {fido: {species: 'dog', color: 'black'}}}
+   * // -> {pets: {fido: {color: ['brown', 'black']}}}
+   * // -> {pets: {fido: {eyes: [['left', 'right']], info: [{sold: null}]}}}
+   * // -> {open: [true, false]}
+   * // -> {employees: [['alice', 'bob']]}
    *
    * console.log(store.getTables());
    * // -> {pets: {fido: {species: 'dog', color: 'brown'}}}
+   * console.log(store.getValues());
+   * // -> {open: true}
    * ```
    * @category Transaction
    * @since v1.3.0
    */
-  finishTransaction(
-    doRollback?: (
-      changedCells: ChangedCells,
-      invalidCells: InvalidCells,
-    ) => boolean,
-  ): Store;
+  finishTransaction(doRollback?: DoRollback): Store;
 
   /**
    * The forEachTable method takes a function that it will then call for each
@@ -2167,6 +3271,31 @@ export interface Store {
    */
   forEachCell(tableId: Id, rowId: Id, cellCallback: CellCallback): void;
 
+  /**
+   * The forEachValue method takes a function that it will then call for each
+   * Value in a Store.
+   *
+   * 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.
+   *
+   * @param valueCallback The function that should be called for every Value.
+   * @example
+   * This example iterates over each Value in a Store, and lists its value.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * store.forEachValue((valueId, value) => {
+   *   console.log(`${valueId}: ${value}`);
+   * });
+   * // -> 'open: true'
+   * // -> 'employees: 3'
+   * ```
+   * @category Iterator
+   * @since v3.0.0
+   */
+  forEachValue(valueCallback: ValueCallback): void;
+
   /**
    * The addTablesListener method registers a listener function with the Store
    * that will be called whenever data in the Store changes.
@@ -2873,76 +4002,314 @@ export interface Store {
    * store.delListener(listenerId);
    * ```
    * @example
-   * This example registers a listener that responds to any change to the Cell
-   * Ids of any Row.
+   * This example registers a listener that responds to any change to the Cell
+   * Ids of any Row.
+   *
+   * ```js
+   * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
+   * const listenerId = store.addCellIdsListener(
+   *   null,
+   *   null,
+   *   (store, tableId, rowId) => {
+   *     console.log(`Cell Ids for ${rowId} row in ${tableId} table changed`);
+   *     console.log(store.getCellIds(tableId, rowId));
+   *   },
+   * );
+   *
+   * store.setCell('pets', 'fido', 'color', 'brown');
+   * // -> 'Cell Ids for fido row in pets table changed'
+   * // -> ['species', 'color']
+   * store.setCell('species', 'dog', 'price', 5);
+   * // -> 'Cell Ids for dog row in species table changed'
+   * // -> ['price']
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any change to the Cell
+   * Ids of a specific Row, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
+   * const listenerId = store.addCellIdsListener(
+   *   'pets',
+   *   'fido',
+   *   (store, tableId, rowId) =>
+   *     store.setCell('meta', 'update', `${tableId}_${rowId}`, true),
+   *   true, // mutator
+   * );
+   *
+   * store.setCell('pets', 'fido', 'color', 'brown');
+   * console.log(store.getTable('meta'));
+   * // -> {update: {pets_fido: true}}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   */
+  addCellIdsListener(
+    tableId: IdOrNull,
+    rowId: IdOrNull,
+    listener: CellIdsListener,
+    mutator?: boolean,
+  ): Id;
+
+  /**
+   * The addCellListener method registers a listener function with the Store
+   * that will be called whenever data in a Cell changes.
+   *
+   * 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
+   * Cell value, and a GetCellChange function in case you need to inspect any
+   * changes that occurred.
+   *
+   * You can either listen to a single Cell (by specifying the Table Id, Row Id,
+   * and Cell Id as the method's first three parameters) or changes to any Cell
+   * (by providing `null` wildcards).
+   *
+   * All, some, or none of the `tableId`, `rowId`, and `cellId` parameters can
+   * be wildcarded with `null`. You can listen to a specific Cell in a specific
+   * Row in a specific Table, any Cell in any Row in any Table, for example - or
+   * every other combination of wildcards.
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   *
+   * @param tableId The Id of the Table to listen to, or `null` as a wildcard.
+   * @param rowId The Id of the Row to listen to, or `null` as a wildcard.
+   * @param cellId The Id of the Cell to listen to, or `null` as a wildcard.
+   * @param listener The function that will be called whenever data in the
+   * matching Cell changes.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to any changes to a
+   * specific Cell.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addCellListener(
+   *   'pets',
+   *   'fido',
+   *   'color',
+   *   (store, tableId, rowId, cellId, newCell, oldCell, getCellChange) => {
+   *     console.log('color cell in fido row in pets table changed');
+   *     console.log([oldCell, newCell]);
+   *     console.log(getCellChange('pets', 'fido', 'color'));
+   *   },
+   * );
+   *
+   * store.setCell('pets', 'fido', 'color', 'walnut');
+   * // -> 'color cell in fido row in pets table changed'
+   * // -> ['brown', 'walnut']
+   * // -> [true, 'brown', 'walnut']
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any changes to any Cell.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addCellListener(
+   *   null,
+   *   null,
+   *   null,
+   *   (store, tableId, rowId, cellId) => {
+   *     console.log(
+   *       `${cellId} cell in ${rowId} row in ${tableId} table changed`,
+   *     );
+   *   },
+   * );
+   *
+   * store.setCell('pets', 'fido', 'color', 'walnut');
+   * // -> 'color cell in fido row in pets table changed'
+   * store.setTable('species', {dog: {price: 5}});
+   * // -> 'price cell in dog row in species table changed'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any changes to a
+   * specific Cell, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addCellListener(
+   *   'pets',
+   *   'fido',
+   *   'color',
+   *   (store, tableId, rowId, cellId) =>
+   *     store.setCell('meta', 'update', `${tableId}_${rowId}_${cellId}`, true),
+   *   true,
+   * );
+   *
+   * store.delCell('pets', 'fido', 'color');
+   * console.log(store.getTable('meta'));
+   * // -> {update: {pets_fido_color: true}}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   */
+  addCellListener(
+    tableId: IdOrNull,
+    rowId: IdOrNull,
+    cellId: IdOrNull,
+    listener: CellListener,
+    mutator?: boolean,
+  ): Id;
+
+  /**
+   * The addValuesListener method registers a listener function with the Store
+   * that will be called whenever the Values change.
+   *
+   * 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.
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   *
+   * @param listener The function that will be called whenever data in the
+   * Values changes.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to any changes to the
+   * Store's Values.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * const listenerId = store.addValuesListener((store, getValueChange) => {
+   *   console.log('values changed');
+   *   console.log(getValueChange('employees'));
+   * });
+   *
+   * store.setValue('employees', 4);
+   * // -> 'values changed'
+   * // -> [true, 3, 4]
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any changes to the
+   * Store's Values, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * const listenerId = store.addValuesListener(
+   *   (store, getValueChange) => store.setValue('updated', true),
+   *   true,
+   * );
+   *
+   * store.setValue('employees', 4);
+   * console.log(store.getValues());
+   * // -> {open: true, employees: 4, updated: true}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v3.0.0
+   */
+  addValuesListener(listener: ValuesListener, mutator?: boolean): Id;
+
+  /**
+   * The addValueIdsListener method registers a listener function with the Store
+   * that will be called whenever the Value Ids in a Store change.
+   *
+   * The provided listener is a ValueIdsListener function, and will be called
+   * with a reference to the Store.
+   *
+   * By default, such a listener is only called when a Value is added or
+   * removed. To listen to all changes in the Values, use the addValuesListener
+   * method.
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   *
+   * @param listener The function that will be called whenever the Value Ids in
+   * the Store change.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to any change to the Value
+   * Ids.
    *
    * ```js
-   * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
-   * const listenerId = store.addCellIdsListener(
-   *   null,
-   *   null,
-   *   (store, tableId, rowId) => {
-   *     console.log(`Cell Ids for ${rowId} row in ${tableId} table changed`);
-   *     console.log(store.getCellIds(tableId, rowId));
-   *   },
-   * );
+   * const store = createStore().setValues({open: true});
+   * const listenerId = store.addValueIdsListener((store) => {
+   *   console.log('Value Ids changed');
+   *   console.log(store.getValueIds());
+   * });
    *
-   * store.setCell('pets', 'fido', 'color', 'brown');
-   * // -> 'Cell Ids for fido row in pets table changed'
-   * // -> ['species', 'color']
-   * store.setCell('species', 'dog', 'price', 5);
-   * // -> 'Cell Ids for dog row in species table changed'
-   * // -> ['price']
+   * store.setValue('employees', 3);
+   * // -> 'Value Ids changed'
+   * // -> ['open', 'employees']
    *
    * store.delListener(listenerId);
    * ```
    * @example
-   * This example registers a listener that responds to any change to the Cell
-   * Ids of a specific Row, and which also mutates the Store itself.
+   * This example registers a listener that responds to any change to the Value
+   * Ids, and which also mutates the Store itself.
    *
    * ```js
-   * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
-   * const listenerId = store.addCellIdsListener(
-   *   'pets',
-   *   'fido',
-   *   (store, tableId, rowId) =>
-   *     store.setCell('meta', 'update', `${tableId}_${rowId}`, true),
+   * const store = createStore().setValues({open: true});
+   * const listenerId = store.addValueIdsListener(
+   *   (store) => store.setValue('updated', true),
    *   true, // mutator
    * );
    *
-   * store.setCell('pets', 'fido', 'color', 'brown');
-   * console.log(store.getTable('meta'));
-   * // -> {update: {pets_fido: true}}
+   * store.setValue('employees', 3);
+   * console.log(store.getValues());
+   * // -> {open: true, employees: 3, updated: true}
    *
    * store.delListener(listenerId);
    * ```
    * @category Listener
+   * @since v3.0.0
    */
-  addCellIdsListener(
-    tableId: IdOrNull,
-    rowId: IdOrNull,
-    listener: CellIdsListener,
-    mutator?: boolean,
-  ): Id;
+  addValueIdsListener(listener: ValueIdsListener, mutator?: boolean): Id;
 
   /**
-   * The addCellListener method registers a listener function with the Store
-   * that will be called whenever data in a Cell changes.
-   *
-   * 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
-   * Cell value, and a GetCellChange function in case you need to inspect any
-   * changes that occurred.
+   * The addValueListener method registers a listener function with the Store
+   * that will be called whenever data in a Value changes.
    *
-   * You can either listen to a single Cell (by specifying the Table Id, Row Id,
-   * and Cell Id as the method's first three parameters) or changes to any Cell
-   * (by providing `null` wildcards).
+   * 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
+   * inspect any changes that occurred.
    *
-   * All, some, or none of the `tableId`, `rowId`, and `cellId` parameters can
-   * be wildcarded with `null`. You can listen to a specific Cell in a specific
-   * Row in a specific Table, any Cell in any Row in any Table, for example - or
-   * every other combination of wildcards.
+   * You can either listen to a single Value (by specifying the Value Id) or
+   * changes to any Value (by providing a `null` wildcard).
    *
    * Use the optional mutator parameter to indicate that there is code in the
    * listener that will mutate Store data. If set to `false` (or omitted), such
@@ -2952,95 +4319,75 @@ export interface Store {
    * The changes made by mutator listeners do not fire other mutating listeners,
    * though they will fire non-mutator listeners.
    *
-   * @param tableId The Id of the Table to listen to, or `null` as a wildcard.
-   * @param rowId The Id of the Row to listen to, or `null` as a wildcard.
-   * @param cellId The Id of the Cell to listen to, or `null` as a wildcard.
+   * @param valueId The Id of the Value to listen to, or `null` as a wildcard.
    * @param listener The function that will be called whenever data in the
-   * matching Cell changes.
+   * matching Value changes.
    * @param mutator An optional boolean that indicates that the listener mutates
    * Store data.
    * @returns A unique Id for the listener that can later be used to call it
    * explicitly, or to remove it.
    * @example
    * This example registers a listener that responds to any changes to a
-   * specific Cell.
+   * specific Value.
    *
    * ```js
-   * const store = createStore().setTables({
-   *   pets: {fido: {species: 'dog', color: 'brown'}},
-   * });
-   * const listenerId = store.addCellListener(
-   *   'pets',
-   *   'fido',
-   *   'color',
-   *   (store, tableId, rowId, cellId, newCell, oldCell, getCellChange) => {
-   *     console.log('color cell in fido row in pets table changed');
-   *     console.log([oldCell, newCell]);
-   *     console.log(getCellChange('pets', 'fido', 'color'));
+   * const store = createStore().setValues({open: true, employees: 3});
+   * const listenerId = store.addValueListener(
+   *   'employees',
+   *   (store, valueId, newValue, oldValue, getValueChange) => {
+   *     console.log('employee value changed');
+   *     console.log([oldValue, newValue]);
+   *     console.log(getValueChange('employees'));
    *   },
    * );
    *
-   * store.setCell('pets', 'fido', 'color', 'walnut');
-   * // -> 'color cell in fido row in pets table changed'
-   * // -> ['brown', 'walnut']
-   * // -> [true, 'brown', 'walnut']
+   * store.setValue('employees', 4);
+   * // -> 'employee value changed'
+   * // -> [3, 4]
+   * // -> [true, 3, 4]
    *
    * store.delListener(listenerId);
    * ```
    * @example
-   * This example registers a listener that responds to any changes to any Cell.
+   * This example registers a listener that responds to any changes to any
+   * Value.
    *
    * ```js
-   * const store = createStore().setTables({
-   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * const store = createStore().setValues({open: true, employees: 3});
+   * const listenerId = store.addValueListener(null, (store, valueId) => {
+   *   console.log(`${valueId} value changed`);
    * });
-   * const listenerId = store.addCellListener(
-   *   null,
-   *   null,
-   *   null,
-   *   (store, tableId, rowId, cellId) => {
-   *     console.log(
-   *       `${cellId} cell in ${rowId} row in ${tableId} table changed`,
-   *     );
-   *   },
-   * );
    *
-   * store.setCell('pets', 'fido', 'color', 'walnut');
-   * // -> 'color cell in fido row in pets table changed'
-   * store.setTable('species', {dog: {price: 5}});
-   * // -> 'price cell in dog row in species table changed'
+   * store.setValue('employees', 4);
+   * // -> 'employees value changed'
+   * store.setValue('open', false);
+   * // -> 'open value changed'
    *
    * store.delListener(listenerId);
    * ```
    * @example
    * This example registers a listener that responds to any changes to a
-   * specific Cell, and which also mutates the Store itself.
+   * specific Value, and which also mutates the Store itself.
    *
    * ```js
-   * const store = createStore().setTables({
-   *   pets: {fido: {species: 'dog', color: 'brown'}},
-   * });
-   * const listenerId = store.addCellListener(
-   *   'pets',
-   *   'fido',
-   *   'color',
-   *   (store, tableId, rowId, cellId) =>
-   *     store.setCell('meta', 'update', `${tableId}_${rowId}_${cellId}`, true),
+   * const store = createStore().setValues({open: true, employees: 3});
+   * const listenerId = store.addValueListener(
+   *   'employees',
+   *   (store, valueId) => store.setValue('updated', true),
    *   true,
    * );
    *
-   * store.delCell('pets', 'fido', 'color');
-   * console.log(store.getTable('meta'));
-   * // -> {update: {pets_fido_color: true}}
+   * store.delValue('employees');
+   * console.log(store.getValues());
+   * // -> {open: true, updated: true}
    *
    * store.delListener(listenerId);
    * ```
    * @category Listener
+   * @since v3.0.0
    */
-  addCellListener(
-    tableId: IdOrNull,
-    rowId: IdOrNull,
-    cellId: IdOrNull,
+  addValueListener(
+    valueId: IdOrNull,
     listener: CellListener,
     mutator?: boolean,
   ): Id;
@@ -3052,7 +4399,7 @@ export interface Store {
    *
    * 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 were being attempted to be changed. It is also
+   * Row, and the Id of Cell that was being attempted to be changed. It is also
    * given the invalid value of the Cell, which could have been of absolutely
    * any type. Since there could have been multiple failed attempts to set the
    * Cell within a single transaction, this is an array containing each attempt,
@@ -3076,19 +4423,20 @@ export interface Store {
    * though they will fire non-mutator listeners.
    *
    * Special note should be made for how the listener will be called when a
-   * Schema is present. The listener will be called:
+   * TablesSchema is present. The listener will be called:
    *
-   * - if a Table is being updated that is not specified in the Schema
-   * - if a Cell is of the wrong type specified in the Schema
-   * - if a Cell is omitted and is not defaulted in the Schema
-   * - if an empty Row is provided and there are no Cell defaults in the Schema
+   * - if a Table is being updated that is not specified in the TablesSchema
+   * - if a Cell is of the wrong type specified in the TablesSchema
+   * - if a Cell is omitted and is not defaulted in the TablesSchema
+   * - if an empty Row is provided and there are no Cell defaults in the
+   *   TablesSchema
    *
-   * The listener will not be called if Cell that is defaulted in the Schema is
-   * not provided, as long as all of the Cells that are _not_ defaulted _are_
-   * provided.
+   * The listener will not be called if a Cell that is defaulted in the
+   * TablesSchema is not provided, as long as all of the Cells that are _not_
+   * defaulted _are_ provided.
    *
    * To help understand all of these schema-based conditions, please see the
-   * Schema example below.
+   * TablesSchema example below.
    *
    * @param tableId The Id of the Table to listen to, or `null` as a wildcard.
    * @param rowId The Id of the Row to listen to, or `null` as a wildcard.
@@ -3125,9 +4473,9 @@ export interface Store {
    * ```
    * @example
    * This example registers a listener that responds to any invalid changes to
-   * any Cell - in a Store _without_ a Schema. Note also how it then responds to
-   * cases where an empty or invalid Row objects, or Table objects, or Tables
-   * objects are provided.
+   * any Cell - in a Store _without_ a TablesSchema. Note also how it then
+   * responds to cases where empty or invalid Row objects, or Table objects,
+   * or Tables objects are provided.
    *
    * ```js
    * const store = createStore().setTables({
@@ -3174,12 +4522,12 @@ export interface Store {
    * ```
    * @example
    * This example registers a listener that responds to any invalid changes to
-   * any Cell - in a Store _with_ a Schema. Note how it responds to cases where
-   * missing parameters are provided for optional, and defaulted Cell values in
-   * a Row.
+   * any Cell - in a Store _with_ a TablesSchema. Note how it responds to cases
+   * where missing parameters are provided for optional, and defaulted Cell
+   * values in a Row.
    *
    * ```js
-   * const store = createStore().setSchema({
+   * const store = createStore().setTablesSchema({
    *   pets: {
    *     species: {type: 'string'},
    *     color: {type: 'string', default: 'unknown'},
@@ -3220,7 +4568,7 @@ export interface Store {
    * // -> {species: 'dog', color: 'unknown'}
    * // The listener is not called, because color is defaulted
    *
-   * store.delTables().setSchema({
+   * store.delTables().setTablesSchema({
    *   pets: {
    *     species: {type: 'string'},
    *     color: {type: 'string'},
@@ -3275,6 +4623,182 @@ export interface Store {
     mutator?: boolean,
   ): Id;
 
+  /**
+   * The addInvalidValueListener method registers a listener function with the
+   * Store that will be called whenever invalid data was attempted to be written
+   * to a Value.
+   *
+   * 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,
+   * which could have been of absolutely any type. Since there could have been
+   * multiple failed attempts to set the Value within a single transaction, this
+   * is an array containing each attempt, chronologically.
+   *
+   * You can either listen to a single Value (by specifying the Value Id as the
+   * method's first parameter) or invalid attempts to change any Value (by
+   * providing a `null` wildcard).
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   *
+   * Special note should be made for how the listener will be called when a
+   * ValuesSchema is present. The listener will be called:
+   *
+   * - if a Value is being updated that is not specified in the ValuesSchema
+   * - if a Value is of the wrong type specified in the ValuesSchema
+   * - if a Value is omitted when using setValues that is not defaulted in the
+   *   ValuesSchema
+   *
+   * The listener will not be called if a Value that is defaulted in the
+   * ValuesSchema is not provided, as long as all of the Values that are _not_
+   * defaulted _are_ provided.
+   *
+   * To help understand all of these schema-based conditions, please see the
+   * ValuesSchema example below.
+   *
+   * @param valueId The Id of the Value to listen to, or `null` as a wildcard.
+   * @param listener The function that will be called whenever an attempt to
+   * write invalid data to the matching Value was made.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to any invalid changes to a
+   * specific Value.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true});
+   * const listenerId = store.addInvalidValueListener(
+   *   'open',
+   *   (store, valueId, invalidValues) => {
+   *     console.log('Invalid open value');
+   *     console.log(invalidValues);
+   *   },
+   * );
+   *
+   * store.setValue('open', {yes: true});
+   * // -> 'Invalid open value'
+   * // -> [{yes: true}]
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any invalid changes to
+   * any Value - in a Store _without_ a ValuesSchema. Note also how it then
+   * responds to cases where an empty Values object is provided.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true});
+   * const listenerId = store.addInvalidValueListener(
+   *   null,
+   *   (store, valueId) => {
+   *     console.log(`Invalid ${valueId} value`);
+   *   },
+   * );
+   *
+   * store.setValue('open', {yes: true});
+   * // -> 'Invalid open value'
+   * store.setValue('employees', ['alice', 'bob']);
+   * // -> 'Invalid employees value'
+   *
+   * store.setValues('pets', 'felix', {});
+   * // -> 'Invalid undefined value'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any invalid changes to
+   * any Value - in a Store _with_ a ValuesSchema. Note how it responds to cases
+   * where missing parameters are provided for optional, and defaulted Values.
+   *
+   * ```js
+   * const store = createStore().setValuesSchema({
+   *   open: {type: 'boolean', default: false},
+   *   employees: {type: 'number'},
+   * });
+   *
+   * console.log(store.getValues());
+   * // -> {open: false}
+   *
+   * const listenerId = store.addInvalidValueListener(
+   *   null,
+   *   (store, valueId) => {
+   *     console.log(`Invalid ${valueId} value`);
+   *   },
+   * );
+   *
+   * store.setValue('website', true);
+   * // -> 'Invalid website value'
+   * // The listener is called, because the website Value is not in the schema
+   *
+   * store.setValue('open', 'yes');
+   * // -> 'Invalid open value'
+   * // The listener is called, because 'open' is invalid...
+   * console.log(store.getValues());
+   * // -> {open: false}
+   * // ...even though it is still present with the default value
+   *
+   * store.setValues({open: true});
+   * // -> 'Invalid employees value'
+   * // The listener is called because employees is missing and not defaulted...
+   * console.log(store.getValues());
+   * // -> {open: true}
+   * // ...even though the Values were set
+   *
+   * store.setValues({employees: 3});
+   * console.log(store.getValues());
+   * // -> {open: false, employees: 3}
+   * // The listener is not called, because 'open' is defaulted
+   *
+   * store.setValuesSchema({
+   *   open: {type: 'boolean'},
+   *   employees: {type: 'number'},
+   * });
+   *
+   * store.setValues({});
+   * // -> 'Invalid open value'
+   * // -> 'Invalid employees value'
+   * // -> 'Invalid undefined value'
+   * // The listener is called multiple times, because neither Value is
+   * // defaulted and the Values as a whole were empty
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any changes to a
+   * specific Value, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true});
+   * const listenerId = store.addInvalidValueListener(
+   *   'open',
+   *   (store, valueId, invalidValues) =>
+   *     store.setValue('invalid_updates', JSON.stringify(invalidValues[0])),
+   *   true,
+   * );
+   *
+   * store.setValue('open', {yes: true});
+   * console.log(store.getValue('invalid_updates'));
+   * // -> '{"yes":true}'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v3.0.0
+   */
+  addInvalidValueListener(
+    valueId: IdOrNull,
+    listener: InvalidValueListener,
+    mutator?: boolean,
+  ): Id;
+
   /**
    * The addWillFinishTransactionListener method registers a listener function
    * with the Store that will be called just before other non-mutating listeners
@@ -3285,59 +4809,82 @@ export interface Store {
    * together.
    *
    * The provided TransactionListener will receive a reference to the Store and
-   * a boolean to indicate whether Cell values have been touched during the
-   * transaction. The latter flag is intended as a hint about whether
+   * two booleans to indicate whether Cell or Value data has been touched during
+   * the transaction. The two flags are intended as a hint about whether
    * non-mutating listeners might be being called at the end of the transaction.
    *
-   * Here, 'touched' means that Cell values have either been changed, or changed
-   * and then changed back to its original value during the transaction. The
-   * exception is a transaction that has been rolled back, for which the value
-   * of `cellsTouched` in the listener will be `false` because all changes have
-   * been reverted.
+   * Here, 'touched' means that Cell or Value data has either been changed, or
+   * changed and then changed back to its original value during the transaction.
+   * The exception is a transaction that has been rolled back, for which the
+   * value of `cellsTouched` and `valuesTouched` in the listener will be `false`
+   * because all changes have been reverted.
    *
    * @returns A unique Id for the listener that can later be used to remove it.
    * @example
    * This example registers a listener that is called at the end of the
    * transaction, just before its listeners will be called. The transactions
    * shown here variously change, touch, and rollback cells, demonstrating how
-   * the `cellsTouched` parameter in the listener works.
+   * the `cellsTouched` and `valuesTouched` parameters in the listener work.
    *
    * ```js
-   * const store = createStore().setTables({
-   *   pets: {fido: {species: 'dog', color: 'brown'}},
-   * });
+   * const store = createStore()
+   *   .setTables({
+   *     pets: {fido: {species: 'dog', color: 'brown'}},
+   *   })
+   *   .setValues({open: true, employees: 3});
    * const listenerId = store.addWillFinishTransactionListener(
-   *   (store, cellsTouched) => console.log(`Cells touched: ${cellsTouched}`),
+   *   (store, cellsTouched, valuesTouched) => {
+   *     console.log(`Cells/Values touched: ${cellsTouched}/${valuesTouched}`);
+   *   },
    * );
    * const listenerId2 = store.addTablesListener(() =>
    *   console.log('Tables changed'),
    * );
+   * const listenerId3 = store.addValuesListener(() =>
+   *   console.log('Values changed'),
+   * );
    *
-   * store.transaction(() => store.setCell('pets', 'fido', 'color', 'brown'));
-   * // -> 'Cells touched: false'
+   * store.transaction(() =>
+   *   store.setCell('pets', 'fido', 'color', 'brown').setValue('employees', 3),
+   * );
+   * // -> 'Cells/Values touched: false/false'
    *
    * store.transaction(() => store.setCell('pets', 'fido', 'color', 'walnut'));
-   * // -> 'Cells touched: true'
+   * // -> 'Cells/Values touched: true/false'
    * // -> 'Tables changed'
    *
+   * store.transaction(() => store.setValue('employees', 4));
+   * // -> 'Cells/Values touched: false/true'
+   * // -> 'Values changed'
+   *
    * store.transaction(() => {
-   *   store.setRow('pets', 'felix', {species: 'cat'});
-   *   store.delRow('pets', 'felix');
+   *   store
+   *     .setRow('pets', 'felix', {species: 'cat'})
+   *     .delRow('pets', 'felix')
+   *     .setValue('city', 'London')
+   *     .delValue('city');
    * });
-   * // -> 'Cells touched: true'
+   * // -> 'Cells/Values touched: true/true'
+   * // But no Tables or Values listeners fired since there are no net changes.
    *
    * store.transaction(
-   *   () => store.setRow('pets', 'fido', {species: 'dog'}),
+   *   () =>
+   *     store
+   *       .setRow('pets', 'felix', {species: 'cat'})
+   *       .setValue('city', 'London'),
    *   () => true,
    * );
-   * // -> 'Cells touched: false'
+   * // -> 'Cells/Values touched: false/false'
    * // Transaction was rolled back.
    *
    * store.callListener(listenerId);
-   * // -> 'Cells touched: undefined'
+   * // -> 'Cells/Values touched: undefined/undefined'
    * // It is meaningless to call this listener directly.
    *
-   * store.delListener(listenerId).delListener(listenerId2);
+   * store
+   *   .delListener(listenerId)
+   *   .delListener(listenerId2)
+   *   .delListener(listenerId3);
    * ```
    * @category Listener
    * @since v1.3.0
@@ -3354,60 +4901,83 @@ export interface Store {
    * together.
    *
    * The provided TransactionListener will receive a reference to the Store and
-   * a boolean to indicate whether Cell values have been touched during the
-   * transaction. The latter flag is intended as a hint about whether
+   * two booleans to indicate whether Cell or Value data has been touched during
+   * the transaction. The two flags is intended as a hint about whether
    * non-mutating listeners might have been called at the end of the
    * transaction.
    *
-   * Here, 'touched' means that Cell values have either been changed, or changed
-   * and then changed back to its original value during the transaction. The
-   * exception is a transaction that has been rolled back, for which the value
-   * of `cellsTouched` in the listener will be `false` because all changes have
-   * been reverted.
+   * Here, 'touched' means that Cell or Value data has either been changed, or
+   * changed and then changed back to its original value during the transaction.
+   * The exception is a transaction that has been rolled back, for which the
+   * value of `cellsTouched` and `valuesTouched` in the listener will be `false`
+   * because all changes have been reverted.
    *
    * @returns A unique Id for the listener that can later be used to remove it.
    * @example
    * This example registers a listener that is called at the end of the
    * transaction, just after its listeners have been called. The transactions
    * shown here variously change, touch, and rollback cells, demonstrating how
-   * the `cellsTouched` parameter in the listener works.
+   * the `cellsTouched` and `valuesTouched` parameters in the listener work.
    *
    * ```js
-   * const store = createStore().setTables({
-   *   pets: {fido: {species: 'dog', color: 'brown'}},
-   * });
+   * const store = createStore()
+   *   .setTables({
+   *     pets: {fido: {species: 'dog', color: 'brown'}},
+   *   })
+   *   .setValues({open: true, employees: 3});
    * const listenerId = store.addDidFinishTransactionListener(
-   *   (store, cellsTouched) => console.log(`Cells touched: ${cellsTouched}`),
+   *   (store, cellsTouched, valuesTouched) => {
+   *     console.log(`Cells/Values touched: ${cellsTouched}/${valuesTouched}`);
+   *   },
    * );
    * const listenerId2 = store.addTablesListener(() =>
    *   console.log('Tables changed'),
    * );
+   * const listenerId3 = store.addValuesListener(() =>
+   *   console.log('Values changed'),
+   * );
    *
-   * store.transaction(() => store.setCell('pets', 'fido', 'color', 'brown'));
-   * // -> 'Cells touched: false'
+   * store.transaction(() =>
+   *   store.setCell('pets', 'fido', 'color', 'brown').setValue('employees', 3),
+   * );
+   * // -> 'Cells/Values touched: false/false'
    *
    * store.transaction(() => store.setCell('pets', 'fido', 'color', 'walnut'));
    * // -> 'Tables changed'
-   * // -> 'Cells touched: true'
+   * // -> 'Cells/Values touched: true/false'
+   *
+   * store.transaction(() => store.setValue('employees', 4));
+   * // -> 'Values changed'
+   * // -> 'Cells/Values touched: false/true'
    *
    * store.transaction(() => {
-   *   store.setRow('pets', 'felix', {species: 'cat'});
-   *   store.delRow('pets', 'felix');
+   *   store
+   *     .setRow('pets', 'felix', {species: 'cat'})
+   *     .delRow('pets', 'felix')
+   *     .setValue('city', 'London')
+   *     .delValue('city');
    * });
-   * // -> 'Cells touched: true'
+   * // -> 'Cells/Values touched: true/true'
+   * // But no Tables or Values listeners fired since there are no net changes.
    *
    * store.transaction(
-   *   () => store.setRow('pets', 'fido', {species: 'dog'}),
+   *   () =>
+   *     store
+   *       .setRow('pets', 'felix', {species: 'cat'})
+   *       .setValue('city', 'London'),
    *   () => true,
    * );
-   * // -> 'Cells touched: false'
+   * // -> 'Cells/Values touched: false/false'
    * // Transaction was rolled back.
    *
    * store.callListener(listenerId);
-   * // -> 'Cells touched: undefined'
+   * // -> 'Cells/Values touched: undefined/undefined'
    * // It is meaningless to call this listener directly.
    *
-   * store.delListener(listenerId).delListener(listenerId2);
+   * store
+   *   .delListener(listenerId)
+   *   .delListener(listenerId2)
+   *   .delListener(listenerId3);
    * ```
    * @category Listener
    * @since v1.3.0
@@ -3458,6 +5028,75 @@ export interface Store {
    *
    * store.delListener(listenerId);
    * ```
+   * @example
+   * This example registers a listener to Row Id changes. It is explicitly
+   * called and fires for two Tables in the Store.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog'}},
+   *   species: {dog: {price: 5}},
+   * });
+   *
+   * const listenerId = store.addRowIdsListener(null, (store, tableId) => {
+   *   console.log(`Row Ids listener called for ${tableId} table`);
+   * });
+   *
+   * store.callListener(listenerId);
+   * // -> 'Row Ids listener called for pets table'
+   * // -> 'Row Ids listener called for species table'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener Value changes. It is explicitly called
+   * and fires for two Values in the Store.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   *
+   * const listenerId = store.addValueListener(
+   *   null,
+   *   (store, valueId, value) => {
+   *     console.log(`Value listener called for ${valueId} value, ${value}`);
+   *   },
+   * );
+   *
+   * store.callListener(listenerId);
+   * // -> 'Value listener called for open value, true'
+   * // -> 'Value listener called for employees value, 3'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers listeners for the end of transactions, and for
+   * invalid Cells. The are explicitly called, meaninglessly. The former
+   * receives empty arguments. The latter is not called at all.
+   *
+   * ```js
+   * const store = createStore();
+   *
+   * const listenerId = store.addWillFinishTransactionListener(
+   *   (store, cellsTouched, valuesTouched) => {
+   *     console.log(`Transaction finish: ${cellsTouched}/${valuesTouched}`);
+   *   },
+   * );
+   * store.callListener(listenerId);
+   * // -> 'Transaction finish: undefined/undefined'
+   * store.delListener(listenerId);
+   *
+   * const listenerId2 = store.addInvalidCellListener(
+   *   null,
+   *   null,
+   *   null,
+   *   (store, tableId, rowId, cellId) => {
+   *     console.log('Invalid cell', tableId, rowId, cellId);
+   *   },
+   * );
+   * store.callListener(listenerId2);
+   * // -> undefined
+   * store.delListener(listenerId2);
+   * ```
    * @category Listener
    */
   callListener(listenerId: Id): Store;
@@ -3552,12 +5191,12 @@ export interface Store {
  * // -> {pets: {fido: {species: 'dog'}}}
  * ```
  * @example
- * This example creates a Store with some initial data and a Schema:
+ * This example creates a Store with some initial data and a TablesSchema:
  *
  * ```js
  * const store = createStore()
  *   .setTables({pets: {fido: {species: 'dog'}}})
- *   .setSchema({
+ *   .setTablesSchema({
  *     pets: {
  *       species: {type: 'string'},
  *       sold: {type: 'boolean', default: false},