tinybase 3.0.2 → 3.1.0-beta.1

package/lib/debug/tools.js

@@ -5,6 +5,21 @@ const BOOLEAN = getTypeOf(true);
 const NUMBER = getTypeOf(0);
 const TYPE = 'type';
 const DEFAULT = 'default';
+const LISTENER = 'Listener';
+const GET = 'get';
+const ADD = 'add';
+const IDS = 'Ids';
+const TABLE = 'Table';
+const TABLES = TABLE + 's';
+const TABLE_IDS = TABLE + IDS;
+const ROW = 'Row';
+const ROW_IDS = ROW + IDS;
+const SORTED_ROW_IDS = 'Sorted' + ROW + IDS;
+const CELL = 'Cell';
+const CELL_IDS = CELL + IDS;
+const VALUE = 'Value';
+const VALUES = VALUE + 's';
+const VALUE_IDS = VALUE + IDS;
 
 const arrayEvery = (array, cb) => array.every(cb);
 const arraySort = (array, sorter) => array.sort(sorter);
@@ -12,6 +27,7 @@ const arrayForEach = (array, cb) => array.forEach(cb);
 const arrayMap = (array, cb) => array.map(cb);
 const arrayLength = (array) => array.length;
 const arrayIsEmpty = (array) => arrayLength(array) == 0;
+const arrayFilter = (array, cb) => array.filter(cb);
 const arrayPush = (array, ...values) => array.push(...values);
 const arrayPop = (array) => array.pop();
 const arrayUnshift = (array, ...values) => array.unshift(...values);
@@ -52,6 +68,110 @@ const mapEnsure = (map, key, getDefaultValue) => {
   return mapGet(map, key);
 };
 
+const upper = (str) => str.toUpperCase();
+const lower = (str) => str.toLowerCase();
+const A = 'a ';
+const A_FUNCTION_FOR = 'A function for';
+const CALLBACK = 'Callback';
+const DEL = 'Del';
+const EXPORT = 'export';
+const ID = 'Id';
+const INVALID = 'Invalid';
+const JSON$1 = 'Json';
+const LISTENER_ = lower(LISTENER);
+const OR_UNDEFINED = ' | undefined';
+const PARTIAL = 'Partial';
+const REGISTERS_A_LISTENER = `Registers a ${LISTENER_} that will be called`;
+const REPRESENTS = 'Represents';
+const SET = 'Set';
+const SQUARE_BRACKETS = '[]';
+const THE_STORE = 'the Store';
+const TRANSACTION = 'Transaction';
+const TRANSACTION_ = lower(TRANSACTION);
+const THE_END_OF_THE_TRANSACTION = 'the end of the ' + TRANSACTION_;
+const VOID = 'void';
+const RETURNS_VOID = ' => ' + VOID;
+const A_STRING_SERIALIZATION_OF = A + 'string serialization of';
+const SPACE = ' ';
+const GETS_A_CALLBACK_THAT_CAN = 'Gets a callback that can ';
+const THE = 'the ';
+const getTheContentOfDoc = (content = 0, theStore = 0) =>
+  `the ${CONTENT[content]}content of` +
+  (theStore ? SPACE + THE_STORE : EMPTY_STRING);
+const getTheContentOfTheStoreDoc = (content = 0, verb, set = 0) =>
+  VERBS[verb] +
+  SPACE +
+  getTheContentOfDoc(content, 1) +
+  (set ? ' when set' : EMPTY_STRING);
+const getRowTypeDoc = (tableId, set = 0) =>
+  REPRESENTS +
+  ` a Row when ${
+    set ? 's' : 'g'
+  }etting ${getTheContentOfDoc()} the '${tableId}' ` +
+  TABLE;
+const getIdsDoc = (idsNoun, parentNoun, sorted = 0) =>
+  `Gets ${sorted ? 'sorted, paginated' : 'the'} Ids of the ${idsNoun}s in ` +
+  parentNoun;
+const getForEachDoc = (childNoun, parentNoun) =>
+  `Calls a function for each ${childNoun} in ` + parentNoun;
+const getCallbackDoc = (takes) => 'A function that takes ' + takes;
+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 ' +
+  NOUNS[childNoun] +
+  ' in ' +
+  NOUNS[parentNoun] +
+  ' change' +
+  (pluralChild ? EMPTY_STRING : 's');
+const getTableDoc = (tableId) => `the '${tableId}' ` + TABLE;
+const getRowDoc = (tableId) => 'the specified Row in ' + getTableDoc(tableId);
+const getTableContentDoc = (tableId, verb = 0) =>
+  VERBS[verb] + ` ${getTheContentOfDoc()} ` + getTableDoc(tableId);
+const getRowContentDoc = (tableId, verb = 0) =>
+  VERBS[verb] + ` ${getTheContentOfDoc()} ` + getRowDoc(tableId);
+const getCellContentDoc = (tableId, cellId, verb = 0) =>
+  VERBS[verb] + ` the '${cellId}' Cell for ` + getRowDoc(tableId);
+const getValueContentDoc = (valueId, verb = 0) =>
+  VERBS[verb] + ` the '${valueId}' Value`;
+const VERBS = [
+  'Gets',
+  'Checks existence of',
+  'Sets',
+  'Deletes',
+  'Sets part of',
+  REPRESENTS,
+  'Gets ' + A_STRING_SERIALIZATION_OF,
+  'Sets ' + A_STRING_SERIALIZATION_OF,
+  REGISTERS_A_LISTENER + ' whenever',
+  GETS_A_CALLBACK_THAT_CAN + 'set',
+  GETS_A_CALLBACK_THAT_CAN + 'add',
+  GETS_A_CALLBACK_THAT_CAN + 'set part of',
+  GETS_A_CALLBACK_THAT_CAN + 'delete',
+];
+const NOUNS = [
+  THE_STORE,
+  TABLES,
+  THE + TABLE + SPACE + IDS,
+  A + TABLE,
+  THE + ROW + SPACE + IDS,
+  A + ROW,
+  THE + CELL + SPACE + IDS,
+  A + CELL,
+  'invalid Cell changes',
+  VALUES,
+  THE + VALUE + SPACE + IDS,
+  A + VALUE,
+  'invalid Value changes',
+  THE + 'sorted ' + ROW + SPACE + IDS,
+];
+const CONTENT = [EMPTY_STRING, 'tabular ', 'keyed value '];
+
 const setNew = (entryOrEntries) =>
   new Set(
     isArray(entryOrEntries) || isUndefined(entryOrEntries)
@@ -60,15 +180,11 @@ const setNew = (entryOrEntries) =>
   );
 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);
-const upper = (str) => str.toUpperCase();
-const lower = (str) => str.toLowerCase();
+const stringHasComma = (str) => str.includes(',');
 const mapUnique = (map, id, value, index = 1) => {
   const uniqueId = `${id}${index == 1 ? '' : index}`;
   if (collHas(map, uniqueId)) {
@@ -110,20 +226,26 @@ const snake = (str) =>
     ),
   );
 const comment = (doc) => `/** ${doc}. */`;
+const getParameterList = (...params) =>
+  join(
+    arrayFilter(params, (param) => param),
+    ', ',
+  );
 const getCodeFunctions = () => {
-  const allImports = pairNewMap();
+  const allImports = [mapNew(), mapNew(), mapNew(), mapNew()];
   const types = mapNew();
-  const methods = mapNew();
   const constants = mapNew();
   const build = (...lines) => join(flat(lines), '\n');
   const addImport = (location, source, ...items) =>
     arrayForEach(items, (item) =>
-      setAdd(mapEnsure(allImports[location], source, setNew), item),
+      arrayForEach([0, 1], (eachLocation) =>
+        (location ?? eachLocation) == eachLocation
+          ? setAdd(mapEnsure(allImports[eachLocation], source, setNew), item)
+          : 0,
+      ),
     );
   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) =>
