tinybase 2.2.6 → 3.0.0-beta.1

package/lib/debug/tools.js

@@ -19,11 +19,19 @@ const arrayShift = (array) => array.shift();
 
 const jsonParse = JSON.parse;
 const isFiniteNumber = isFinite;
+const isInstanceOf = (thing, cls) => thing instanceof cls;
 const isUndefined = (thing) => thing == void 0;
 const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
 const isString = (thing) => getTypeOf(thing) == STRING;
 const isArray = (thing) => Array.isArray(thing);
 
+const getCellOrValueType = (cell) => {
+  const type = getTypeOf(cell);
+  return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
+    ? type
+    : void 0;
+};
+
 const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
 const collValues = (coll) => [...(coll?.values() ?? [])];
 const collForEach = (coll, cb) => coll?.forEach(cb);
@@ -55,6 +63,7 @@ const setAdd = (set, value) => set?.add(value);
 const pairNew = (value) => [value, value];
 const pairNewMap = () => [mapNew(), mapNew()];
 
+const NON_ALPHA = /[^A-Za-z]+/;
 const NON_ALPHANUMERIC = /[^A-Za-z0-9]+/;
 const JSDOC = /^( *)\/\*\* *(.*?) *\*\/$/gm;
 const substr = (str, start, end) => str.substring(start, end);
@@ -92,7 +101,14 @@ const camel = (str, firstCap = 0) =>
     ),
   );
 const snake = (str) =>