+  const addInternalFunction = (name, parameters, body) =>
     mapUnique(
       constants,
       name,
@@ -133,36 +255,38 @@ const getCodeFunctions = () => {
     );
   const addConstant = (name, body) =>
     mapGet(constants, name) === body ? name : mapUnique(constants, name, body);
-  const getImports = (location) => [
-    ...arraySort(
-      mapMap(
-        allImports[location],
-        (items, source) =>
-          `import {${join(
-            arraySort(collValues(items)),
-            ', ',
-          )}} from '${source}';`,
-      ),
-    ),
-    EMPTY_STRING,
-  ];
+  const getImports = (location = 0) =>
+    arrayMap(
+      [
+        ...arraySort(
+          mapMap(
+            allImports[location],
+            (items, source) =>
+              `import {${join(
+                arraySort(collValues(items)),
+                ', ',
+              )}} from '${source}';`,
+          ),
+          (import1, import2) =>
+            stringHasComma(import1) != stringHasComma(import2)
+              ? stringHasComma(import1)
+                ? -1
+                : 1
+              : import1 > import2
+              ? 1
+              : -1,
+        ),
+        EMPTY_STRING,
+      ],
+      (line) => line.replace('{React}', 'React'),
+      // sigh
+    );
   const getTypes = () =>
     mapMap(types, ([body, doc], name) => [
       comment(doc),
-      `export type ${name} = ${body};`,
+      `${EXPORT} type ${name} = ${body};`,
       EMPTY_STRING,
     ]);
-  const getMethods = (location) =>
-    mapMap(methods, ([parameters, returnType, body, doc, generic], name) => {
-      const lines = location
-        ? [`${name}: ${generic}(${parameters}): ${returnType} => ${body},`]
-        : [`${name}${generic}(${parameters}): ${returnType};`];
-      if (!location) {
-        arrayUnshift(lines, comment(doc));
-      }
-      arrayPush(lines, EMPTY_STRING);
-      return lines;
-    });
   const getConstants = () =>
     mapMap(constants, (body, name) => {
       body = isArray(body) ? body : [body];
@@ -173,12 +297,10 @@ const getCodeFunctions = () => {
     build,
     addImport,
     addType,
-    addMethod,
-    addFunction,
+    addInternalFunction,
     addConstant,
     getImports,
     getTypes,
-    getMethods,
     getConstants,
   ];
 };
@@ -202,182 +324,11 @@ const getCreateFunction = (getFunction) => {
   };
 };
 
-const THE_STORE = 'the Store';
-const A_FUNCTION_FOR = 'A function for';
-const EXPORT = 'export';
-const LISTENER = 'listener';
-const OR_UNDEFINED = ' | undefined';
-const REGISTERS_A_LISTENER = `Registers a ${LISTENER} that will be called`;
-const REPRESENTS = 'Represents';
-const RETURNS_VOID = ' => void';
-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 ${getTheContentOfDoc()} the '${tableId}' Table`;
-const getIdsDoc = (idsNoun, parentNoun, sorted = 0) =>
-  `Gets ${
-    sorted ? 'sorted, paginated' : 'the'
-  } Ids of the ${idsNoun}s in ${parentNoun}`;
-const getForEachDoc = (childNoun, parentNoun) =>
-  `Calls a function for each ${childNoun} in ${parentNoun}`;
-const getHasDoc = (childNoun, parentNoun = THE_STORE) =>
-  `Gets whether ${childNoun} exists in ${parentNoun}`;
-const getCallbackDoc = (takes) => `A function that takes ${takes}`;
-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 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]} ${getTheContentOfDoc()} ${getTableDoc(tableId)}`;
-const getRowContentDoc = (tableId, verb = 0) =>
-  `${VERBS[verb]} ${getTheContentOfDoc()} ${getRowDoc(tableId)}`;
-const getCellContentDoc = (tableId, cellId, verb = 0) =>
-  `${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,
-  'Tables',
-  'Table Ids',
-  'a Table',
-  'Row Ids',
-  'a Row',
-  'Cell Ids',
-  'a Cell',
-  'invalid Cell changes',
-  'Values',
-  'Value Ids',
-  'a Value',
-  'invalid Value changes',
-];
-const CONTENT = ['', 'tabular ', 'keyed value '];
-
-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) =>
-  `fluent(() => ${storeMethod(method, parameters)})`;
-const storeListener = (
-  method,
-  beforeParameters = EMPTY_STRING,
-  afterParameters = EMPTY_STRING,
-) =>
-  `store.${method}(${
-    beforeParameters ? `${beforeParameters}, ` : EMPTY_STRING
-  }proxy(${LISTENER})${
-    afterParameters ? `, ${afterParameters}` : EMPTY_STRING
-  })`;
-const getStoreApi = (tablesSchema, valuesSchema, module) => {
-  if (objIsEmpty(tablesSchema) && objIsEmpty(valuesSchema)) {
-    return pairNew(EMPTY_STRING);
-  }
-  const [
-    build,
-    addImport,
-    addType,
-    addMethod,
-    addFunction,
-    addConstant,
-    getImports,
-    getTypes,
-    getMethods,
-    getConstants,
-  ] = getCodeFunctions();
-  const moduleDefinition = `./${camel(module)}.d`;
-  const storeType = camel(module, 1);
-  const storeInstance = camel(storeType);
-  const createSteps = [];
-  const tableTypes = mapNew();
+const getSchemaFunctions = (tablesSchema, valuesSchema, addConstant) => {
   const mapTablesSchema = (callback) =>
     objMap(tablesSchema, (_, tableId) => {
       return callback(
         tableId,
-        mapEnsure(tableTypes, tableId, () => {
-          const table = camel(tableId, 1);
-          return [
-            addType(
-              `${table}Table`,
-              `{[rowId: Id]: ${table}Row}`,
-              `${REPRESENTS} the '${tableId}' Table`,
-            ),
-            addType(
-              `${table}Row`,
-              `{${join(
-                mapCellSchema(
-                  tableId,
-                  (cellId, type, defaultValue) =>
-                    `'${cellId}'${
-                      isUndefined(defaultValue) ? '?' : EMPTY_STRING
-                    }: ${type};`,
-                ),
-                ' ',
-              )}}`,
-              getRowTypeDoc(tableId),
-            ),
-            addType(
-              `${table}RowWhenSet`,
-              `{${join(
-                mapCellSchema(
-                  tableId,
-                  (cellId, type) => `'${cellId}'?: ${type};`,
-                ),
-                ' ',
-              )}}`,
-              getRowTypeDoc(tableId, 1),
-            ),
-            addType(
-              `${table}CellId`,
-              join(
-                mapCellSchema(tableId, (cellId) => `'${cellId}'`),
-                ' | ',
-              ),
-              `A Cell Id for the '${tableId}' Table`,
-            ),
-            addType(
-              `${table}CellCallback`,
-              `(...[cellId, cell]: ${join(
-                mapCellSchema(
-                  tableId,
-                  (cellId, type) => `[cellId: '${cellId}', cell: ${type}]`,
-                ),
-                ' | ',
-              )})${RETURNS_VOID}`,
-              getCallbackDoc(
-                `a Cell Id and value from a Row in the '${tableId}' Table`,
-              ),
-            ),
-            addType(
-              `${table}RowCallback`,
-              `(rowId: Id, forEachCell: (cellCallback: ${table}CellCallback)${RETURNS_VOID})${RETURNS_VOID}`,
-              getCallbackDoc(
-                `a Row Id from the '${tableId}' Table, and a Cell iterator`,
-              ),
-            ),
-          ];
-        }),
         camel(tableId, 1),
         addConstant(snake(tableId), `'${tableId}'`),
       );
@@ -402,6 +353,124 @@ const getStoreApi = (tablesSchema, valuesSchema, module) => {
         camel(valueId, 1),
       ),
     );
+  return [mapTablesSchema, mapCellSchema, mapValuesSchema];
+};
+
+const METHOD_PREFIX_VERBS = [
+  GET,
+  'has',
+  'set',
+  'del',
+  'set',
+  'forEach',
+  ADD,
+  EMPTY_STRING,
+];
+const storeMethod = (method, parameters = EMPTY_STRING, cast = EMPTY_STRING) =>
+  `store.${method}(${parameters})` + (cast ? ' as ' + cast : EMPTY_STRING);
+const fluentStoreMethod = (method, parameters = EMPTY_STRING) =>
+  `fluent(() => ${storeMethod(method, parameters)})`;
+const storeListener = (
+  method,
+  beforeParameters = EMPTY_STRING,
+  afterParameters = EMPTY_STRING,
+) =>
+  `store.${method}(${
+    beforeParameters ? beforeParameters + ', ' : EMPTY_STRING
+  }proxy(listener)${afterParameters ? ', ' + afterParameters : EMPTY_STRING})`;
+const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
+  const [
+    build,
+    addImport,
+    addType,
+    addInternalFunction,
+    addConstant,
+    getImports,
+    getTypes,
+    getConstants,
+  ] = getCodeFunctions();
+  const [mapTablesSchema, mapCellSchema, mapValuesSchema] = getSchemaFunctions(
+    tablesSchema,
+    valuesSchema,
+    addConstant,
+  );
+  const methods = mapNew();
+  const getMethods = (location = 0) =>
+    mapMap(methods, ([parameters, returnType, body, doc, generic], name) => {
+      const lines = location
+        ? [name + `: ${generic}(${parameters}): ${returnType} => ${body},`]
+        : [name + generic + `(${parameters}): ${returnType};`];
+      if (!location) {
+        arrayUnshift(lines, comment(doc));
+      }
+      arrayPush(lines, EMPTY_STRING);
+      return lines;
+    });
+  const addMethod = (
+    name,
+    parameters,
+    returnType,
+    body,
+    doc,
+    generic = EMPTY_STRING,
+  ) => mapUnique(methods, name, [parameters, returnType, body, doc, generic]);
+  const addProxyMethod = (
+    prefixVerb,
+    prefix,
+    underlyingName,
+    returnType,
+    doc,
+    params = EMPTY_STRING,
+    paramsInCall = EMPTY_STRING,
+    generic = EMPTY_STRING,
+  ) =>
+    addMethod(
+      METHOD_PREFIX_VERBS[prefixVerb] +
+        prefix +
+        (prefixVerb == 4 ? PARTIAL : EMPTY_STRING) +
+        underlyingName,
+      params,
+      returnType,
+      (returnType == storeType ? fluentStoreMethod : storeMethod)(
+        METHOD_PREFIX_VERBS[prefixVerb] +
+          (prefixVerb == 4 ? PARTIAL : EMPTY_STRING) +
+          underlyingName,
+        paramsInCall,
+        prefixVerb ? void 0 : returnType,
+      ),
+      doc,
+      generic,
+    );
+  const addProxyListener = (
+    underlyingName,
+    listenerType,
+    doc,
+    params = EMPTY_STRING,
+    paramsInCall = EMPTY_STRING,
+    mutator = 1,
+  ) =>
+    addMethod(
+      ADD + underlyingName + LISTENER,
+      (params ? params + ', ' : EMPTY_STRING) +
+        LISTENER_ +
+        ': ' +
+        listenerType +
+        (mutator ? ', mutator?: boolean' : EMPTY_STRING),
+      ID,
+      storeListener(
+        ADD + underlyingName + LISTENER,
+        paramsInCall,
+        mutator ? 'mutator' : EMPTY_STRING,
+      ),
+      doc,
+    );
+  const moduleDefinition = `./${camel(module)}.d`;
+  const storeType = camel(module, 1);
+  const storeInstance = camel(storeType);
+  const createSteps = [];
+  const mapCellOrValueTypes = mapNew();
+  let sharedTableTypes = [];
+  let sharedValueTypes = [];
   addImport(
     1,
     moduleDefinition,
@@ -409,80 +478,170 @@ const getStoreApi = (tablesSchema, valuesSchema, module) => {
     `create${storeType} as create${storeType}Decl`,
   );
   if (!objIsEmpty(tablesSchema)) {
+    const tablesTypes = mapNew();
+    mapTablesSchema((tableId, tableName) => {
+      const tableTypes = [
+        addType(
+          tableName + TABLE,
+          `{[rowId: Id]: ${tableName}Row}`,
+          REPRESENTS + ` the '${tableId}' ` + TABLE,
+        ),
+        addType(
+          tableName + ROW,
+          `{${join(
+            mapCellSchema(
+              tableId,
+              (cellId, type, defaultValue) =>
+                `'${cellId}'${
+                  isUndefined(defaultValue) ? '?' : EMPTY_STRING
+                }: ${type};`,
+            ),
+            ' ',
+          )}}`,
+          getRowTypeDoc(tableId),
+        ),
+        addType(
+          tableName + ROW + 'WhenSet',
+          `{${join(
+            mapCellSchema(tableId, (cellId, type) => `'${cellId}'?: ${type};`),
+            ' ',
+          )}}`,
+          getRowTypeDoc(tableId, 1),
+        ),
+        addType(
+          tableName + CELL + ID,
+          join(
+            mapCellSchema(tableId, (cellId) => `'${cellId}'`),
+            ' | ',
+          ),
+          `A Cell Id for the '${tableId}' ` + TABLE,
+        ),
+        addType(
+          tableName + CELL + CALLBACK,
+          `(...[cellId, cell]: ${join(
+            mapCellSchema(
+              tableId,
+              (cellId, type) => `[cellId: '${cellId}', cell: ${type}]`,
+            ),
+            ' | ',
+          )})` + RETURNS_VOID,
+          getCallbackDoc(
+            `a Cell Id and value from a Row in the '${tableId}' ` + TABLE,
+          ),
+        ),
+        addType(
+          tableName + ROW + CALLBACK,
+          `(rowId: Id, forEachCell: (cellCallback: ${tableName}CellCallback)` +
+            RETURNS_VOID +
+            ')' +
+            RETURNS_VOID,
+          getCallbackDoc(
+            `a Row Id from the '${tableId}' Table, and a Cell iterator`,
+          ),
+        ),
+      ];
+      mapSet(tablesTypes, tableId, tableTypes);
+      addImport(1, moduleDefinition, ...tableTypes);
+    });
     const tablesType = addType(
-      'Tables',
+      TABLES,
       `{${join(
         mapTablesSchema(
-          (tableId, tableTypes2) => `'${tableId}'?: ${tableTypes2[0]};`,
+          (tableId) => `'${tableId}'?: ${mapGet(tablesTypes, tableId)?.[0]};`,
         ),
         ' ',
       )}}`,
-      getTheContentOfTheStoreDoc(4, 1),
+      getTheContentOfTheStoreDoc(1, 5),
     );
     const tableIdType = addType(
-      'TableId',
+      TABLE + ID,
       join(
         mapTablesSchema((tableId) => `'${tableId}'`),
         ' | ',
       ),
-      `A Table Id in ${THE_STORE}`,
+      'A ' + TABLE + ' Id in ' + THE_STORE,
     );
     const tableCallbackType = addType(
-      'TableCallback',
+      TABLE + CALLBACK,
       `(...[tableId, rowCallback]: ${join(
         mapTablesSchema(
-          (tableId, tableTypes2) =>
-            `[tableId: '${tableId}', forEachRow: (rowCallback: ${tableTypes2[5]})${RETURNS_VOID}]`,
+          (tableId) =>
+            `[tableId: '${tableId}', forEachRow: (rowCallback: ${
+              mapGet(tablesTypes, tableId)?.[5]
+            })${RETURNS_VOID}]`,
         ),
         ' | ',
-      )})${RETURNS_VOID}`,
-      getCallbackDoc('a Table Id, and a Row iterator'),
+      )})` + 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]}]`,
+          (tableId) =>
+            `[tableId: '${tableId}', rowId: Id, cellId: ${
+              mapGet(tablesTypes, tableId)?.[3]
+            }]`,
         ),
         ' | ',
       )}) => CellChange`,