-  upper(join((str ? str : ' ').split(NON_ALPHANUMERIC), '_'));
+  upper(
+    join(
+      (str && !NON_ALPHA.test(str[0]) ? str : ' ' + str).split(
+        NON_ALPHANUMERIC,
+      ),
+      '_',
+    ),
+  );
 const comment = (doc) => `/** ${doc}. */`;
 const getCodeFunctions = () => {
   const allImports = pairNewMap();
@@ -104,8 +120,7 @@ const getCodeFunctions = () => {
     arrayForEach(items, (item) =>
       setAdd(mapEnsure(allImports[location], source, setNew), item),
     );
-  const addType = (name, body = '', doc = '') =>
-    mapUnique(types, name, [body, doc]);
+  const addType = (name, body, doc) => mapUnique(types, name, [body, doc]);
   const addMethod = (name, parameters, returnType, body, doc, generic = '') =>
     mapUnique(methods, name, [parameters, returnType, body, doc, generic]);
   const addFunction = (name, parameters, body) =>
@@ -171,16 +186,11 @@ const getCodeFunctions = () => {
 const object = Object;
 const objIds = object.keys;
 const objFreeze = object.freeze;
+const isObject = (obj) =>
+  isInstanceOf(obj, object) && obj.constructor == object;
 const objMap = (obj, cb) =>
   arrayMap(object.entries(obj), ([id, value]) => cb(value, id));
-const objIsEmpty = (obj) => arrayIsEmpty(objIds(obj));
-
-const getCellType = (cell) => {
-  const type = getTypeOf(cell);
-  return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
-    ? type
-    : void 0;
-};
+const objIsEmpty = (obj) => isObject(obj) && arrayIsEmpty(objIds(obj));
 
 const getCreateFunction = (getFunction) => {
   const getFunctionsByStore = /* @__PURE__ */ new WeakMap();
@@ -192,7 +202,6 @@ const getCreateFunction = (getFunction) => {
   };
 };
 
-const THE_CONTENT_OF = 'the content of';
 const THE_STORE = 'the Store';
 const A_FUNCTION_FOR = 'A function for';
 const EXPORT = 'export';
@@ -201,13 +210,17 @@ const OR_UNDEFINED = ' | undefined';
 const REGISTERS_A_LISTENER = `Registers a ${LISTENER} that will be called`;
 const REPRESENTS = 'Represents';
 const RETURNS_VOID = ' => void';
-const THE_CONTENT_OF_THE_STORE = `${THE_CONTENT_OF} ${THE_STORE}`;
 const THE_END_OF_THE_TRANSACTION = 'the end of the transaction';
 const THE_SPECIFIED_ROW = 'the specified Row';
+const A_STRING_SERIALIZATION_OF = 'a string serialization of';
+const getTheContentOfDoc = (content = 0, theStore = 0) =>
+  `the ${CONTENT[content]}content of${theStore ? ` ${THE_STORE}` : ''}`;
+const getTheContentOfTheStoreDoc = (verb, content = 0, set = 0) =>
+  `${VERBS[verb]} ${getTheContentOfDoc(content, 1)}${set ? ' when set' : ''}`;
 const getRowTypeDoc = (tableId, set = 0) =>
   `${REPRESENTS} a Row when ${
     set ? 's' : 'g'
-  }etting ${THE_CONTENT_OF} the '${tableId}' Table`;
+  }etting ${getTheContentOfDoc()} the '${tableId}' Table`;
 const getIdsDoc = (idsNoun, parentNoun, sorted = 0) =>
   `Gets ${
     sorted ? 'sorted, paginated' : 'the'
@@ -217,27 +230,37 @@ const getForEachDoc = (childNoun, parentNoun) =>
 const getHasDoc = (childNoun, parentNoun = THE_STORE) =>
   `Gets whether ${childNoun} exists in ${parentNoun}`;
 const getCallbackDoc = (takes) => `A function that takes ${takes}`;
-const getListenerTypeDoc = (childNoun = 0, parentNoun = 0) =>
-  `${A_FUNCTION_FOR} listening to changes to ${nouns[childNoun]} in ${nouns[parentNoun]}`;
+const getListenerTypeDoc = (childNoun, parentNoun = 0) =>
+  `${A_FUNCTION_FOR} listening to changes to ${NOUNS[childNoun]} in ${NOUNS[parentNoun]}`;
 const getListenerDoc = (childNoun, parentNoun, pluralChild = 0) =>
   `${REGISTERS_A_LISTENER} whenever ${childNoun} in ${parentNoun} change` +
   (pluralChild ? EMPTY_STRING : 's');
-const getStoreContentDoc = (verb = 0) =>
-  `${verbs[verb]} ${THE_CONTENT_OF_THE_STORE}`;
 const getTableDoc = (tableId) => `the '${tableId}' Table`;
 const getRowDoc = (tableId) =>
   `${THE_SPECIFIED_ROW} in ${getTableDoc(tableId)}`;
 const getCellDoc = (cellId) => `the '${cellId}' Cell`;
+const getValueDoc = (valueId) => `the '${valueId}' Value`;
 const getTableContentDoc = (tableId, verb = 0) =>
-  `${verbs[verb]} ${THE_CONTENT_OF} ${getTableDoc(tableId)}`;
+  `${VERBS[verb]} ${getTheContentOfDoc()} ${getTableDoc(tableId)}`;
 const getRowContentDoc = (tableId, verb = 0) =>
-  `${verbs[verb]} ${THE_CONTENT_OF} ${getRowDoc(tableId)}`;
+  `${VERBS[verb]} ${getTheContentOfDoc()} ${getRowDoc(tableId)}`;
 const getCellContentDoc = (tableId, cellId, verb = 0) =>
-  `${verbs[verb]} ${getCellDoc(cellId)} for ${getRowDoc(tableId)}`;
-const verbs = ['Gets', 'Sets', 'Sets part of', 'Deletes'];
-const nouns = [
+  `${VERBS[verb]} ${getCellDoc(cellId)} for ${getRowDoc(tableId)}`;
+const getValueContentDoc = (valueId, verb = 0) =>
+  `${VERBS[verb]} ${getValueDoc(valueId)}`;
+const VERBS = [
+  'Gets',
+  'Sets',
+  'Sets part of',
+  'Deletes',
+  REPRESENTS,
+  `Gets ${A_STRING_SERIALIZATION_OF}`,
+  `Sets ${A_STRING_SERIALIZATION_OF}`,
+  `${REGISTERS_A_LISTENER} whenever`,
+];
+const NOUNS = [
   THE_STORE,
-  'anything',
+  'Tables',
   'Table Ids',
   'a Table',
   'Row Ids',
@@ -245,17 +268,14 @@ const nouns = [
   'Cell Ids',
   'a Cell',
   'invalid Cell changes',
+  'Values',
+  'Value Ids',
+  'a Value',
+  'invalid Value changes',
 ];
+const CONTENT = ['', 'tabular ', 'keyed value '];
 
-const COMMON_IMPORTS = [
-  'ChangedCells',
-  'Id',
-  'IdOrNull',
-  'Ids',
-  'InvalidCells',
-  'Json',
-  'Store',
-];
+const COMMON_IMPORTS = ['DoRollback', 'Id', 'IdOrNull', 'Ids', 'Json', 'Store'];
 const storeMethod = (method, parameters = EMPTY_STRING, cast = EMPTY_STRING) =>
   `store.${method}(${parameters})${cast ? ` as ${cast}` : EMPTY_STRING}`;
 const fluentStoreMethod = (method, parameters = EMPTY_STRING) =>
@@ -270,8 +290,8 @@ const storeListener = (
   }proxy(${LISTENER})${
     afterParameters ? `, ${afterParameters}` : EMPTY_STRING
   })`;
-const getStoreApi = (schema, module) => {
-  if (objIsEmpty(schema)) {
+const getStoreApi = (tablesSchema, valuesSchema, module) => {
+  if (objIsEmpty(tablesSchema) && objIsEmpty(valuesSchema)) {
     return pairNew(EMPTY_STRING);
   }
   const [
@@ -289,9 +309,10 @@ const getStoreApi = (schema, module) => {
   const moduleDefinition = `./${camel(module)}.d`;
   const storeType = camel(module, 1);
   const storeInstance = camel(storeType);
+  const createSteps = [];
   const tableTypes = mapNew();
-  const mapTableSchema = (callback) =>
-    objMap(schema, (_, tableId) => {
+  const mapTablesSchema = (callback) =>
+    objMap(tablesSchema, (_, tableId) => {
       return callback(
         tableId,
         mapEnsure(tableTypes, tableId, () => {
@@ -362,7 +383,7 @@ const getStoreApi = (schema, module) => {
       );
     });
   const mapCellSchema = (tableId, callback) =>
-    objMap(schema[tableId], (cellSchema, cellId) =>
+    objMap(tablesSchema[tableId], (cellSchema, cellId) =>
       callback(
         cellId,
         cellSchema[TYPE],
@@ -371,342 +392,715 @@ const getStoreApi = (schema, module) => {
         camel(cellId, 1),
       ),
     );
-  const tablesType = addType(
-    'Tables',
-    `{${join(
-      mapTableSchema(
-        (tableId, tableTypes2) => `'${tableId}'?: ${tableTypes2[0]};`,
+  const mapValuesSchema = (callback) =>
+    objMap(valuesSchema, (valueSchema, valueId) =>
+      callback(
+        valueId,
+        valueSchema[TYPE],
+        valueSchema[DEFAULT],
+        addConstant(snake(valueId), `'${valueId}'`),
+        camel(valueId, 1),
       ),
-      ' ',
-    )}}`,
-    `${REPRESENTS} ${THE_CONTENT_OF_THE_STORE}`,
-  );
-  const tableIdType = addType(
-    'TableId',
-    join(
-      mapTableSchema((tableId) => `'${tableId}'`),
-      ' | ',
-    ),
-    `A Table Id in ${THE_STORE}`,
+    );
+  addImport(
+    1,
+    moduleDefinition,
+    storeType,
+    `create${storeType} as create${storeType}Decl`,
   );
-  const tableCallbackType = addType(
-    'TableCallback',
-    `(...[tableId, rowCallback]: ${join(
-      mapTableSchema(
-        (tableId, tableTypes2) =>
-          `[tableId: '${tableId}', forEachRow: (rowCallback: ${tableTypes2[5]})${RETURNS_VOID}]`,
+  if (!objIsEmpty(tablesSchema)) {
+    const tablesType = addType(
+      'Tables',
+      `{${join(
+        mapTablesSchema(
+          (tableId, tableTypes2) => `'${tableId}'?: ${tableTypes2[0]};`,
+        ),
+        ' ',
+      )}}`,
+      getTheContentOfTheStoreDoc(4, 1),
+    );
+    const tableIdType = addType(
+      'TableId',
+      join(
+        mapTablesSchema((tableId) => `'${tableId}'`),
+        ' | ',
       ),
-      ' | ',
-    )})${RETURNS_VOID}`,
-    getCallbackDoc('a Table Id, and a Row iterator'),
-  );
-  const getCellChangeType = addType(
-    'GetCellChange',
-    `(...[tableId, rowId, cellId]: ${join(
-      mapTableSchema(
-        (tableId, tableTypes2) =>
-          `[tableId: '${tableId}', rowId: Id, cellId: ${tableTypes2[3]}]`,
+      `A Table Id in ${THE_STORE}`,
+    );
+    const tableCallbackType = addType(
+      'TableCallback',
+      `(...[tableId, rowCallback]: ${join(
+        mapTablesSchema(
+          (tableId, tableTypes2) =>
+            `[tableId: '${tableId}', forEachRow: (rowCallback: ${tableTypes2[5]})${RETURNS_VOID}]`,
+        ),
+        ' | ',
+      )})${RETURNS_VOID}`,
+      getCallbackDoc('a Table Id, and a Row iterator'),
+    );
+    const getCellChangeType = addType(
+      'GetCellChange',
+      `(...[tableId, rowId, cellId]: ${join(
+        mapTablesSchema(
+          (tableId, tableTypes2) =>
+            `[tableId: '${tableId}', rowId: Id, cellId: ${tableTypes2[3]}]`,
+        ),
+        ' | ',
+      )}) => CellChange`,
+      `${A_FUNCTION_FOR} returning information about any Cell's changes during a transaction`,
+    );
+    const tablesListenerType = addType(
+      'TablesListener',
+      `(${storeInstance}: ${storeType}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})${RETURNS_VOID}`,
+      getListenerTypeDoc(1),
+    );
+    const tableIdsListenerType = addType(
+      'TableIdsListener',
+      `(${storeInstance}: ${storeType})${RETURNS_VOID}`,
+      getListenerTypeDoc(2),
+    );
+    const tableListenerType = addType(
+      'TableListener',
+      `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})${RETURNS_VOID}`,
+      getListenerTypeDoc(3),
+    );
+    const rowIdsListenerType = addType(
+      'RowIdsListener',
+      `(${storeInstance}: ${storeType}, tableId: ${tableIdType})` +
+        RETURNS_VOID,
+      getListenerTypeDoc(4, 3),
+    );
+    const rowListenerType = addType(
+      'RowListener',
+      `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, rowId: Id, getCellChange: ${getCellChangeType}${OR_UNDEFINED})${RETURNS_VOID}`,
+      getListenerTypeDoc(5, 3),
+    );
+    const cellIdsListenerType = addType(
+      'CellIdsListener',
+      `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, rowId: Id)` +
+        RETURNS_VOID,
+      getListenerTypeDoc(6, 5),
+    );
+    const cellListenerType = addType(
+      'CellListener',
+      `(...[${storeInstance}, tableId, rowId, cellId, newCell, oldCell, getCellChange]: ${join(
+        flat(
+          mapTablesSchema((tableId) =>
+            mapCellSchema(
+              tableId,
+              (cellId, type) =>
+                `[${storeInstance}: ${storeType}, tableId: '${tableId}', rowId: Id, cellId: '${cellId}', newCell: ${type}${OR_UNDEFINED}, oldCell: ${type}${OR_UNDEFINED}, getCellChange: ${getCellChangeType} | undefined]`,
+            ),
+          ),
+        ),
+        ' | ',
+      )})${RETURNS_VOID}`,
+      getListenerTypeDoc(7, 5),
+    );
+    const invalidCellListenerType = addType(
+      'InvalidCellListener',
+      `(${storeInstance}: ${storeType}, tableId: Id, rowId: Id, cellId: Id, invalidCells: any[])${RETURNS_VOID}`,
+      getListenerTypeDoc(8),
+    );
+    addMethod(
+      `hasTables`,
+      EMPTY_STRING,
+      BOOLEAN,
+      storeMethod('hasTables'),
+      getHasDoc('any Table'),
+    );
+    addMethod(
+      `getTables`,
+      EMPTY_STRING,
+      tablesType,
+      storeMethod('getTables'),
+      getTheContentOfTheStoreDoc(0, 1),
+    );
+    addMethod(
+      `setTables`,
+      `tables: ${tablesType}`,
+      storeType,
+      fluentStoreMethod('setTables', 'tables'),
+      getTheContentOfTheStoreDoc(1, 1),
+    );
+    addMethod(
+      `delTables`,
+      EMPTY_STRING,
+      storeType,
+      fluentStoreMethod('delTables'),
+      getTheContentOfTheStoreDoc(3, 1),
+    );
+    addMethod(
+      `getTableIds`,
+      EMPTY_STRING,
+      `${tableIdType}[]`,
+      storeMethod('getTableIds', EMPTY_STRING, `${tableIdType}[]`),
+      getIdsDoc('Table', THE_STORE),
+    );
+    addMethod(
+      'forEachTable',
+      `tableCallback: ${tableCallbackType}`,
+      'void',
+      storeMethod('forEachTable', 'tableCallback as any'),
+      getForEachDoc('Table', THE_STORE),
+    );
+    const mapCellTypes = mapNew();
+    mapTablesSchema(
+      (
+        tableId,
+        [
+          tableType,
+          rowType,
+          rowWhenSetType,
+          cellIdType,
+          cellCallbackType,
+          rowCallbackType,
+        ],
+        tableName,
+        TABLE_ID,
+      ) => {
+        addImport(
+          1,
+          moduleDefinition,
+          tableType,
+          rowType,
+          rowWhenSetType,
+          cellIdType,
+          cellCallbackType,
+          rowCallbackType,
+        );
+        addMethod(
+          `has${tableName}Table`,
+          EMPTY_STRING,
+          BOOLEAN,
+          storeMethod('hasTable', TABLE_ID),
+          getHasDoc(getTableDoc(tableId)),
+        );
+        addMethod(
+          `get${tableName}Table`,
+          EMPTY_STRING,
+          tableType,
+          storeMethod('getTable', TABLE_ID, tableType),
+          getTableContentDoc(tableId),
+        );
+        addMethod(
+          `set${tableName}Table`,
+          `table: ${tableType}`,
+          storeType,
+          fluentStoreMethod('setTable', `${TABLE_ID}, table`),
+          getTableContentDoc(tableId, 1),
+        );
+        addMethod(
+          `del${tableName}Table`,
+          EMPTY_STRING,
+          storeType,
+          fluentStoreMethod('delTable', TABLE_ID),
+          getTableContentDoc(tableId, 3),
+        );
+        addMethod(
+          `get${tableName}RowIds`,
+          EMPTY_STRING,
+          'Ids',
+          storeMethod('getRowIds', TABLE_ID),
+          getIdsDoc('Row', getTableDoc(tableId)),
+        );
+        addMethod(
+          `get${tableName}SortedRowIds`,
+          `cellId?: ${cellIdType}, descending?: boolean, offset?: number, limit?: number`,
+          'Ids',
+          storeMethod(
+            'getSortedRowIds',
+            `${TABLE_ID}, cellId, descending, offset, limit`,
+          ),
+          getIdsDoc('Row', getTableDoc(tableId), 1),
+        );
+        addMethod(
+          `forEach${tableName}Row`,
+          `rowCallback: ${rowCallbackType}`,
+          'void',
+          storeMethod('forEachRow', `${TABLE_ID}, rowCallback as any`),
+          getForEachDoc('Row', getTableDoc(tableId)),
+        );
+        addMethod(
+          `has${tableName}Row`,
+          'rowId: Id',
+          BOOLEAN,
+          storeMethod('hasRow', `${TABLE_ID}, rowId`),
+          getHasDoc(THE_SPECIFIED_ROW, getTableDoc(tableId)),
+        );
+        addMethod(
+          `get${tableName}Row`,
+          'rowId: Id',
+          rowType,
+          storeMethod('getRow', `${TABLE_ID}, rowId`, rowType),
+          getRowContentDoc(tableId),
+        );
+        addMethod(
+          `set${tableName}Row`,
+          `rowId: Id, row: ${rowWhenSetType}`,
+          storeType,
+          fluentStoreMethod('setRow', `${TABLE_ID}, rowId, row`),
+          getRowContentDoc(tableId, 1),
+        );
+        addMethod(
+          `add${tableName}Row`,
+          `row: ${rowWhenSetType}`,
+          `Id${OR_UNDEFINED}`,
+          storeMethod('addRow', `${TABLE_ID}, row`),
+          `Adds a new Row to ${getTableDoc(tableId)}`,
+        );
+        addMethod(
+          `set${tableName}PartialRow`,
+          `rowId: Id, partialRow: ${rowWhenSetType}`,
+          storeType,
+          fluentStoreMethod('setPartialRow', `${TABLE_ID}, rowId, partialRow`),
+          getRowContentDoc(tableId, 2),
+        );
+        addMethod(
+          `del${tableName}Row`,
+          `rowId: Id`,
+          storeType,
+          fluentStoreMethod('delRow', `${TABLE_ID}, rowId`),
+          getRowContentDoc(tableId, 3),
+        );
+        addMethod(
+          `get${tableName}CellIds`,
+          'rowId: Id',
+          `${cellIdType}[]`,
+          storeMethod('getCellIds', `${TABLE_ID}, rowId`, `${cellIdType}[]`),
+          getIdsDoc('Cell', getRowDoc(tableId)),
+        );
+        addMethod(
+          `forEach${tableName}Cell`,
+          `rowId: Id, cellCallback: ${cellCallbackType}`,
+          'void',
+          storeMethod('forEachCell', `${TABLE_ID}, rowId, cellCallback as any`),
+          getForEachDoc('Cell', getRowDoc(tableId)),
+        );
+        mapCellSchema(
+          tableId,
+          (cellId, type, defaultValue, CELL_ID, cellName) => {
+            const mapCellType = `Map${camel(type, 1)}`;
+            mapSet(mapCellTypes, type, mapCellType);
+            addMethod(
+              `has${tableName}${cellName}Cell`,
+              'rowId: Id',
+              BOOLEAN,
+              storeMethod('hasCell', `${TABLE_ID}, rowId, ${CELL_ID}`),
+              getHasDoc(getCellDoc(cellId), getRowDoc(tableId)),
+            );
+            const returnCellType = `${type}${
+              isUndefined(defaultValue) ? OR_UNDEFINED : EMPTY_STRING
+            }`;
+            addMethod(
+              `get${tableName}${cellName}Cell`,
+              'rowId: Id',
+              returnCellType,
+              storeMethod(
+                'getCell',
+                `${TABLE_ID}, rowId, ${CELL_ID}`,
+                returnCellType,
+              ),
+              getCellContentDoc(tableId, cellId),
+            );
+            addMethod(
+              `set${tableName}${cellName}Cell`,
+              `rowId: Id, cell: ${type} | ${mapCellType}`,
+              storeType,
+              fluentStoreMethod(
+                'setCell',
+                `${TABLE_ID}, rowId, ${CELL_ID}, cell as any`,
+              ),
+              getCellContentDoc(tableId, cellId, 1),
+            );
+            addMethod(
+              `del${tableName}${cellName}Cell`,
+              `rowId: Id`,
+              storeType,
+              fluentStoreMethod('delCell', `${TABLE_ID}, rowId, ${CELL_ID}`),
+              getCellContentDoc(tableId, cellId, 3),
+            );
+          },
+        );
+      },
+    );
+    addMethod(
+      'getTablesJson',
+      EMPTY_STRING,
+      'Json',
+      storeMethod('getTablesJson'),
+      getTheContentOfTheStoreDoc(5, 1),
+    );
+    addMethod(
+      'setTablesJson',
+      'tablesJson: Json',
+      storeType,
+      fluentStoreMethod('setTablesJson', 'tablesJson'),
+      getTheContentOfTheStoreDoc(6, 1),
+    );
+    addMethod(
+      'addTablesListener',
+      `${LISTENER}: ${tablesListenerType}, mutator?: boolean`,
+      'Id',
+      storeListener('addTablesListener', EMPTY_STRING, 'mutator'),
+      getTheContentOfTheStoreDoc(7, 1) + ' changes',
+    );
+    addMethod(
+      'addTableIdsListener',
+      `${LISTENER}: ${tableIdsListenerType}, mutator?: boolean`,
+      'Id',
+      storeListener('addTableIdsListener', EMPTY_STRING, 'mutator'),
+      getListenerDoc('the Table Ids', THE_STORE, 1),
+    );
+    addMethod(
+      'addTableListener',
+      `tableId: ${tableIdType} | null, ${LISTENER}: ${tableListenerType}, mutator?: boolean`,
+      'Id',
+      storeListener('addTableListener', 'tableId', 'mutator'),
+      getListenerDoc('a Table', THE_STORE),
+    );
+    addMethod(
+      'addRowIdsListener',
+      `tableId: ${tableIdType} | null, ${LISTENER}: ${rowIdsListenerType}, mutator?: boolean`,
+      'Id',
+      storeListener('addRowIdsListener', 'tableId', 'mutator'),
+      getListenerDoc('the Row Ids', 'a Table', 1),
+    );
+    addMethod(
+      'addRowListener',
+      `tableId: ${tableIdType} | null, rowId: IdOrNull, ${LISTENER}: ${rowListenerType}, mutator?: boolean`,
+      'Id',
+      storeListener('addRowListener', 'tableId, rowId', 'mutator'),
+      getListenerDoc('a Row', 'a Table'),
+    );
+    addMethod(
+      'addCellIdsListener',
+      `tableId: ${tableIdType} | null, rowId: IdOrNull, ${LISTENER}: ${cellIdsListenerType}, mutator?: boolean`,
+      'Id',
+      storeListener('addCellIdsListener', 'tableId, rowId', 'mutator'),
+      getListenerDoc('the Cell Ids', 'a Row', 1),
+    );
+    addMethod(
+      'addCellListener',
+      `tableId: ${tableIdType} | null, rowId: IdOrNull, cellId: ${join(
+        mapTablesSchema((_, tableTypes2) => tableTypes2[3]),
+        ' | ',
+      )} | null, ${LISTENER}: ${cellListenerType}, mutator?: boolean`,
+      'Id',
+      storeListener('addCellListener', 'tableId, rowId, cellId', 'mutator'),
+      getListenerDoc('a Cell', 'a Row'),
+    );
+    addMethod(
+      'addInvalidCellListener',
+      `tableId: IdOrNull, rowId: IdOrNull, cellId: IdOrNull, ${LISTENER}: ${invalidCellListenerType}, mutator?: boolean`,
+      'Id',
+      storeListener(
+        'addInvalidCellListener',
+        'tableId, rowId, cellId',
+        'mutator',
       ),
-      ' | ',
-    )}) => CellChange`,
-    `${A_FUNCTION_FOR} returning information about any Cell's changes during  a transaction`,
-  );
-  const tablesListenerType = addType(
-    'TablesListener',
-    `(${storeInstance}: ${storeType}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})${RETURNS_VOID}`,
-    getListenerTypeDoc(1),
-  );
-  const tableIdsListenerType = addType(
-    'TableIdsListener',
-    `(${storeInstance}: ${storeType})${RETURNS_VOID}`,
-    getListenerTypeDoc(2),
-  );
-  const tableListenerType = addType(
-    'TableListener',
-    `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})${RETURNS_VOID}`,
-    getListenerTypeDoc(3),
-  );
-  const rowIdsListenerType = addType(
-    'RowIdsListener',
-    `(${storeInstance}: ${storeType}, tableId: ${tableIdType})${RETURNS_VOID}`,
-    getListenerTypeDoc(4, 3),
-  );
-  const rowListenerType = addType(
-    'RowListener',
-    `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, rowId: Id, getCellChange: ${getCellChangeType}${OR_UNDEFINED})${RETURNS_VOID}`,
-    getListenerTypeDoc(5, 3),
-  );
-  const cellIdsListenerType = addType(
-    'CellIdsListener',
-    `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, rowId: Id)` +
-      RETURNS_VOID,
-    getListenerTypeDoc(6, 5),
-  );
-  const cellListenerType = addType(
-    'CellListener',
-    `(...[${storeInstance}, tableId, rowId, cellId, newCell, oldCell, getCellChange]: ${join(
+      `${REGISTERS_A_LISTENER} whenever an invalid Cell change was attempted`,
+    );
+    mapForEach(mapCellTypes, (type, mapCellType) =>
+      addType(
+        mapCellType,
+        `(cell: ${type}${OR_UNDEFINED}) => ${type}`,
+        `Takes a ${type} Cell value and returns another`,
+      ),
+    );
+    addImport(
+      1,
+      moduleDefinition,
+      tablesType,
+      tableIdType,
+      tableCallbackType,
+      tablesListenerType,
+      tableIdsListenerType,
+      tableListenerType,
+      rowIdsListenerType,
+      rowListenerType,
+      cellIdsListenerType,
+      cellListenerType,
+      invalidCellListenerType,
+      ...collValues(mapCellTypes),
+    );
+    addImport(0, 'tinybase', 'CellChange');
+    arrayPush(
+      createSteps,
+      '.setTablesSchema({',
       flat(
-        mapTableSchema((tableId) =>
-          mapCellSchema(
+        mapTablesSchema((tableId, _, __, TABLE_ID) => [
+          `[${TABLE_ID}]: {`,
+          ...mapCellSchema(
             tableId,
-            (cellId, type) =>
-              `[${storeInstance}: ${storeType}, tableId: '${tableId}', rowId: Id, cellId: '${cellId}', newCell: ${type}${OR_UNDEFINED}, oldCell: ${type}${OR_UNDEFINED}, getCellChange: ${getCellChangeType} | undefined]`,
+            (_2, type, defaultValue, CELL_ID) =>
+              `[${CELL_ID}]: {[${addConstant(
+                snake(TYPE),
+                `'${TYPE}'`,
+              )}]: ${addConstant(snake(type), `'${type}'`)}${
+                isUndefined(defaultValue)
+                  ? EMPTY_STRING
+                  : `, [${addConstant(snake(DEFAULT), `'${DEFAULT}'`)}]: ${
+                      isString(defaultValue)
+                        ? addConstant(snake(defaultValue), `'${defaultValue}'`)
+                        : defaultValue
+                    }`
+              }},`,
           ),
+          `},`,
+        ]),
+      ),
+      '})',
+    );
+  }
+  if (!objIsEmpty(valuesSchema)) {
+    const valuesType = addType(
+      'Values',
+      `{${join(
+        mapValuesSchema(
+          (valueId, type, defaultValue) =>
+            `'${valueId}'${
+              isUndefined(defaultValue) ? '?' : EMPTY_STRING
+            }: ${type};`,
         ),
+        ' ',
+      )}}`,
+      getTheContentOfTheStoreDoc(4, 2),
+    );
+    const valuesWhenSetType = addType(
+      'ValuesWhenSet',
+      `{${join(
+        mapValuesSchema((valueId, type) => `'${valueId}'?: ${type};`),
+        ' ',
+      )}}`,
+      getTheContentOfTheStoreDoc(4, 2, 1),
+    );
+    const valueIdType = addType(
+      'ValueId',
+      join(
+        mapValuesSchema((valueId) => `'${valueId}'`),
+        ' | ',
       ),
-      ' | ',
-    )})${RETURNS_VOID}`,
-    getListenerTypeDoc(7, 5),
-  );
-  const invalidCellListenerType = addType(
-    'InvalidCellListener',
-    `(${storeInstance}: ${storeType}, tableId: Id, rowId: Id, cellId: Id, invalidCells: any[])${RETURNS_VOID}`,
-    getListenerTypeDoc(8),
-  );
-  const transactionListenerType = addType(
-    'TransactionListener',
-    `(${storeInstance}: ${storeType}, cellsTouched: boolean)${RETURNS_VOID}`,
-    `${A_FUNCTION_FOR} listening to the completion of a transaction`,
-  );
-  addMethod(
-    `hasTables`,
-    EMPTY_STRING,
-    BOOLEAN,
-    storeMethod('hasTables'),
-    getHasDoc('any Table'),
-  );
-  addMethod(
-    `getTables`,
-    EMPTY_STRING,
-    tablesType,
-    storeMethod('getTables'),
-    getStoreContentDoc(),
-  );
-  addMethod(
-    `setTables`,
-    `tables: ${tablesType}`,
-    storeType,
-    fluentStoreMethod('setTables', 'tables'),
-    getStoreContentDoc(1),
-  );
-  addMethod(
-    `delTables`,
-    EMPTY_STRING,
-    storeType,
-    fluentStoreMethod('delTables'),
-    getStoreContentDoc(3),
-  );
-  addMethod(
-    `getTableIds`,
-    EMPTY_STRING,
-    `${tableIdType}[]`,
-    storeMethod('getTableIds', EMPTY_STRING, `${tableIdType}[]`),
-    getIdsDoc('Table', THE_STORE),
-  );
-  addMethod(
-    'forEachTable',
-    `tableCallback: ${tableCallbackType}`,
-    'void',
-    storeMethod('forEachTable', 'tableCallback as any'),
-    getForEachDoc('Table', THE_STORE),
-  );
-  const mapCellTypes = mapNew();
-  mapTableSchema(
-    (
-      tableId,
-      [
-        tableType,
-        rowType,
-        rowWhenSetType,
-        cellIdType,
-        cellCallbackType,
-        rowCallbackType,
-      ],
-      tableName,
-      TABLE_ID,
-    ) => {
-      addImport(
-        1,
-        moduleDefinition,
-        tableType,
-        rowType,
-        rowWhenSetType,
-        cellIdType,
-        cellCallbackType,
-        rowCallbackType,
-      );
+      `A Value Id in ${THE_STORE}`,
+    );
+    const valueCallbackType = addType(
+      'ValueCallback',
+      `(...[valueId, rowCallback]: ${join(
+        mapValuesSchema(
+          (valueId, type) => `[valueId: '${valueId}', value: ${type}]`,
+        ),
+        ' | ',
+      )})${RETURNS_VOID}`,
+      getCallbackDoc('a Value Id, and value'),
+    );
+    const getValueChangeType = addType(
+      'GetValueChange',
+      `(valueId: ${valueIdType}) => ValueChange`,
+      `${A_FUNCTION_FOR} returning information about any Value's changes during a transaction`,
+    );
+    const valuesListenerType = addType(
+      'ValuesListener',
+      `(${storeInstance}: ${storeType}, getValueChange: ${getValueChangeType}${OR_UNDEFINED})` +
+        RETURNS_VOID,
+      getListenerTypeDoc(9),
+    );
+    const valueIdsListenerType = addType(
+      'ValueIdsListener',
+      `(${storeInstance}: ${storeType})${RETURNS_VOID}`,
+      getListenerTypeDoc(10),
+    );
+    const valueListenerType = addType(
+      'ValueListener',
+      `(...[${storeInstance}, valueId, newValue, oldValue, getValueChange]: ${join(
+        mapValuesSchema(
+          (valueId, type) =>
+            `[${storeInstance}: ${storeType}, valueId: '${valueId}', newValue: ${type}${OR_UNDEFINED}, oldValue: ${type}${OR_UNDEFINED}, getValueChange: ${getValueChangeType} | undefined]`,
+        ),
+        ' | ',
+      )})${RETURNS_VOID}`,
+      getListenerTypeDoc(11),
+    );
+    const invalidValueListenerType = addType(
+      'InvalidValueListener',
+      `(${storeInstance}: ${storeType}, valueId: Id, invalidValues: any[])${RETURNS_VOID}`,
+      getListenerTypeDoc(12),
+    );
+    addMethod(
+      `hasValues`,
+      EMPTY_STRING,
+      BOOLEAN,
+      storeMethod('hasValues'),
+      getHasDoc('any Value'),
+    );
+    addMethod(
+      `getValues`,
+      EMPTY_STRING,
+      valuesType,
+      storeMethod('getValues'),
+      getTheContentOfTheStoreDoc(0, 2),
+    );
+    addMethod(
+      `setValues`,
+      `values: ${valuesWhenSetType}`,
+      storeType,
+      fluentStoreMethod('setValues', 'values'),
+      getTheContentOfTheStoreDoc(1, 2),
+    );
+    addMethod(
+      `setPartialValues`,
+      `partialValues: ${valuesWhenSetType}`,
+      storeType,
+      fluentStoreMethod('setPartialValues', 'partialValues'),
+      getTheContentOfTheStoreDoc(2, 2),
+    );
+    addMethod(
+      `delValues`,
+      EMPTY_STRING,
+      storeType,
+      fluentStoreMethod('delValues'),
+      getTheContentOfTheStoreDoc(3, 2),
+    );
+    addMethod(
+      `getValueIds`,
+      EMPTY_STRING,
+      `${valueIdType}[]`,
+      storeMethod('getValueIds', EMPTY_STRING, `${valueIdType}[]`),
+      getIdsDoc('Value', THE_STORE),
+    );
+    addMethod(
+      'forEachValue',
+      `valueCallback: ${valueCallbackType}`,
+      'void',
+      storeMethod('forEachValue', 'valueCallback as any'),
+      getForEachDoc('Value', THE_STORE),
+    );
+    mapValuesSchema((valueId, type, _, VALUE_ID, valueName) => {
       addMethod(
-        `has${tableName}Table`,
+        `has${valueName}Value`,
         EMPTY_STRING,
         BOOLEAN,
-        storeMethod('hasTable', TABLE_ID),
-        getHasDoc(getTableDoc(tableId)),
+        storeMethod('hasValue', VALUE_ID),
+        getHasDoc(getValueDoc(valueId)),
       );
       addMethod(
-        `get${tableName}Table`,
+        `get${valueName}Value`,
         EMPTY_STRING,
-        tableType,
-        storeMethod('getTable', TABLE_ID, tableType),
-        getTableContentDoc(tableId),
-      );
-      addMethod(
-        `set${tableName}Table`,
-        `table: ${tableType}`,
-        storeType,
-        fluentStoreMethod('setTable', `${TABLE_ID}, table`),
-        getTableContentDoc(tableId, 1),
+        type,
+        storeMethod('getValue', VALUE_ID, type),
+        getValueContentDoc(valueId),
       );
       addMethod(
-        `del${tableName}Table`,
-        EMPTY_STRING,
+        `set${valueName}Value`,
+        `value: ${type}`,
         storeType,
-        fluentStoreMethod('delTable', TABLE_ID),
-        getTableContentDoc(tableId, 3),
+        fluentStoreMethod('setValue', `${VALUE_ID}, value`),
+        getValueContentDoc(valueId, 1),
       );
       addMethod(
-        `get${tableName}RowIds`,
+        `del${valueName}Value`,
         EMPTY_STRING,
-        'Ids',
-        storeMethod('getRowIds', TABLE_ID),
-        getIdsDoc('Row', getTableDoc(tableId)),
-      );
-      addMethod(
-        `get${tableName}SortedRowIds`,
-        `cellId?: ${cellIdType}, descending?: boolean, offset?: number, limit?: number`,
-        'Ids',
-        storeMethod(
-          'getSortedRowIds',
-          `${TABLE_ID}, cellId, descending, offset, limit`,
-        ),
-        getIdsDoc('Row', getTableDoc(tableId), 1),
-      );
-      addMethod(
-        `forEach${tableName}Row`,
-        `rowCallback: ${rowCallbackType}`,
-        'void',
-        storeMethod('forEachRow', `${TABLE_ID}, rowCallback as any`),
-        getForEachDoc('Row', getTableDoc(tableId)),
-      );
-      addMethod(
-        `has${tableName}Row`,
-        'rowId: Id',
-        BOOLEAN,
-        storeMethod('hasRow', `${TABLE_ID}, rowId`),
-        getHasDoc(THE_SPECIFIED_ROW, getTableDoc(tableId)),
-      );
-      addMethod(
-        `get${tableName}Row`,
-        'rowId: Id',
-        rowType,
-        storeMethod('getRow', `${TABLE_ID}, rowId`, rowType),
-        getRowContentDoc(tableId),
-      );
-      addMethod(
-        `set${tableName}Row`,
-        `rowId: Id, row: ${rowWhenSetType}`,
         storeType,
-        fluentStoreMethod('setRow', `${TABLE_ID}, rowId, row`),
-        getRowContentDoc(tableId, 1),
-      );
-      addMethod(
-        `add${tableName}Row`,
-        `row: ${rowWhenSetType}`,
-        `Id${OR_UNDEFINED}`,
-        storeMethod('addRow', `${TABLE_ID}, row`),
-        `Adds a new Row to ${getTableDoc(tableId)}`,
-      );
-      addMethod(
-        `set${tableName}PartialRow`,
-        `rowId: Id, partialRow: ${rowWhenSetType}`,
-        storeType,
-        fluentStoreMethod('setPartialRow', `${TABLE_ID}, rowId, partialRow`),
-        getRowContentDoc(tableId, 2),
-      );
-      addMethod(
-        `del${tableName}Row`,
-        `rowId: Id`,
-        storeType,
-        fluentStoreMethod('delRow', `${TABLE_ID}, rowId`),
-        getRowContentDoc(tableId, 3),
-      );
-      addMethod(
-        `get${tableName}CellIds`,
-        'rowId: Id',
-        `${cellIdType}[]`,
-        storeMethod('getCellIds', `${TABLE_ID}, rowId`, `${cellIdType}[]`),
-        getIdsDoc('Cell', getRowDoc(tableId)),
-      );
-      addMethod(
-        `forEach${tableName}Cell`,
-        `rowId: Id, cellCallback: ${cellCallbackType}`,
-        'void',
-        storeMethod('forEachCell', `${TABLE_ID}, rowId, cellCallback as any`),
-        getForEachDoc('Cell', getRowDoc(tableId)),
+        fluentStoreMethod('delValue', VALUE_ID),
+        getValueContentDoc(valueId, 3),
       );
-      mapCellSchema(
-        tableId,
-        (cellId, type, defaultValue, CELL_ID, cellName) => {
-          const mapCellType = `Map${camel(type, 1)}`;
-          mapSet(mapCellTypes, type, mapCellType);
-          addMethod(
-            `has${tableName}${cellName}Cell`,
-            'rowId: Id',
-            BOOLEAN,
-            storeMethod('hasCell', `${TABLE_ID}, rowId, ${CELL_ID}`),
-            getHasDoc(getCellDoc(cellId), getRowDoc(tableId)),
-          );
-          const returnCellType = `${type}${
-            isUndefined(defaultValue) ? OR_UNDEFINED : EMPTY_STRING
-          }`;
-          addMethod(
-            `get${tableName}${cellName}Cell`,
-            'rowId: Id',
-            returnCellType,
-            storeMethod(
-              'getCell',
-              `${TABLE_ID}, rowId, ${CELL_ID}`,
-              returnCellType,
-            ),
-            getCellContentDoc(tableId, cellId),
-          );
-          addMethod(
-            `set${tableName}${cellName}Cell`,
-            `rowId: Id, cell: ${type} | ${mapCellType}`,
-            storeType,
-            fluentStoreMethod(
-              'setCell',
-              `${TABLE_ID}, rowId, ${CELL_ID}, cell as any`,
-            ),
-            getCellContentDoc(tableId, cellId, 1),
-          );
-          addMethod(
-            `del${tableName}${cellName}Cell`,
-            `rowId: Id`,
-            storeType,
-            fluentStoreMethod('delCell', `${TABLE_ID}, rowId, ${CELL_ID}`),
-            getCellContentDoc(tableId, cellId, 3),
-          );
-        },
-      );
-    },
+    });
+    addMethod(
+      'getValuesJson',
+      EMPTY_STRING,
+      'Json',
+      storeMethod('getValuesJson'),
+      getTheContentOfTheStoreDoc(5, 2),
+    );
+    addMethod(
+      'setValuesJson',
+      'valuesJson: Json',
+      storeType,
+      fluentStoreMethod('setValuesJson', 'valuesJson'),
+      getTheContentOfTheStoreDoc(6, 2),
+    );
+    addMethod(
+      'addValuesListener',
+      `${LISTENER}: ${valuesListenerType}, mutator?: boolean`,
+      'Id',
+      storeListener('addValuesListener', EMPTY_STRING, 'mutator'),
+      getTheContentOfTheStoreDoc(7, 2) + ' changes',
+    );
+    addMethod(
+      'addValueIdsListener',
+      `${LISTENER}: ${valueIdsListenerType}, mutator?: boolean`,
+      'Id',
+      storeListener('addValueIdsListener', EMPTY_STRING, 'mutator'),
+      getListenerDoc('the Value Ids', THE_STORE, 1),
+    );
+    addMethod(
+      'addValueListener',
+      `valueId: ${valueIdType} | null, ${LISTENER}: ${valueListenerType}, mutator?: boolean`,
+      'Id',
+      storeListener('addValueListener', 'valueId', 'mutator'),
+      getListenerDoc('a Value', THE_STORE),
+    );
+    addMethod(
+      'addInvalidValueListener',
+      `valueId: IdOrNull, ${LISTENER}: ${invalidValueListenerType}, mutator?: boolean`,
+      'Id',
+      storeListener('addInvalidValueListener', 'valueId', 'mutator'),
+      `${REGISTERS_A_LISTENER} whenever an invalid Cell change was attempted`,
+    );
+    addImport(
+      1,
+      moduleDefinition,
+      valuesType,
+      valueIdType,
+      valueCallbackType,
+      valuesListenerType,
+      valueIdsListenerType,
+      valueListenerType,
+      invalidValueListenerType,
+    );
+    addImport(0, 'tinybase', 'ValueChange');
+    arrayPush(
+      createSteps,
+      '.setValuesSchema({',
+      mapValuesSchema((valueId, type, defaultValue, VALUE_ID) => [
+        `[${VALUE_ID}]: {[${addConstant(
+          snake(TYPE),
+          `'${TYPE}'`,
+        )}]: ${addConstant(snake(type), `'${type}'`)}${
+          isUndefined(defaultValue)
+            ? EMPTY_STRING
+            : `, [${addConstant(snake(DEFAULT), `'${DEFAULT}'`)}]: ${
+                isString(defaultValue)
+                  ? addConstant(snake(defaultValue), `'${defaultValue}'`)
+                  : defaultValue
+              }`
+        }},`,
+      ]),
+      '})',
+    );
+  }
+  addImport(0, 'tinybase', ...COMMON_IMPORTS);
+  const transactionListenerType = addType(
+    'TransactionListener',
+    `(${storeInstance}: ${storeType}, cellsTouched: boolean, valuesTouched: boolean)${RETURNS_VOID}`,
+    `${A_FUNCTION_FOR} listening to the completion of a transaction`,
   );
   addMethod(
     'getJson',
     EMPTY_STRING,
     'Json',
     storeMethod('getJson'),
-    `${verbs[0]} a string serialization ${THE_CONTENT_OF_THE_STORE}`,
+    getTheContentOfTheStoreDoc(5),
   );
   addMethod(
     'setJson',
     'json: Json',
     storeType,
     fluentStoreMethod('setJson', 'json'),
-    `${verbs[1]} ${THE_CONTENT_OF_THE_STORE} from a serialized string`,
+    getTheContentOfTheStoreDoc(6),
   );
   addMethod(
     'transaction',
-    'actions: () => Return, doRollback?: (changedCells: ChangedCells, invalidCells: InvalidCells) => boolean',
+    'actions: () => Return, doRollback?: DoRollback',
     'Return',
     storeMethod('transaction', 'actions, doRollback'),
     'Execute a transaction to make multiple mutations',
@@ -721,70 +1115,11 @@ const getStoreApi = (schema, module) => {
   );
   addMethod(
     'finishTransaction',
-    'doRollback?: (changedCells: ChangedCells, invalidCells: InvalidCells) => boolean,',
+    'doRollback?: DoRollback,',
     storeType,
     fluentStoreMethod('finishTransaction', 'doRollback'),
     'Explicitly finishes a transaction',
   );
-  addMethod(
-    'addTablesListener',
-    `${LISTENER}: ${tablesListenerType}, mutator?: boolean`,
-    'Id',
-    storeListener('addTablesListener', EMPTY_STRING, 'mutator'),
-    `${REGISTERS_A_LISTENER} whenever ${THE_CONTENT_OF_THE_STORE} changes`,
-  );
-  addMethod(
-    'addTableIdsListener',
-    `${LISTENER}: ${tableIdsListenerType}, mutator?: boolean`,
-    'Id',
-    storeListener('addTableIdsListener', EMPTY_STRING, 'mutator'),
-    getListenerDoc('the Table Ids', THE_STORE, 1),
-  );
-  addMethod(
-    'addTableListener',
-    `tableId: ${tableIdType} | null, ${LISTENER}: ${tableListenerType}, mutator?: boolean`,
-    'Id',
-    storeListener('addTableListener', 'tableId', 'mutator'),
-    getListenerDoc('a Table', THE_STORE),
-  );
-  addMethod(
-    'addRowIdsListener',
-    `tableId: ${tableIdType} | null, ${LISTENER}: ${rowIdsListenerType}, mutator?: boolean`,
-    'Id',
-    storeListener('addRowIdsListener', 'tableId', 'mutator'),
-    getListenerDoc('the Row Ids', 'a Table', 1),
-  );
-  addMethod(
-    'addRowListener',
-    `tableId: ${tableIdType} | null, rowId: IdOrNull, ${LISTENER}: ${rowListenerType}, mutator?: boolean`,
-    'Id',
-    storeListener('addRowListener', 'tableId, rowId', 'mutator'),
-    getListenerDoc('a Row', 'a Table'),
-  );
-  addMethod(
-    'addCellIdsListener',
-    `tableId: ${tableIdType} | null, rowId: IdOrNull, ${LISTENER}: ${cellIdsListenerType}, mutator?: boolean`,
-    'Id',
-    storeListener('addCellIdsListener', 'tableId, rowId', 'mutator'),
-    getListenerDoc('the Cell Ids', 'a Row', 1),
-  );
-  addMethod(
-    'addCellListener',
-    `tableId: ${tableIdType} | null, rowId: IdOrNull, cellId: ${join(
-      mapTableSchema((_, tableTypes2) => tableTypes2[3]),
-      ' | ',
-    )} | null, ${LISTENER}: ${cellListenerType}, mutator?: boolean`,
-    'Id',
-    storeListener('addCellListener', 'tableId, rowId, cellId', 'mutator'),
-    getListenerDoc('a Cell', 'a Row'),
-  );
-  addMethod(
-    'addInvalidCellListener',
-    `tableId: IdOrNull, rowId: IdOrNull, cellId: IdOrNull, ${LISTENER}: ${invalidCellListenerType}, mutator?: boolean`,
-    'Id',
-    storeListener('addCellListener', 'tableId, rowId, cellId', 'mutator'),
-    `${REGISTERS_A_LISTENER} whenever an invalid Cell change was attempted`,
-  );
   addMethod(
     'addWillFinishTransactionListener',
     `${LISTENER}: ${transactionListenerType}`,
@@ -818,62 +1153,17 @@ const getStoreApi = (schema, module) => {
     EMPTY_STRING,
     'Store',
     'store',
-    `${verbs[0]} the underlying Store object`,
+    `${VERBS[0]} the underlying Store object`,
   );
-  mapForEach(mapCellTypes, (type, mapCellType) =>
-    addType(
-      mapCellType,
-      `(cell: ${type}${OR_UNDEFINED}) => ${type}`,
-      `Takes a ${type} Cell value and returns another`,
-    ),
-  );
-  addImport(0, 'tinybase', 'CellChange', ...COMMON_IMPORTS);
   addImport(1, 'tinybase', 'createStore', ...COMMON_IMPORTS);
   addImport(
     1,
     moduleDefinition,
     storeType,
     `create${storeType} as create${storeType}Decl`,
-    tablesType,
-    tableIdType,
-    tableCallbackType,
-    tablesListenerType,
-    tableIdsListenerType,
-    tableListenerType,
-    rowIdsListenerType,
-    rowListenerType,
-    cellIdsListenerType,
-    cellListenerType,
-    invalidCellListenerType,
     transactionListenerType,
-    ...collValues(mapCellTypes),
   );
-  addConstant('store', [
-    'createStore().setSchema({',
-    flat(
-      mapTableSchema((tableId, _, __, TABLE_ID) => [
-        `[${TABLE_ID}]: {`,
-        ...mapCellSchema(
-          tableId,
-          (_2, type, defaultValue, CELL_ID) =>
-            `[${CELL_ID}]: {[${addConstant(
-              snake(TYPE),
-              `'${TYPE}'`,
-            )}]: ${addConstant(snake(type), `'${type}'`)}${
-              isUndefined(defaultValue)
-                ? EMPTY_STRING
-                : `, [${addConstant(snake(DEFAULT), `'${DEFAULT}'`)}]: ${
-                    isString(defaultValue)
-                      ? addConstant(snake(defaultValue), `'${defaultValue}'`)
-                      : defaultValue
-                  }`
-            }},`,
-        ),
-        `},`,
-      ]),
-    ),
-    '})',
-  ]);
+  addConstant('store', ['createStore()', ...createSteps]);
   addFunction('fluent', 'actions: () => Store', [
     'actions();',
     `return ${storeInstance};`,
@@ -942,14 +1232,15 @@ const createTools = getCreateFunction((store) => {
       totalTables,
       totalRows,
       totalCells,
+      totalValues: arrayLength(store.getValueIds()),
       jsonLength: length(store.getJson()),
       ...(detail ? {detail: {tables}} : {}),
     };
   };
-  const getStoreSchema = () => {
-    const schema = jsonParse(store.getSchemaJson());
+  const getStoreTablesSchema = () => {
+    const tablesSchema = jsonParse(store.getTablesSchemaJson());
     if (
-      !objIsEmpty(schema) ||
+      !objIsEmpty(tablesSchema) ||
       arrayEvery(store.getTableIds(), (tableId) => {
         const rowIds = store.getRowIds(tableId);
         const cellsMeta = mapNew();
@@ -958,7 +1249,7 @@ const createTools = getCreateFunction((store) => {
             arrayEvery(store.getCellIds(tableId, rowId), (cellId) => {
               const value = store.getCell(tableId, rowId, cellId);
               const cellMeta = mapEnsure(cellsMeta, cellId, () => [
-                getCellType(value),
+                getCellOrValueType(value),
                 mapNew(),
                 [0],
                 0,
@@ -970,13 +1261,13 @@ const createTools = getCreateFunction((store) => {
               }
               mapSet(values, value, count);
               cellMeta[3]++;
-              return type == getCellType(value);
+              return type == getCellOrValueType(value);
             }),
           )
         ) {
-          schema[tableId] = {};
+          tablesSchema[tableId] = {};
           collForEach(cellsMeta, ([type, , [, maxValue], count], cellId) => {
-            schema[tableId][cellId] = {
+            tablesSchema[tableId][cellId] = {
               [TYPE]: type,
               ...(count == arrayLength(rowIds) ? {[DEFAULT]: maxValue} : {}),
             };
@@ -985,11 +1276,23 @@ const createTools = getCreateFunction((store) => {
         }
       })
     ) {
-      return schema;
+      return tablesSchema;
     }
     return {};
   };
-  const getStoreApi$1 = (module) => getStoreApi(getStoreSchema(), module);
+  const getStoreValuesSchema = () => {
+    const valuesSchema = jsonParse(store.getValuesSchemaJson());
+    if (objIsEmpty(valuesSchema)) {
+      store.forEachValue((valueId, value) => {
+        valuesSchema[valueId] = {
+          [TYPE]: getCellOrValueType(value),
+        };
+      });
+    }
+    return valuesSchema;
+  };
+  const getStoreApi$1 = (module) =>
+    getStoreApi(getStoreTablesSchema(), getStoreValuesSchema(), module);
   const getPrettyStoreApi = async (module) => {
     let format;
     try {
@@ -1003,7 +1306,8 @@ const createTools = getCreateFunction((store) => {
   };
   const tools = {
     getStoreStats,
-    getStoreSchema,
+    getStoreTablesSchema,
+    getStoreValuesSchema,
     getStoreApi: getStoreApi$1,
     getPrettyStoreApi,
   };