-      `${A_FUNCTION_FOR} returning information about any Cell's changes during a transaction`,
+      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}`,
+      TABLES + LISTENER,
+      `(${storeInstance}: ${storeType}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})` +
+        RETURNS_VOID,
       getListenerTypeDoc(1),
     );
     const tableIdsListenerType = addType(
-      'TableIdsListener',
-      `(${storeInstance}: ${storeType})${RETURNS_VOID}`,
+      TABLE_IDS + LISTENER,
+      `(${storeInstance}: ${storeType})` + RETURNS_VOID,
       getListenerTypeDoc(2),
     );
     const tableListenerType = addType(
-      'TableListener',
-      `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})${RETURNS_VOID}`,
+      TABLE + LISTENER,
+      `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})` +
+        RETURNS_VOID,
       getListenerTypeDoc(3),
     );
     const rowIdsListenerType = addType(
-      'RowIdsListener',
+      ROW_IDS + LISTENER,
       `(${storeInstance}: ${storeType}, tableId: ${tableIdType})` +
         RETURNS_VOID,
       getListenerTypeDoc(4, 3),
     );
+    const sortedRowIdsListenerType = addType(
+      SORTED_ROW_IDS + LISTENER,
+      '(' +
+        getParameterList(
+          storeInstance + ': ' + storeType,
+          'tableId: ' + tableIdType,
+          'cellId: Id' + OR_UNDEFINED,
+          'descending: boolean',
+          'offset: number',
+          'limit: number' + OR_UNDEFINED,
+          'sortedRowIds: Ids',
+        ) +
+        ')' +
+        RETURNS_VOID,
+      getListenerTypeDoc(13, 3),
+    );
     const rowListenerType = addType(
-      'RowListener',
-      `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, rowId: Id, getCellChange: ${getCellChangeType}${OR_UNDEFINED})${RETURNS_VOID}`,
+      ROW + LISTENER,
+      `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, rowId: Id, getCellChange: ${getCellChangeType}${OR_UNDEFINED})` +
+        RETURNS_VOID,
       getListenerTypeDoc(5, 3),
     );
     const cellIdsListenerType = addType(
-      'CellIdsListener',
+      CELL_IDS + LISTENER,
       `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, rowId: Id)` +
         RETURNS_VOID,
       getListenerTypeDoc(6, 5),
     );
     const cellListenerType = addType(
-      'CellListener',
+      CELL + LISTENER,
       `(...[${storeInstance}, tableId, rowId, cellId, newCell, oldCell, getCellChange]: ${join(
         flat(
           mapTablesSchema((tableId) =>
@@ -494,319 +653,279 @@ const getStoreApi = (tablesSchema, valuesSchema, module) => {
           ),
         ),
         ' | ',
-      )})${RETURNS_VOID}`,
+      )})` + RETURNS_VOID,
       getListenerTypeDoc(7, 5),
     );
     const invalidCellListenerType = addType(
-      'InvalidCellListener',
-      `(${storeInstance}: ${storeType}, tableId: Id, rowId: Id, cellId: Id, invalidCells: any[])${RETURNS_VOID}`,
+      INVALID + CELL + LISTENER,
+      `(${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,
+    sharedTableTypes = [
       tablesType,
-      storeMethod('getTables'),
-      getTheContentOfTheStoreDoc(0, 1),
-    );
-    addMethod(
-      `setTables`,
-      `tables: ${tablesType}`,
-      storeType,
-      fluentStoreMethod('setTables', 'tables'),
-      getTheContentOfTheStoreDoc(1, 1),
+      tableIdType,
+      tablesListenerType,
+      tableIdsListenerType,
+      tableListenerType,
+      rowIdsListenerType,
+      sortedRowIdsListenerType,
+      rowListenerType,
+      cellIdsListenerType,
+      cellListenerType,
+      tablesTypes,
+    ];
+    arrayForEach(
+      [
+        [tablesType],
+        [BOOLEAN],
+        [storeType, 'tables: ' + tablesType, 'tables'],
+        [storeType],
+      ],
+      ([returnType, params, paramsInCall], verb) =>
+        addProxyMethod(
+          verb,
+          EMPTY_STRING,
+          TABLES,
+          returnType,
+          getTheContentOfTheStoreDoc(1, verb),
+          params,
+          paramsInCall,
+        ),
     );
-    addMethod(
-      `delTables`,
+    addProxyMethod(
+      0,
       EMPTY_STRING,
-      storeType,
-      fluentStoreMethod('delTables'),
-      getTheContentOfTheStoreDoc(3, 1),
+      TABLE_IDS,
+      tableIdType + SQUARE_BRACKETS,
+      getIdsDoc(TABLE, THE_STORE),
     );
-    addMethod(
-      `getTableIds`,
+    addProxyMethod(
+      5,
       EMPTY_STRING,
-      `${tableIdType}[]`,
-      storeMethod('getTableIds', EMPTY_STRING, `${tableIdType}[]`),
-      getIdsDoc('Table', THE_STORE),
+      TABLE,
+      VOID,
+      getForEachDoc(TABLE, THE_STORE),
+      'tableCallback: ' + tableCallbackType,
+      'tableCallback as any',
     );
-    addMethod(
-      'forEachTable',
-      `tableCallback: ${tableCallbackType}`,
-      'void',
-      storeMethod('forEachTable', 'tableCallback as any'),
-      getForEachDoc('Table', THE_STORE),
-    );
-    const mapCellTypes = mapNew();
-    mapTablesSchema(
-      (
-        tableId,
+    mapTablesSchema((tableId, tableName, TABLE_ID) => {
+      const [
+        tableType,
+        rowType,
+        rowWhenSetType,
+        cellIdType,
+        cellCallbackType,
+        rowCallbackType,
+      ] = mapGet(tablesTypes, tableId);
+      arrayForEach(
         [
-          tableType,
-          rowType,
-          rowWhenSetType,
-          cellIdType,
-          cellCallbackType,
-          rowCallbackType,
+          [tableType],
+          [BOOLEAN],
+          [storeType, 'table: ' + tableType, ', table'],
+          [storeType],
         ],
+        ([returnType, params, paramsInCall = EMPTY_STRING], verb) =>
+          addProxyMethod(
+            verb,
+            tableName,
+            TABLE,
+            returnType,
+            getTableContentDoc(tableId, verb),
+            params,
+            TABLE_ID + paramsInCall,
+          ),
+      );
+      addProxyMethod(
+        0,
         tableName,
+        ROW_IDS,
+        IDS,
+        getIdsDoc(ROW, getTableDoc(tableId)),
+        EMPTY_STRING,
         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`,
+      );
+      addProxyMethod(
+        0,
+        tableName,
+        SORTED_ROW_IDS,
+        IDS,
+        getIdsDoc(ROW, getTableDoc(tableId), 1),
+        'cellId?: ' +
+          cellIdType +
+          ', descending?: boolean, offset?: number, limit?: number',
+        TABLE_ID + ', cellId, descending, offset, limit',
+      );
+      addProxyMethod(
+        5,
+        tableName,
+        ROW,
+        VOID,
+        getForEachDoc(ROW, getTableDoc(tableId)),
+        'rowCallback: ' + rowCallbackType,
+        TABLE_ID + ', rowCallback as any',
+      );
+      arrayForEach(
+        [
+          [rowType],
+          [BOOLEAN],
+          [storeType, ', row: ' + rowWhenSetType, ', row'],
+          [storeType],
+          [storeType, ', partialRow: ' + rowWhenSetType, ', partialRow'],
+        ],
+        (
+          [returnType, params = EMPTY_STRING, paramsInCall = EMPTY_STRING],
+          verb,
+        ) =>
+          addProxyMethod(
+            verb,
+            tableName,
+            ROW,
+            returnType,
+            getRowContentDoc(tableId, verb),
+            'rowId: Id' + params,
+            TABLE_ID + ', rowId' + paramsInCall,
           ),
-          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`,
+      );
+      addProxyMethod(
+        6,
+        tableName,
+        ROW,
+        ID + OR_UNDEFINED,
+        'Adds a new Row to ' + getTableDoc(tableId),
+        'row: ' + rowWhenSetType,
+        TABLE_ID + ', row',
+      );
+      addProxyMethod(
+        0,
+        tableName,
+        CELL_IDS,
+        cellIdType + SQUARE_BRACKETS,
+        getIdsDoc(CELL, getRowDoc(tableId)),
+        'rowId: ' + ID,
+        TABLE_ID + ', rowId',
+      );
+      addProxyMethod(
+        5,
+        tableName,
+        CELL,
+        VOID,
+        getForEachDoc(CELL, getRowDoc(tableId)),
+        'rowId: Id, cellCallback: ' + cellCallbackType,
+        TABLE_ID + ', rowId, cellCallback as any',
+      );
+      mapCellSchema(
+        tableId,
+        (cellId, type, defaultValue, CELL_ID, cellName) => {
+          const mapCellType = 'Map' + camel(type, 1);
+          mapSet(mapCellOrValueTypes, type, mapCellType);
+          const returnCellType =
+            type + (isUndefined(defaultValue) ? OR_UNDEFINED : EMPTY_STRING);
+          arrayForEach(
+            [
+              [returnCellType],
+              [BOOLEAN],
+              [storeType, `, cell: ${type} | ` + mapCellType, ', cell as any'],
+              [storeType],
+            ],
+            (
+              [returnType, params = EMPTY_STRING, paramsInCall = EMPTY_STRING],
+              verb,
+            ) =>
+              addProxyMethod(
+                verb,
+                tableName + cellName,
+                CELL,
+                returnType,
+                getCellContentDoc(tableId, cellId, verb),
+                'rowId: Id' + params,
+                TABLE_ID + ', rowId, ' + CELL_ID + paramsInCall,
               ),
-              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',
+          );
+        },
+      );
+    });
+    addProxyMethod(
+      0,
       EMPTY_STRING,
-      'Json',
-      storeMethod('getTablesJson'),
-      getTheContentOfTheStoreDoc(5, 1),
+      TABLES + JSON$1,
+      JSON$1,
+      getTheContentOfTheStoreDoc(1, 6),
     );
-    addMethod(
-      'setTablesJson',
-      'tablesJson: Json',
+    addProxyMethod(
+      2,
+      EMPTY_STRING,
+      TABLES + JSON$1,
       storeType,
-      fluentStoreMethod('setTablesJson', 'tablesJson'),
-      getTheContentOfTheStoreDoc(6, 1),
+      getTheContentOfTheStoreDoc(1, 7),
+      'tablesJson: ' + JSON$1,
+      'tables' + JSON$1,
     );
-    addMethod(
-      'addTablesListener',
-      `${LISTENER}: ${tablesListenerType}, mutator?: boolean`,
-      'Id',
-      storeListener('addTablesListener', EMPTY_STRING, 'mutator'),
-      getTheContentOfTheStoreDoc(7, 1) + ' changes',
+    addProxyListener(
+      TABLES,
+      tablesListenerType,
+      getTheContentOfTheStoreDoc(1, 8) + ' changes',
     );
-    addMethod(
-      'addTableIdsListener',
-      `${LISTENER}: ${tableIdsListenerType}, mutator?: boolean`,
-      'Id',
-      storeListener('addTableIdsListener', EMPTY_STRING, 'mutator'),
-      getListenerDoc('the Table Ids', THE_STORE, 1),
+    addProxyListener(TABLE_IDS, tableIdsListenerType, getListenerDoc(2, 0, 1));
+    addProxyListener(
+      TABLE,
+      tableListenerType,
+      getListenerDoc(3, 0),
+      `tableId: ${tableIdType} | null`,
+      'tableId',
     );
-    addMethod(
-      'addTableListener',
-      `tableId: ${tableIdType} | null, ${LISTENER}: ${tableListenerType}, mutator?: boolean`,
-      'Id',
-      storeListener('addTableListener', 'tableId', 'mutator'),
-      getListenerDoc('a Table', THE_STORE),
+    addProxyListener(
+      ROW_IDS,
+      rowIdsListenerType,
+      getListenerDoc(4, 3, 1),
+      `tableId: ${tableIdType} | null`,
+      'tableId',
     );
-    addMethod(
-      'addRowIdsListener',
-      `tableId: ${tableIdType} | null, ${LISTENER}: ${rowIdsListenerType}, mutator?: boolean`,
-      'Id',
-      storeListener('addRowIdsListener', 'tableId', 'mutator'),
-      getListenerDoc('the Row Ids', 'a Table', 1),
+    addProxyListener(
+      SORTED_ROW_IDS,
+      sortedRowIdsListenerType,
+      getListenerDoc(13, 3, 1),
+      getParameterList(
+        'tableId: ' + tableIdType,
+        'cellId: Id' + OR_UNDEFINED,
+        'descending: boolean',
+        'offset: number',
+        'limit: number' + OR_UNDEFINED,
+      ),
+      getParameterList('tableId', 'cellId', 'descending', 'offset', 'limit'),
     );
-    addMethod(
-      'addRowListener',
-      `tableId: ${tableIdType} | null, rowId: IdOrNull, ${LISTENER}: ${rowListenerType}, mutator?: boolean`,
-      'Id',
-      storeListener('addRowListener', 'tableId, rowId', 'mutator'),
-      getListenerDoc('a Row', 'a Table'),
+    addProxyListener(
+      ROW,
+      rowListenerType,
+      getListenerDoc(5, 3),
+      `tableId: ${tableIdType} | null, rowId: IdOrNull`,
+      'tableId, rowId',
     );
-    addMethod(
-      'addCellIdsListener',
-      `tableId: ${tableIdType} | null, rowId: IdOrNull, ${LISTENER}: ${cellIdsListenerType}, mutator?: boolean`,
-      'Id',
-      storeListener('addCellIdsListener', 'tableId, rowId', 'mutator'),
-      getListenerDoc('the Cell Ids', 'a Row', 1),
+    addProxyListener(
+      CELL_IDS,
+      cellIdsListenerType,
+      getListenerDoc(6, 5, 1),
+      `tableId: ${tableIdType} | null, rowId: IdOrNull`,
+      'tableId, rowId',
     );
-    addMethod(
-      'addCellListener',
+    addProxyListener(
+      CELL,
+      cellListenerType,
+      getListenerDoc(7, 5),
       `tableId: ${tableIdType} | null, rowId: IdOrNull, cellId: ${join(
-        mapTablesSchema((_, tableTypes2) => tableTypes2[3]),
+        mapTablesSchema(
+          (tableId) => mapGet(tablesTypes, tableId)?.[3] ?? EMPTY_STRING,
+        ),
         ' | ',
-      )} | 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',
-      ),
-      `${REGISTERS_A_LISTENER} whenever an invalid Cell change was attempted`,
+      )} | null`,
+      'tableId, rowId, cellId',
     );
-    mapForEach(mapCellTypes, (type, mapCellType) =>
-      addType(
-        mapCellType,
-        `(cell: ${type}${OR_UNDEFINED}) => ${type}`,
-        `Takes a ${type} Cell value and returns another`,
-      ),
+    addProxyListener(
+      INVALID + CELL,
+      invalidCellListenerType,
+      REGISTERS_A_LISTENER + ' whenever an invalid Cell change was attempted',
+      `tableId: IdOrNull, rowId: IdOrNull, cellId: IdOrNull`,
+      'tableId, rowId, cellId',
     );
     addImport(
       1,
@@ -818,18 +937,19 @@ const getStoreApi = (tablesSchema, valuesSchema, module) => {
       tableIdsListenerType,
       tableListenerType,
       rowIdsListenerType,
+      sortedRowIdsListenerType,
       rowListenerType,
       cellIdsListenerType,
       cellListenerType,
       invalidCellListenerType,
-      ...collValues(mapCellTypes),
+      ...collValues(mapCellOrValueTypes),
     );
     addImport(0, 'tinybase', 'CellChange');
     arrayPush(
       createSteps,
       '.setTablesSchema({',
       flat(
-        mapTablesSchema((tableId, _, __, TABLE_ID) => [
+        mapTablesSchema((tableId, _, TABLE_ID) => [
           `[${TABLE_ID}]: {`,
           ...mapCellSchema(
             tableId,
@@ -840,11 +960,10 @@ const getStoreApi = (tablesSchema, valuesSchema, module) => {
               )}]: ${addConstant(snake(type), `'${type}'`)}${
                 isUndefined(defaultValue)
                   ? EMPTY_STRING
-                  : `, [${addConstant(snake(DEFAULT), `'${DEFAULT}'`)}]: ${
-                      isString(defaultValue)
-                        ? addConstant(snake(defaultValue), `'${defaultValue}'`)
-                        : defaultValue
-                    }`
+                  : `, [${addConstant(snake(DEFAULT), `'${DEFAULT}'`)}]: ` +
+                    (isString(defaultValue)
+                      ? addConstant(snake(defaultValue), `'${defaultValue}'`)
+                      : defaultValue)
               }},`,
           ),
           `},`,
@@ -855,196 +974,183 @@ const getStoreApi = (tablesSchema, valuesSchema, module) => {
   }
   if (!objIsEmpty(valuesSchema)) {
     const valuesType = addType(
-      'Values',
-      `{${join(
-        mapValuesSchema(
-          (valueId, type, defaultValue) =>
-            `'${valueId}'${
-              isUndefined(defaultValue) ? '?' : EMPTY_STRING
-            }: ${type};`,
-        ),
-        ' ',
-      )}}`,
-      getTheContentOfTheStoreDoc(4, 2),
+      VALUES,
+      '{' +
+        join(
+          mapValuesSchema(
+            (valueId, type, defaultValue) =>
+              `'${valueId}'${
+                isUndefined(defaultValue) ? '?' : EMPTY_STRING
+              }: ${type};`,
+          ),
+          ' ',
+        ) +
+        '}',
+      getTheContentOfTheStoreDoc(2, 5),
     );
     const valuesWhenSetType = addType(
-      'ValuesWhenSet',
-      `{${join(
-        mapValuesSchema((valueId, type) => `'${valueId}'?: ${type};`),
-        ' ',
-      )}}`,
-      getTheContentOfTheStoreDoc(4, 2, 1),
+      VALUES + 'WhenSet',
+      '{' +
+        join(
+          mapValuesSchema((valueId, type) => `'${valueId}'?: ${type};`),
+          ' ',
+        ) +
+        '}',
+      getTheContentOfTheStoreDoc(2, 5, 1),
     );
     const valueIdType = addType(
-      'ValueId',
+      VALUE + ID,
       join(
         mapValuesSchema((valueId) => `'${valueId}'`),
         ' | ',
       ),
-      `A Value Id in ${THE_STORE}`,
+      'A Value Id in ' + THE_STORE,
     );
     const valueCallbackType = addType(
-      'ValueCallback',
+      VALUE + CALLBACK,
       `(...[valueId, rowCallback]: ${join(
         mapValuesSchema(
           (valueId, type) => `[valueId: '${valueId}', value: ${type}]`,
         ),
         ' | ',
-      )})${RETURNS_VOID}`,
+      )})` + 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`,
+      A_FUNCTION_FOR +
+        ` returning information about any Value's changes during a ` +
+        TRANSACTION_,
     );
     const valuesListenerType = addType(
-      'ValuesListener',
+      VALUES + LISTENER,
       `(${storeInstance}: ${storeType}, getValueChange: ${getValueChangeType}${OR_UNDEFINED})` +
         RETURNS_VOID,
       getListenerTypeDoc(9),
     );
     const valueIdsListenerType = addType(
-      'ValueIdsListener',
-      `(${storeInstance}: ${storeType})${RETURNS_VOID}`,
+      VALUE_IDS + LISTENER,
+      `(${storeInstance}: ${storeType})` + RETURNS_VOID,
       getListenerTypeDoc(10),
     );
     const valueListenerType = addType(
-      'ValueListener',
+      VALUE + LISTENER,
       `(...[${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}`,
+      )})` + RETURNS_VOID,
       getListenerTypeDoc(11),
     );
     const invalidValueListenerType = addType(
-      'InvalidValueListener',
-      `(${storeInstance}: ${storeType}, valueId: Id, invalidValues: any[])${RETURNS_VOID}`,
+      INVALID + VALUE + LISTENER,
+      `(${storeInstance}: ${storeType}, valueId: Id, invalidValues: any[])` +
+        RETURNS_VOID,
       getListenerTypeDoc(12),
     );
-    addMethod(
-      `hasValues`,
-      EMPTY_STRING,
-      BOOLEAN,
-      storeMethod('hasValues'),
-      getHasDoc('any Value'),
-    );
-    addMethod(
-      `getValues`,
-      EMPTY_STRING,
+    sharedValueTypes = [
       valuesType,
-      storeMethod('getValues', EMPTY_STRING, valuesType),
-      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),
+      valuesWhenSetType,
+      valueIdType,
+      valuesListenerType,
+      valueIdsListenerType,
+      valueListenerType,
+    ];
+    arrayForEach(
+      [
+        [valuesType],
+        [BOOLEAN],
+        [storeType, 'values: ' + valuesWhenSetType, 'values'],
+        [storeType],
+        [storeType, 'partialValues: ' + valuesWhenSetType, 'partialValues'],
+      ],
+      ([returnType, params, paramsInCall], verb) =>
+        addProxyMethod(
+          verb,
+          EMPTY_STRING,
+          VALUES,
+          returnType,
+          getTheContentOfTheStoreDoc(2, verb),
+          params,
+          paramsInCall,
+        ),
     );
-    addMethod(
-      `delValues`,
+    addProxyMethod(
+      0,
       EMPTY_STRING,
-      storeType,
-      fluentStoreMethod('delValues'),
-      getTheContentOfTheStoreDoc(3, 2),
+      VALUE_IDS,
+      valueIdType + SQUARE_BRACKETS,
+      getIdsDoc(VALUE, THE_STORE),
     );
-    addMethod(
-      `getValueIds`,
+    addProxyMethod(
+      5,
       EMPTY_STRING,
-      `${valueIdType}[]`,
-      storeMethod('getValueIds', EMPTY_STRING, `${valueIdType}[]`),
-      getIdsDoc('Value', THE_STORE),
-    );
-    addMethod(
-      'forEachValue',
+      VALUE,
+      `void`,
+      getForEachDoc(VALUE, THE_STORE),
       `valueCallback: ${valueCallbackType}`,
-      'void',
-      storeMethod('forEachValue', 'valueCallback as any'),
-      getForEachDoc('Value', THE_STORE),
+      'valueCallback as any',
     );
     mapValuesSchema((valueId, type, _, VALUE_ID, valueName) => {
-      addMethod(
-        `has${valueName}Value`,
-        EMPTY_STRING,
-        BOOLEAN,
-        storeMethod('hasValue', VALUE_ID),
-        getHasDoc(getValueDoc(valueId)),
-      );
-      addMethod(
-        `get${valueName}Value`,
-        EMPTY_STRING,
-        type,
-        storeMethod('getValue', VALUE_ID, type),
-        getValueContentDoc(valueId),
-      );
-      addMethod(
-        `set${valueName}Value`,
-        `value: ${type}`,
-        storeType,
-        fluentStoreMethod('setValue', `${VALUE_ID}, value`),
-        getValueContentDoc(valueId, 1),
-      );
-      addMethod(
-        `del${valueName}Value`,
-        EMPTY_STRING,
-        storeType,
-        fluentStoreMethod('delValue', VALUE_ID),
-        getValueContentDoc(valueId, 3),
+      const mapValueType = 'Map' + camel(type, 1);
+      mapSet(mapCellOrValueTypes, type, mapValueType);
+      arrayForEach(
+        [
+          [type],
+          [BOOLEAN],
+          [storeType, `value: ${type} | ` + mapValueType, ', value as any'],
+          [storeType],
+        ],
+        ([returnType, params, paramsInCall = EMPTY_STRING], verb) =>
+          addProxyMethod(
+            verb,
+            valueName,
+            VALUE,
+            returnType,
+            getValueContentDoc(valueId, verb),
+            params,
+            VALUE_ID + paramsInCall,
+          ),
       );
     });
-    addMethod(
-      'getValuesJson',
+    addProxyMethod(
+      0,
       EMPTY_STRING,
-      'Json',
-      storeMethod('getValuesJson'),
-      getTheContentOfTheStoreDoc(5, 2),
+      VALUES + JSON$1,
+      JSON$1,
+      getTheContentOfTheStoreDoc(2, 6),
     );
-    addMethod(
-      'setValuesJson',
-      'valuesJson: Json',
+    addProxyMethod(
+      2,
+      EMPTY_STRING,
+      VALUES + JSON$1,
       storeType,
-      fluentStoreMethod('setValuesJson', 'valuesJson'),
-      getTheContentOfTheStoreDoc(6, 2),
+      getTheContentOfTheStoreDoc(2, 7),
+      'valuesJson: ' + JSON$1,
+      'values' + JSON$1,
     );
-    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),
+    addProxyListener(
+      VALUES,
+      valuesListenerType,
+      getTheContentOfTheStoreDoc(2, 8) + ' changes',
     );
-    addMethod(
-      'addValueListener',
-      `valueId: ${valueIdType} | null, ${LISTENER}: ${valueListenerType}, mutator?: boolean`,
-      'Id',
-      storeListener('addValueListener', 'valueId', 'mutator'),
-      getListenerDoc('a Value', THE_STORE),
+    addProxyListener(VALUE_IDS, valueIdsListenerType, getListenerDoc(10, 0, 1));
+    addProxyListener(
+      VALUE,
+      valueListenerType,
+      getListenerDoc(11, 0),
+      `valueId: ${valueIdType} | null`,
+      'valueId',
     );
-    addMethod(
-      'addInvalidValueListener',
-      `valueId: IdOrNull, ${LISTENER}: ${invalidValueListenerType}, mutator?: boolean`,
-      'Id',
-      storeListener('addInvalidValueListener', 'valueId', 'mutator'),
-      `${REGISTERS_A_LISTENER} whenever an invalid Cell change was attempted`,
+    addProxyListener(
+      INVALID + VALUE,
+      invalidValueListenerType,
+      REGISTERS_A_LISTENER + ' whenever an invalid Value change was attempted',
+      `valueId: IdOrNull`,
+      'valueId',
     );
     addImport(
       1,
@@ -1069,94 +1175,122 @@ const getStoreApi = (tablesSchema, valuesSchema, module) => {
         )}]: ${addConstant(snake(type), `'${type}'`)}${
           isUndefined(defaultValue)
             ? EMPTY_STRING
-            : `, [${addConstant(snake(DEFAULT), `'${DEFAULT}'`)}]: ${
-                isString(defaultValue)
-                  ? addConstant(snake(defaultValue), `'${defaultValue}'`)
-                  : defaultValue
-              }`
+            : `, [${addConstant(snake(DEFAULT), `'${DEFAULT}'`)}]: ` +
+              (isString(defaultValue)
+                ? addConstant(snake(defaultValue), `'${defaultValue}'`)
+                : defaultValue)
         }},`,
       ]),
       '})',
     );
   }
-  addImport(0, 'tinybase', ...COMMON_IMPORTS);
+  mapForEach(mapCellOrValueTypes, (type, mapCellType) =>
+    addType(
+      mapCellType,
+      `(cell: ${type}${OR_UNDEFINED}) => ` + type,
+      `Takes a ${type} Cell value and returns another`,
+    ),
+  );
+  addImport(
+    null,
+    'tinybase',
+    'DoRollback',
+    ID,
+    'IdOrNull',
+    IDS,
+    JSON$1,
+    'Store',
+  );
   const transactionListenerType = addType(
-    'TransactionListener',
-    `(${storeInstance}: ${storeType}, cellsTouched: boolean, valuesTouched: boolean)${RETURNS_VOID}`,
-    `${A_FUNCTION_FOR} listening to the completion of a transaction`,
+    TRANSACTION + LISTENER,
+    `(${storeInstance}: ${storeType}, cellsTouched: boolean, valuesTouched: boolean)` +
+      RETURNS_VOID,
+    A_FUNCTION_FOR + ' listening to the completion of a ' + TRANSACTION_,
   );
-  addMethod(
-    'getJson',
+  addProxyMethod(
+    0,
     EMPTY_STRING,
-    'Json',
-    storeMethod('getJson'),
-    getTheContentOfTheStoreDoc(5),
+    JSON$1,
+    JSON$1,
+    getTheContentOfTheStoreDoc(0, 6),
   );
-  addMethod(
-    'setJson',
-    'json: Json',
+  addProxyMethod(
+    2,
+    EMPTY_STRING,
+    JSON$1,
     storeType,
-    fluentStoreMethod('setJson', 'json'),
-    getTheContentOfTheStoreDoc(6),
+    getTheContentOfTheStoreDoc(0, 7),
+    'json: ' + JSON$1,
+    'json',
   );
-  addMethod(
-    'transaction',
-    'actions: () => Return, doRollback?: DoRollback',
+  addProxyMethod(
+    7,
+    EMPTY_STRING,
+    TRANSACTION_,
     'Return',
-    storeMethod('transaction', 'actions, doRollback'),
-    'Execute a transaction to make multiple mutations',
+    'Execute a ' + TRANSACTION_ + ' to make multiple mutations',
+    'actions: () => Return, doRollback?: DoRollback',
+    'actions, doRollback',
     '<Return>',
   );
-  addMethod(
-    'startTransaction',
+  addProxyMethod(
+    7,
     EMPTY_STRING,
+    'start' + TRANSACTION,
     storeType,
-    fluentStoreMethod('startTransaction'),
-    'Explicitly starts a transaction',
+    'Explicitly starts a ' + TRANSACTION_,
   );
-  addMethod(
-    'finishTransaction',
-    'doRollback?: DoRollback,',
+  addProxyMethod(
+    7,
+    EMPTY_STRING,
+    'finish' + TRANSACTION,
     storeType,
-    fluentStoreMethod('finishTransaction', 'doRollback'),
-    'Explicitly finishes a transaction',
+    'Explicitly finishes a ' + TRANSACTION_,
+    'doRollback?: DoRollback,',
+    'doRollback',
   );
-  addMethod(
-    'addWillFinishTransactionListener',
-    `${LISTENER}: ${transactionListenerType}`,
-    'Id',
-    storeListener('addWillFinishTransactionListener'),
-    `${REGISTERS_A_LISTENER} just before ${THE_END_OF_THE_TRANSACTION}`,
+  addProxyListener(
+    'WillFinish' + TRANSACTION,
+    transactionListenerType,
+    REGISTERS_A_LISTENER + ' just before ' + THE_END_OF_THE_TRANSACTION,
+    EMPTY_STRING,
+    EMPTY_STRING,
+    0,
   );
-  addMethod(
-    'addDidFinishTransactionListener',
-    `${LISTENER}: ${transactionListenerType}`,
-    'Id',
-    storeListener('addDidFinishTransactionListener'),
-    `${REGISTERS_A_LISTENER} just after ${THE_END_OF_THE_TRANSACTION}`,
+  addProxyListener(
+    'DidFinish' + TRANSACTION,
+    transactionListenerType,
+    REGISTERS_A_LISTENER + ' just after ' + THE_END_OF_THE_TRANSACTION,
+    EMPTY_STRING,
+    EMPTY_STRING,
+    0,
   );
-  addMethod(
-    'callListener',
-    `${LISTENER}Id: Id`,
+  addProxyMethod(
+    7,
+    EMPTY_STRING,
+    'call' + LISTENER,
     storeType,
-    fluentStoreMethod('callListener', `${LISTENER}Id`),
-    `Manually provoke a ${LISTENER} to be called`,
+    `Manually provoke a listener to be called`,
+    `listenerId: Id`,
+    `listenerId`,
   );
-  addMethod(
-    'delListener',
-    `${LISTENER}Id: Id`,
+  addProxyMethod(
+    3,
+    EMPTY_STRING,
+    LISTENER,
     storeType,
-    fluentStoreMethod('delListener', `${LISTENER}Id`),
-    `Remove a ${LISTENER} that was previously added to ${THE_STORE}`,
+    'Remove a listener that was previously added to ' + THE_STORE,
+    'listenerId: Id',
+    'listenerId',
   );
   addMethod(
     'getStore',
     EMPTY_STRING,
     'Store',
     'store',
-    `${VERBS[0]} the underlying Store object`,
+    VERBS[0] + ' the underlying Store object',
   );
-  addImport(1, 'tinybase', 'createStore', ...COMMON_IMPORTS);
+  addImport(1, 'tinybase', 'createStore');
   addImport(
     1,
     moduleDefinition,
@@ -1165,33 +1299,806 @@ const getStoreApi = (tablesSchema, valuesSchema, module) => {
     transactionListenerType,
   );
   addConstant('store', ['createStore()', ...createSteps]);
-  addFunction('fluent', 'actions: () => Store', [
+  addInternalFunction('fluent', 'actions: () => Store', [
     'actions();',
     `return ${storeInstance};`,
   ]);
-  addFunction(
+  addInternalFunction(
     'proxy',
-    `${LISTENER}: any`,
-    `(_: Store, ...args: any[]) => ${LISTENER}(${storeInstance}, ...args)`,
+    `listener: any`,
+    `(_: Store, ...params: any[]) => listener(${storeInstance}, ...params)`,
   );
   addConstant(storeInstance, ['{', ...getMethods(1), '}']);
   return [
     build(
       ...getImports(0),
       ...getTypes(),
-      `${EXPORT} interface ${storeType} {`,
+      EXPORT + ' interface ' + storeType + ' {',
       ...getMethods(0),
-      `}`,
+      '}',
       EMPTY_STRING,
       comment(`Creates a ${storeType} object`),
-      `${EXPORT} function create${storeType}(): ${storeType};`,
+      EXPORT + ' function create' + storeType + '(): ' + storeType + ';',
     ),
     build(
       ...getImports(1),
-      `${EXPORT} const create${storeType}: typeof create${storeType}Decl = () => {`,
+      EXPORT +
+        ' const create' +
+        storeType +
+        ': typeof create' +
+        storeType +
+        'Decl = () => {',
       ...getConstants(),
       `return Object.freeze(${storeInstance});`,
-      `};`,
+      '};',
+    ),
+    sharedTableTypes,
+    sharedValueTypes,
+  ];
+};
+
+const DEPS = 'Deps';
+const getGet = (noun) => GET + noun;
+const getGetAndGetDeps = (noun) =>
+  getParameterList(getGet(noun), getGet(noun) + DEPS);
+const PARAMETER = 'Parameter';
+const GETTER_ARGS = ': (parameter: ' + PARAMETER + ', store: Store) => ';
+const USE_CONTEXT = 'const contextValue = useContext(Context);';
+const AND_REGISTERS =
+  ', and registers a listener so that any changes to that result will cause a re-render';
+const BASED_ON_A_PARAMETER = ', based on a parameter';
+const COLON_SPACE = ': ';
+const PARAMETERIZED_CALLBACK =
+  PARAMETER + 'ized' + CALLBACK + '<' + PARAMETER + '>';
+const GENERIC_PARAMETER = '<' + PARAMETER + ',>';
+const DEPS_SUFFIX = DEPS + '?: React.DependencyList';
+const THEN_DEPS = 'then' + DEPS_SUFFIX;
+const THEN_PREFIX = 'then?: (store: Store';
+const THEN_AND_THEN_DEPS = getParameterList(
+  THEN_PREFIX + ')' + RETURNS_VOID,
+  THEN_DEPS,
+);
+const THEN_AND_THEN_DEPS_IN_CALL = 'then, then' + DEPS;
+const ROW_ID = 'rowId';
+const TYPED_ROW_ID = ROW_ID + COLON_SPACE + ID;
+const getListenerHookParams = (listenerType, ...extraParams) =>
+  getParameterList(
+    ...extraParams,
+    LISTENER_ + ': ' + listenerType,
+    LISTENER_ + DEPS_SUFFIX,
+    'mutator?: boolean',
+  );
+const getListenerHookParamsInCall = (...extraParams) =>
+  getParameterList(...extraParams, LISTENER_, LISTENER_ + DEPS, 'mutator');
+const getStoreUiReactApi = (
+  tablesSchema,
+  valuesSchema,
+  module,
+  sharedTableTypes,
+  sharedValueTypes,
+) => {
+  const [
+    build,
+    addImport,
+    addType,
+    addInternalFunction,
+    addConstant,
+    getImports,
+    getTypes,
+    getConstants,
+  ] = getCodeFunctions();
+  const [mapTablesSchema, mapCellSchema, mapValuesSchema] = getSchemaFunctions(
+    tablesSchema,
+    valuesSchema,
+    addConstant,
+  );
+  const moduleDefinition = `./${camel(module)}.d`;
+  const uiReactModuleDefinition = `./${camel(module)}-ui-react.d`;
+  const tinyBaseUiReact = 'tinybase/ui-react';
+  const storeType = camel(module, 1);
+  const storeInstance = camel(storeType);
+  const StoreOrStoreId = storeType + 'Or' + storeType + ID;
+  const storeOrStoreId = storeInstance + 'Or' + storeType + ID;
+  const functions = mapNew();
+  const addFunction = (
+    name,
+    parameters,
+    returnType,
+    body,
+    doc,
+    generic = EMPTY_STRING,
+  ) => {
+    addImport(1, uiReactModuleDefinition, name + ' as ' + name + 'Decl');
+    return mapUnique(functions, name, [
+      parameters,
+      returnType,
+      isArray(body) ? ['{', body, '}'] : body,
+      doc,
+      generic,
+    ]);
+  };
+  const addHook = (
+    name,
+    parameters,
+    returnType,
+    body,
+    doc,
+    generic = EMPTY_STRING,
+  ) => addFunction(`use${name}`, parameters, returnType, body, doc, generic);
+  const addProxyHook = (
+    name,
+    underlyingName,
+    returnType,
+    doc,
+    preParameters = EMPTY_STRING,
+    preParametersInCall = EMPTY_STRING,
+    generic = EMPTY_STRING,
+    postParameters = EMPTY_STRING,
+    postParametersInCall = EMPTY_STRING,
+  ) => {
+    addImport(
+      1,
+      tinyBaseUiReact,
+      `use${underlyingName} as use${underlyingName}Core`,
+    );
+    addHook(
+      name,
+      getParameterList(preParameters, storeOrStoreIdParameter, postParameters),
+      returnType,
+      useHook +
+        `(${storeOrStoreId}, use${underlyingName}Core, [` +
+        (preParametersInCall ? preParametersInCall : EMPTY_STRING) +
+        (postParametersInCall ? '], [' + postParametersInCall : EMPTY_STRING) +
+        '])',
+      doc,
+      generic,
+    );
+  };
+  const addComponent = (name, parameters, body, doc) =>
+    addFunction(name, parameters, 1, body, doc);
+  const getFunctions = (location = 0) =>
+    mapMap(functions, ([parameters, returnType, body, doc, generic], name) => {
+      const lines = location
+        ? [
+            EXPORT +
+              ` const ${name}: typeof ${name}Decl = ${generic}(${parameters}): ${
+                returnType == 1 ? 'any' : returnType
+              } =>`,
+            body,
+          ]
+        : [
+            EXPORT +
+              ` function ${name}${generic}(${parameters}): ${
+                returnType == 1 ? 'ComponentReturnType' : returnType
+              };`,
+          ];
+      if (!location) {
+        arrayUnshift(lines, comment(doc));
+      }
+      arrayPush(lines, EMPTY_STRING);
+      return lines;
+    });
+  addImport(
+    null,
+    'tinybase',
+    ID,
+    IDS,
+    'IdOrNull',
+    'Store',
+    CALLBACK,
+    PARAMETER + 'ized' + CALLBACK,
+  );
+  addImport(0, tinyBaseUiReact, 'ComponentReturnType');
+  addImport(0, moduleDefinition, storeType);
+  const storeOrStoreIdType = addType(
+    StoreOrStoreId,
+    storeType + ' | ' + ID,
+    `Used when you need to refer to a ${storeType} in a React hook or component`,
+  );
+  const providerPropsType = addType(
+    'ProviderProps',
+    `{readonly ${storeInstance}?: ${storeType}; readonly ${storeInstance}ById?: {[${storeInstance}Id: Id]: ${storeType}}}`,
+    `Used with the Provider component, so that a ${storeType} can be passed into the context of an application`,
+  );
+  addImport(1, 'react', 'React');
+  addImport(1, uiReactModuleDefinition, storeOrStoreIdType, providerPropsType);
+  const storeOrStoreIdParameter = storeOrStoreId + '?: ' + storeOrStoreIdType;
+  addConstant('{createContext, useContext, useMemo}', 'React');
+  addConstant(
+    'Context',
+    `createContext<[${storeType}?, {[${storeInstance}Id: Id]: ${storeType}}?]>([])`,
+  );
+  addHook(
+    `Create${storeType}`,
+    `create: () => ${storeType}, create` + DEPS_SUFFIX,
+    storeType,
+    '\n// eslint-disable-next-line react-hooks/exhaustive-deps\nuseMemo(create, createDeps)',
+    `Create a ${storeType} within a React application with convenient memoization`,
+  );
+  const getStoreHook = addHook(
+    storeType,
+    `id?: Id`,
+    storeType + OR_UNDEFINED,
+    [
+      USE_CONTEXT,
+      'return id == null ? contextValue[0] : contextValue[1]?.[id];',
+    ],
+    `Get a reference to a ${storeType} from within a Provider component context`,
+  );
+  const useHook = addInternalFunction(
+    `useHook`,
+    storeOrStoreId +
+      `: ${storeOrStoreIdType} | undefined, hook: (...params: any[]) => any, preParams: any[], postParams: any[] = []`,
+    [
+      `const ${storeInstance} = ${getStoreHook}(${storeOrStoreId} as Id);`,
+      `return hook(...preParams, ((${storeOrStoreId} == null || typeof ${storeOrStoreId} == 'string')`,
+      `? ${storeInstance} : ${storeOrStoreId})?.getStore(), ...postParams)`,
+    ],
+  );
+  if (!objIsEmpty(tablesSchema)) {
+    const [
+      tablesType,
+      tableIdType,
+      tablesListenerType,
+      tableIdsListenerType,
+      tableListenerType,
+      rowIdsListenerType,
+      sortedRowIdsListenerType,
+      rowListenerType,
+      cellIdsListenerType,
+      cellListenerType,
+      tablesTypes,
+    ] = sharedTableTypes;
+    addImport(
+      null,
+      moduleDefinition,
+      tablesType,
+      tableIdType,
+      tablesListenerType,
+      tableIdsListenerType,
+      tableListenerType,
+      rowIdsListenerType,
+      sortedRowIdsListenerType,
+      rowListenerType,
+      cellIdsListenerType,
+      cellListenerType,
+    );
+    addImport(1, tinyBaseUiReact);
+    addImport(1, moduleDefinition, storeType);
+    addProxyHook(
+      TABLES,
+      TABLES,
+      tablesType,
+      getTheContentOfTheStoreDoc(1, 0) + AND_REGISTERS,
+    );
+    addProxyHook(
+      TABLE_IDS,
+      TABLE_IDS,
+      tableIdType + SQUARE_BRACKETS,
+      getIdsDoc(TABLE, THE_STORE) + AND_REGISTERS,
+    );
+    addProxyHook(
+      SET + TABLES + CALLBACK,
+      SET + TABLES + CALLBACK,
+      PARAMETERIZED_CALLBACK,
+      getTheContentOfTheStoreDoc(1, 9) + BASED_ON_A_PARAMETER,
+      getParameterList(
+        getGet(TABLES) + GETTER_ARGS + tablesType,
+        getGet(TABLES) + DEPS_SUFFIX,
+      ),
+      getGetAndGetDeps(TABLES),
+      GENERIC_PARAMETER,
+      getParameterList(
+        THEN_PREFIX,
+        `tables: ${tablesType})` + RETURNS_VOID,
+        THEN_DEPS,
+      ),
+      THEN_AND_THEN_DEPS_IN_CALL,
+    );
+    addProxyHook(
+      DEL + TABLES + CALLBACK,
+      DEL + TABLES + CALLBACK,
+      CALLBACK,
+      getTheContentOfTheStoreDoc(1, 12),
+      EMPTY_STRING,
+      EMPTY_STRING,
+      EMPTY_STRING,
+      THEN_AND_THEN_DEPS,
+      THEN_AND_THEN_DEPS_IN_CALL,
+    );
+    mapTablesSchema((tableId, tableName, TABLE_ID) => {
+      const [tableType, rowType, rowWhenSetType, cellIdType] = mapGet(
+        tablesTypes,
+        tableId,
+      );
+      addImport(
+        0,
+        moduleDefinition,
+        tableType,
+        rowType,
+        rowWhenSetType,
+        cellIdType,
+      );
+      addImport(
+        1,
+        moduleDefinition,
+        tableType,
+        rowType,
+        rowWhenSetType,
+        cellIdType,
+      );
+      addProxyHook(
+        tableName + TABLE,
+        TABLE,
+        tableType,
+        getTableContentDoc(tableId) + AND_REGISTERS,
+        EMPTY_STRING,
+        TABLE_ID,
+      );
+      addProxyHook(
+        tableName + ROW_IDS,
+        ROW_IDS,
+        IDS,
+        getIdsDoc(ROW, getTableDoc(tableId)) + AND_REGISTERS,
+        EMPTY_STRING,
+        TABLE_ID,
+      );
+      addProxyHook(
+        tableName + SORTED_ROW_IDS,
+        SORTED_ROW_IDS,
+        IDS,
+        getIdsDoc(ROW, getTableDoc(tableId), 1) + AND_REGISTERS,
+        'cellId?: ' +
+          cellIdType +
+          ', descending?: boolean, offset?: number, limit?: number',
+        TABLE_ID + ', cellId, descending, offset, limit',
+      );
+      addProxyHook(
+        tableName + ROW,
+        ROW,
+        rowType,
+        getRowContentDoc(tableId) + AND_REGISTERS,
+        TYPED_ROW_ID,
+        getParameterList(TABLE_ID, ROW_ID),
+      );
+      addProxyHook(
+        tableName + CELL_IDS,
+        CELL_IDS,
+        cellIdType + SQUARE_BRACKETS,
+        getIdsDoc(CELL, getRowDoc(tableId)) + AND_REGISTERS,
+        TYPED_ROW_ID,
+        getParameterList(TABLE_ID, ROW_ID),
+      );
+      addProxyHook(
+        SET + tableName + TABLE + CALLBACK,
+        SET + TABLE + CALLBACK,
+        PARAMETERIZED_CALLBACK,
+        getTableContentDoc(tableId, 9) + BASED_ON_A_PARAMETER,
+        getParameterList(
+          getGet(TABLE) + GETTER_ARGS + tableType,
+          getGet(TABLE) + DEPS_SUFFIX,
+        ),
+        getParameterList(TABLE_ID, getGetAndGetDeps(TABLE)),
+        GENERIC_PARAMETER,
+        getParameterList(
+          THEN_PREFIX,
+          `table: ${tableType})` + RETURNS_VOID,
+          THEN_DEPS,
+        ),
+        THEN_AND_THEN_DEPS_IN_CALL,
+      );
+      addProxyHook(
+        DEL + tableName + TABLE + CALLBACK,
+        DEL + TABLE + CALLBACK,
+        CALLBACK,
+        getTableContentDoc(tableId, 12),
+        EMPTY_STRING,
+        TABLE_ID,
+        EMPTY_STRING,
+        THEN_AND_THEN_DEPS,
+        THEN_AND_THEN_DEPS_IN_CALL,
+      );
+      addProxyHook(
+        SET + tableName + ROW + CALLBACK,
+        SET + ROW + CALLBACK,
+        PARAMETERIZED_CALLBACK,
+        getRowContentDoc(tableId, 9) + BASED_ON_A_PARAMETER,
+        getParameterList(
+          TYPED_ROW_ID,
+          getGet(ROW) + GETTER_ARGS + rowWhenSetType,
+          getGet(ROW) + DEPS_SUFFIX,
+        ),
+        getParameterList(TABLE_ID, ROW_ID, getGetAndGetDeps(ROW)),
+        GENERIC_PARAMETER,
+        getParameterList(
+          THEN_PREFIX,
+          `row: ${rowWhenSetType})` + RETURNS_VOID,
+          THEN_DEPS,
+        ),
+        THEN_AND_THEN_DEPS_IN_CALL,
+      );
+      addProxyHook(
+        'Add' + tableName + ROW + CALLBACK,
+        'Add' + ROW + CALLBACK,
+        PARAMETERIZED_CALLBACK,
+        getRowContentDoc(tableId, 10) + BASED_ON_A_PARAMETER,
+        getParameterList(
+          getGet(ROW) + GETTER_ARGS + rowWhenSetType,
+          getGet(ROW) + DEPS_SUFFIX,
+        ),
+        getParameterList(TABLE_ID, getGetAndGetDeps(ROW)),
+        GENERIC_PARAMETER,
+        'then?: (' +
+          getParameterList(
+            TYPED_ROW_ID + OR_UNDEFINED,
+            'store: Store',
+            'row: ' + rowWhenSetType + ')' + RETURNS_VOID,
+            'then' + DEPS_SUFFIX,
+          ),
+        THEN_AND_THEN_DEPS_IN_CALL,
+      );
+      addProxyHook(
+        SET + tableName + PARTIAL + ROW + CALLBACK,
+        SET + PARTIAL + ROW + CALLBACK,
+        PARAMETERIZED_CALLBACK,
+        getRowContentDoc(tableId, 11) + BASED_ON_A_PARAMETER,
+        getParameterList(
+          TYPED_ROW_ID,
+          getGet(PARTIAL + ROW) + GETTER_ARGS + rowWhenSetType,
+          getGet(PARTIAL + ROW) + DEPS_SUFFIX,
+        ),
+        getParameterList(TABLE_ID, ROW_ID, getGetAndGetDeps(PARTIAL + ROW)),
+        GENERIC_PARAMETER,
+        getParameterList(
+          THEN_PREFIX,
+          `partialRow: ${rowWhenSetType})` + RETURNS_VOID,
+          THEN_DEPS,
+        ),
+        THEN_AND_THEN_DEPS_IN_CALL,
+      );
+      addProxyHook(
+        DEL + tableName + ROW + CALLBACK,
+        DEL + ROW + CALLBACK,
+        CALLBACK,
+        getRowContentDoc(tableId, 12),
+        TYPED_ROW_ID,
+        getParameterList(TABLE_ID, ROW_ID),
+        EMPTY_STRING,
+        THEN_AND_THEN_DEPS,
+        THEN_AND_THEN_DEPS_IN_CALL,
+      );
+      mapCellSchema(
+        tableId,
+        (cellId, type, defaultValue, CELL_ID, cellName) => {
+          const mapCellType = 'Map' + camel(type, 1);
+          addImport(0, moduleDefinition, mapCellType);
+          addImport(1, moduleDefinition, mapCellType);
+          addProxyHook(
+            tableName + cellName + CELL,
+            CELL,
+            type + (isUndefined(defaultValue) ? OR_UNDEFINED : EMPTY_STRING),
+            getCellContentDoc(tableId, cellId) + AND_REGISTERS,
+            TYPED_ROW_ID,
+            getParameterList(TABLE_ID, ROW_ID, CELL_ID),
+          );
+          addProxyHook(
+            SET + tableName + cellName + CELL + CALLBACK,
+            SET + CELL + CALLBACK,
+            PARAMETERIZED_CALLBACK,
+            getCellContentDoc(tableId, cellId, 9) + BASED_ON_A_PARAMETER,
+            getParameterList(
+              TYPED_ROW_ID,
+              getGet(CELL) + GETTER_ARGS + type + ' | ' + mapCellType,
+              getGet(CELL) + DEPS_SUFFIX,
+            ),
+            getParameterList(TABLE_ID, ROW_ID, CELL_ID, getGetAndGetDeps(CELL)),
+            GENERIC_PARAMETER,
+            getParameterList(
+              THEN_PREFIX,
+              `cell: ${type} | ${mapCellType})` + RETURNS_VOID,
+              THEN_DEPS,
+            ),
+            THEN_AND_THEN_DEPS_IN_CALL,
+          );
+          addProxyHook(
+            DEL + tableName + cellName + CELL + CALLBACK,
+            DEL + CELL + CALLBACK,
+            CALLBACK,
+            getCellContentDoc(tableId, cellId, 12),
+            getParameterList(TYPED_ROW_ID, 'forceDel?: boolean'),
+            getParameterList(TABLE_ID, ROW_ID, CELL_ID, 'forceDel'),
+            EMPTY_STRING,
+            THEN_AND_THEN_DEPS,
+            THEN_AND_THEN_DEPS_IN_CALL,
+          );
+        },
+      );
+    });
+    const cellIdsType = join(
+      mapTablesSchema(
+        (tableId) => mapGet(tablesTypes, tableId)?.[3] ?? EMPTY_STRING,
+      ),
+      ' | ',
+    );
+    addProxyHook(
+      TABLES + LISTENER,
+      TABLES + LISTENER,
+      VOID,
+      getTheContentOfTheStoreDoc(1, 8) + ' changes',
+      getListenerHookParams(tablesListenerType),
+      getListenerHookParamsInCall(),
+    );
+    addProxyHook(
+      TABLE_IDS + LISTENER,
+      TABLE_IDS + LISTENER,
+      VOID,
+      getListenerDoc(2, 0, 1),
+      getListenerHookParams(tableIdsListenerType),
+      getListenerHookParamsInCall(),
+    );
+    addProxyHook(
+      TABLE + LISTENER,
+      TABLE + LISTENER,
+      VOID,
+      getListenerDoc(3, 0),
+      getListenerHookParams(
+        tableListenerType,
+        `tableId: ${tableIdType} | null`,
+      ),
+      getListenerHookParamsInCall('tableId'),
+    );
+    addProxyHook(
+      ROW_IDS + LISTENER,
+      ROW_IDS + LISTENER,
+      VOID,
+      getListenerDoc(4, 3, 1),
+      getListenerHookParams(
+        rowIdsListenerType,
+        `tableId: ${tableIdType} | null`,
+      ),
+      getListenerHookParamsInCall('tableId'),
+    );
+    addProxyHook(
+      SORTED_ROW_IDS + LISTENER,
+      SORTED_ROW_IDS + LISTENER,
+      VOID,
+      getListenerDoc(13, 3, 1),
+      getListenerHookParams(
+        sortedRowIdsListenerType,
+        `tableId: ${tableIdType} | null`,
+        'cellId: ' + cellIdsType + OR_UNDEFINED,
+        'descending: boolean',
+        'offset: number',
+        'limit: number' + OR_UNDEFINED,
+      ),
+      getListenerHookParamsInCall(
+        'tableId',
+        'cellId',
+        'descending',
+        'offset',
+        'limit',
+      ),
+    );
+    addProxyHook(
+      ROW + LISTENER,
+      ROW + LISTENER,
+      VOID,
+      getListenerDoc(5, 3),
+      getListenerHookParams(
+        rowListenerType,
+        `tableId: ${tableIdType} | null`,
+        ROW_ID + `: IdOrNull`,
+      ),
+      getListenerHookParamsInCall('tableId', ROW_ID),
+    );
+    addProxyHook(
+      CELL_IDS + LISTENER,
+      CELL_IDS + LISTENER,
+      VOID,
+      getListenerDoc(6, 5, 1),
+      getListenerHookParams(
+        cellIdsListenerType,
+        `tableId: ${tableIdType} | null`,
+        ROW_ID + `: IdOrNull`,
+      ),
+      getListenerHookParamsInCall('tableId', ROW_ID),
+    );
+    addProxyHook(
+      CELL + LISTENER,
+      CELL + LISTENER,
+      VOID,
+      getListenerDoc(7, 5),
+      getListenerHookParams(
+        cellListenerType,
+        `tableId: ${tableIdType} | null`,
+        ROW_ID + `: IdOrNull`,
+        `cellId: ${cellIdsType} | null`,
+      ),
+      getListenerHookParamsInCall('tableId', ROW_ID, 'cellId'),
+    );
+  }
+  if (!objIsEmpty(valuesSchema)) {
+    const [
+      valuesType,
+      valuesWhenSetType,
+      valueIdType,
+      valuesListenerType,
+      valueIdsListenerType,
+      valueListenerType,
+    ] = sharedValueTypes;
+    addImport(null, moduleDefinition, ...sharedValueTypes);
+    addProxyHook(
+      VALUES,
+      VALUES,
+      valuesType,
+      getTheContentOfTheStoreDoc(2, 0) + AND_REGISTERS,
+    );
+    addProxyHook(
+      VALUE_IDS,
+      VALUE_IDS,
+      valueIdType + SQUARE_BRACKETS,
+      getIdsDoc(VALUE, THE_STORE) + AND_REGISTERS,
+    );
+    addProxyHook(
+      SET + VALUES + CALLBACK,
+      SET + VALUES + CALLBACK,
+      PARAMETERIZED_CALLBACK,
+      getTheContentOfTheStoreDoc(2, 9) + BASED_ON_A_PARAMETER,
+      getParameterList(
+        getGet(VALUES) + GETTER_ARGS + valuesWhenSetType,
+        getGet(VALUES) + DEPS_SUFFIX,
+      ),
+      getGetAndGetDeps(VALUES),
+      GENERIC_PARAMETER,
+      getParameterList(
+        THEN_PREFIX,
+        `values: ${valuesWhenSetType})` + RETURNS_VOID,
+        THEN_DEPS,
+      ),
+      THEN_AND_THEN_DEPS_IN_CALL,
+    );
+    addProxyHook(
+      SET + PARTIAL + VALUES + CALLBACK,
+      SET + PARTIAL + VALUES + CALLBACK,
+      PARAMETERIZED_CALLBACK,
+      getTheContentOfTheStoreDoc(2, 11) + BASED_ON_A_PARAMETER,
+      getParameterList(
+        getGet(PARTIAL + VALUES) + GETTER_ARGS + valuesWhenSetType,
+        getGet(PARTIAL + VALUES) + DEPS_SUFFIX,
+      ),
+      getGetAndGetDeps(PARTIAL + VALUES),
+      GENERIC_PARAMETER,
+      getParameterList(
+        THEN_PREFIX,
+        `partialValues: ${valuesWhenSetType})` + RETURNS_VOID,
+        THEN_DEPS,
+      ),
+      THEN_AND_THEN_DEPS_IN_CALL,
+    );
+    addProxyHook(
+      DEL + VALUES + CALLBACK,
+      DEL + VALUES + CALLBACK,
+      CALLBACK,
+      getTheContentOfTheStoreDoc(2, 12),
+      EMPTY_STRING,
+      EMPTY_STRING,
+      EMPTY_STRING,
+      THEN_AND_THEN_DEPS,
+      THEN_AND_THEN_DEPS_IN_CALL,
+    );
+    mapValuesSchema((valueId, type, _, VALUE_ID, valueName) => {
+      const mapValueType = 'Map' + camel(type, 1);
+      addImport(0, moduleDefinition, mapValueType);
+      addImport(1, moduleDefinition, mapValueType);
+      addProxyHook(
+        valueName + VALUE,
+        VALUE,
+        type,
+        getValueContentDoc(valueId) + AND_REGISTERS,
+        EMPTY_STRING,
+        VALUE_ID,
+      );
+      addProxyHook(
+        SET + valueName + VALUE + CALLBACK,
+        SET + VALUE + CALLBACK,
+        PARAMETERIZED_CALLBACK,
+        getValueContentDoc(valueId, 9) + BASED_ON_A_PARAMETER,
+        getParameterList(
+          getGet(VALUE) + GETTER_ARGS + type + ' | ' + mapValueType,
+          getGet(VALUE) + DEPS_SUFFIX,
+        ),
+        getParameterList(VALUE_ID, getGetAndGetDeps(VALUE)),
+        GENERIC_PARAMETER,
+        getParameterList(
+          THEN_PREFIX,
+          `value: ${type} | ${mapValueType})` + RETURNS_VOID,
+          THEN_DEPS,
+        ),
+        THEN_AND_THEN_DEPS_IN_CALL,
+      );
+      addProxyHook(
+        DEL + valueName + VALUE + CALLBACK,
+        DEL + VALUE + CALLBACK,
+        CALLBACK,
+        getValueContentDoc(valueId, 12),
+        EMPTY_STRING,
+        VALUE_ID,
+        EMPTY_STRING,
+        THEN_AND_THEN_DEPS,
+        THEN_AND_THEN_DEPS_IN_CALL,
+      );
+    });
+    addProxyHook(
+      VALUES + LISTENER,
+      VALUES + LISTENER,
+      VOID,
+      getTheContentOfTheStoreDoc(2, 8) + ' changes',
+      getListenerHookParams(valuesListenerType),
+      getListenerHookParamsInCall(),
+    );
+    addProxyHook(
+      VALUE_IDS + LISTENER,
+      VALUE_IDS + LISTENER,
+      VOID,
+      getListenerDoc(10, 0, 1),
+      getListenerHookParams(valueIdsListenerType),
+      getListenerHookParamsInCall(),
+    );
+    addProxyHook(
+      VALUE + LISTENER,
+      VALUE + LISTENER,
+      VOID,
+      getListenerDoc(11, 0),
+      getListenerHookParams(
+        valueListenerType,
+        `valueId: ${valueIdType} | null`,
+      ),
+      getListenerHookParamsInCall('valueId'),
+    );
+  }
+  addComponent(
+    'Provider',
+    `{${storeInstance}, ${storeInstance}ById, children}: ` +
+      providerPropsType +
+      ' & {children: React.ReactNode}',
+    [
+      USE_CONTEXT,
+      'return (',
+      '<Context.Provider',
+      'value={useMemo(',
+      `() => [${storeInstance} ?? contextValue[0], {...contextValue[1], ...${storeInstance}ById}],`,
+      `[${storeInstance}, ${storeInstance}ById, contextValue],`,
+      ')}>',
+      '{children}',
+      '</Context.Provider>',
+      ');',
+    ],
+    'Wraps part of an application in a context that provides default objects to be used by hooks and components within',
+  );
+  return [
+    build(...getImports(0), ...getTypes(), ...getFunctions(0)),
+    build(...getImports(1), ...getConstants(), ...getFunctions(1)),
+  ];
+};
+
+const getStoreApi = (tablesSchema, valuesSchema, module) => {
+  if (objIsEmpty(tablesSchema) && objIsEmpty(valuesSchema)) {
+    return [EMPTY_STRING, EMPTY_STRING, EMPTY_STRING, EMPTY_STRING];
+  }
+  const [dTsCore, tsCore, sharedTableTypes, sharedValueTypes] = getStoreCoreApi(
+    tablesSchema,
+    valuesSchema,
+    module,
+  );
+  return [
+    dTsCore,
+    tsCore,
+    ...getStoreUiReactApi(
+      tablesSchema,
+      valuesSchema,
+      module,
+      sharedTableTypes,
+      sharedValueTypes,
     ),
   ];
 };
@@ -1295,14 +2202,17 @@ const createTools = getCreateFunction((store) => {
   const getStoreApi$1 = (module) =>
     getStoreApi(getStoreTablesSchema(), getStoreValuesSchema(), module);
   const getPrettyStoreApi = async (module) => {
+    const extensions = ['d.ts', 'ts', 'd.ts', 'tsx'];
     let format;
     try {
       format = (await import('prettier')).format;
-    } catch {
+    } catch (e) {
       format = (str) => str;
     }
-    return arrayMap(getStoreApi$1(module), (file) =>
-      formatJsDoc(format(file, prettierConfig)),
+    return arrayMap(getStoreApi$1(module), (file, f) =>
+      formatJsDoc(
+        format(file, {...prettierConfig, filepath: `_.${extensions[f]}`}),
+      ),
     );
   };
   const getStore = () => store;