tinybase 3.1.0-beta.2 → 3.1.0-beta.3

package/lib/debug/tools.js

@@ -74,27 +74,44 @@ const A = 'a ';
 const A_FUNCTION_FOR = 'A function for';
 const CALLBACK = 'Callback';
 const DEL = 'Del';
+const DO_ROLLBACK_PARAM = 'doRollback?: DoRollback';
+const DO_ACTIONS_AND_ROLLBACK_PARAMS =
+  'actions: () => Return, ' + DO_ROLLBACK_PARAM;
 const EXPORT = 'export';
 const ID = 'Id';
+const ID_OR_NULL = 'IdOrNull';
 const INVALID = 'Invalid';
 const JSON$1 = 'Json';
 const LISTENER_ = lower(LISTENER);
 const OR_UNDEFINED = ' | undefined';
+const NON_NULLABLE = 'NonNullable';
 const PARTIAL = 'Partial';
 const REGISTERS_A_LISTENER = `Registers a ${LISTENER_} that will be called`;
 const REPRESENTS = 'Represents';
+const ROW_ID_PARAM = 'rowId: ' + ID;
+const ROW_ID_OR_NULL_PARAM = 'rowId: ' + ID_OR_NULL;
+const SCHEMA = 'Schema';
 const SET = 'Set';
+const SORTED_ARGS = ', descending?: boolean, offset?: number, limit?: number';
 const SQUARE_BRACKETS = '[]';
-const THE_STORE = 'the Store';
+const STORE = 'Store';
+const THE_STORE = 'the ' + STORE;
 const TRANSACTION = 'Transaction';
 const TRANSACTION_ = lower(TRANSACTION);
+const TRANSACTION_DOC =
+  'Execute a ' + TRANSACTION_ + ' to make multiple mutations';
+const START_TRANSACTION_DOC = 'Explicitly starts a ' + TRANSACTION_;
+const FINISH_TRANSACTION_DOC = 'Explicitly finishes a ' + TRANSACTION_;
 const THE_END_OF_THE_TRANSACTION = 'the end of the ' + TRANSACTION_;
 const VOID = 'void';
 const RETURNS_VOID = ' => ' + VOID;
+const WHEN_SET = 'WhenSet';
+const WHEN_SETTING_IT = ' when setting it';
 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 THE_SCHEMA_FOR = ' the schema for';
 const getTheContentOfDoc = (content = 0, theStore = 0) =>
   `the ${CONTENT[content]}content of` +
   (theStore ? SPACE + THE_STORE : EMPTY_STRING);
@@ -102,7 +119,7 @@ const getTheContentOfTheStoreDoc = (content = 0, verb, set = 0) =>
   VERBS[verb] +
   SPACE +
   getTheContentOfDoc(content, 1) +
-  (set ? ' when set' : EMPTY_STRING);
+  (set ? ' when setting it' : EMPTY_STRING);
 const getRowTypeDoc = (tableId, set = 0) =>
   REPRESENTS +
   ` a Row when ${
@@ -133,6 +150,7 @@ const getListenerDoc = (childNoun, parentNoun, pluralChild = 0) =>
   (pluralChild ? EMPTY_STRING : 's');
 const getTableDoc = (tableId) => `the '${tableId}' ` + TABLE;
 const getRowDoc = (tableId) => 'the specified Row in ' + getTableDoc(tableId);
+const getContentDoc = (verb = 0, noun = 0) => VERBS[verb] + SPACE + NOUNS[noun];
 const getTableContentDoc = (tableId, verb = 0) =>
   VERBS[verb] + ` ${getTheContentOfDoc()} ` + getTableDoc(tableId);
 const getRowContentDoc = (tableId, verb = 0) =>
@@ -156,6 +174,20 @@ const VERBS = [
   GETS_A_CALLBACK_THAT_CAN + 'set part of',
   GETS_A_CALLBACK_THAT_CAN + 'delete',
   'Renders',
+  'Gets ' + A_STRING_SERIALIZATION_OF + THE_SCHEMA_FOR,
+  'Sets' + THE_SCHEMA_FOR,
+  'Deletes' + THE_SCHEMA_FOR,
+];
+const METHOD_PREFIX_VERBS = [
+  GET,
+  'has',
+  'set',
+  'del',
+  'set',
+  // partial
+  'forEach',
+  ADD,
+  EMPTY_STRING,
 ];
 const NOUNS = [
   THE_STORE,
@@ -234,6 +266,9 @@ const getParameterList = (...params) =>
     arrayFilter(params, (param) => param),
     ', ',
   );
+const getFieldTypeList = (...props) => '{' + join(props, '; ') + '}';
+const getPropTypeList = (...props) =>
+  getFieldTypeList(...arrayMap(props, (prop) => 'readonly ' + prop));
 const getCodeFunctions = () => {
   const allImports = [mapNew(), mapNew(), mapNew(), mapNew()];
   const types = mapNew();
@@ -247,7 +282,8 @@ const getCodeFunctions = () => {
           : 0,
       ),
     );
-  const addType = (name, body, doc) => mapUnique(types, name, [body, doc]);
+  const addType = (name, body, doc, generic = EMPTY_STRING, exported = 1) =>
+    mapUnique(types, name, [body, doc, generic, exported]);
   const addInternalFunction = (name, parameters, body) =>
     mapUnique(
       constants,
@@ -285,9 +321,11 @@ const getCodeFunctions = () => {
       // sigh
     );
   const getTypes = () =>
-    mapMap(types, ([body, doc], name) => [
+    mapMap(types, ([body, doc, generic, exported], name) => [
       comment(doc),
-      `${EXPORT} type ${name} = ${body};`,
+      `${
+        exported ? EXPORT + ' ' : EMPTY_STRING
+      }type ${name}${generic} = ${body};`,
       EMPTY_STRING,
     ]);
   const getConstants = () =>
@@ -359,16 +397,362 @@ const getSchemaFunctions = (tablesSchema, valuesSchema, addConstant) => {
   return [mapTablesSchema, mapCellSchema, mapValuesSchema];
 };
 
-const METHOD_PREFIX_VERBS = [
-  GET,
-  'has',
-  'set',
-  'del',
-  'set',
-  'forEach',
-  ADD,
-  EMPTY_STRING,
-];
+const getTypeFunctions = (
+  addType,
+  mapTablesSchema,
+  mapCellSchema,
+  mapValuesSchema,
+) => {
+  const getTablesTypes = (storeInstance, storeType) => {
+    const storeParam = storeInstance + ': ' + storeType;
+    const tablesType = addType(
+      TABLES,
+      getFieldTypeList(
+        ...mapTablesSchema(
+          (tableId) =>
+            `'${tableId}'?: {[rowId: Id]: ` +
+            getFieldTypeList(
+              ...mapCellSchema(
+                tableId,
+                (cellId, type, defaultValue) =>
+                  `'${cellId}'${
+                    isUndefined(defaultValue) ? '?' : EMPTY_STRING
+                  }: ${type}`,
+              ),
+            ) +
+            '}',
+        ),
+      ),
+      getTheContentOfTheStoreDoc(1, 5),
+    );
+    const tablesWhenSetType = addType(
+      TABLES + WHEN_SET,
+      getFieldTypeList(
+        ...mapTablesSchema(
+          (tableId) =>
+            `'${tableId}'?: {[rowId: Id]: ` +
+            getFieldTypeList(
+              ...mapCellSchema(
+                tableId,
+                (cellId, type) => `'${cellId}'?: ${type}`,
+              ),
+            ) +
+            '}',
+        ),
+      ),
+      getTheContentOfTheStoreDoc(1, 5, 1),
+    );
+    const tableIdType = addType(
+      TABLE + ID,
+      'keyof ' + tablesType,
+      'A ' + TABLE + ' Id in ' + THE_STORE,
+    );
+    const tIdGeneric = `<TId extends ${tableIdType}>`;
+    const tableType = addType(
+      TABLE,
+      NON_NULLABLE + `<${tablesType}[TId]>`,
+      'A ' + TABLE + ' in ' + THE_STORE,
+      tIdGeneric,
+    );
+    const tableWhenSetType = addType(
+      TABLE + WHEN_SET,
+      NON_NULLABLE + `<${tablesWhenSetType}[TId]>`,
+      'A ' + TABLE + ' in ' + THE_STORE + WHEN_SETTING_IT,
+      tIdGeneric,
+    );
+    const rowType = addType(
+      ROW,
+      tableType + '<TId>[Id]',
+      'A ' + ROW + ' in a ' + TABLE,
+      tIdGeneric,
+    );
+    const rowWhenSetType = addType(
+      ROW + WHEN_SET,
+      tableWhenSetType + '<TId>[Id]',
+      'A ' + ROW + ' in a ' + TABLE + WHEN_SETTING_IT,
+      tIdGeneric,
+    );
+    const cellIdType = addType(
+      CELL + ID,
+      `Extract<keyof ${rowType}<TId>, Id>`,
+      'A ' + CELL + ' Id in a ' + ROW,
+      tIdGeneric,
+    );
+    const cellType = addType(
+      CELL,
+      NON_NULLABLE + `<${tablesType}[TId]>[Id][CId]`,
+      'A ' + CELL + ' in a ' + ROW,
+      `<TId extends ${tableIdType}, CId extends ${cellIdType}<TId>>`,
+    );
+    const cellIdCellArrayType = addType(
+      'CellIdCellArray',
+      `CId extends ${cellIdType}<TId> ? [cellId: CId, cell: ${cellType}<TId, CId>] : never`,
+      CELL + ' Ids and types in a ' + ROW,
+      `<TId extends ${tableIdType}, CId = ${cellIdType}<TId>>`,
+      0,
+    );
+    const cellCallbackType = addType(
+      CELL + CALLBACK,
+      `(...[cellId, cell]: ${cellIdCellArrayType}<TId>)` + RETURNS_VOID,
+      getCallbackDoc(A + CELL + ' Id, and ' + CELL),
+      tIdGeneric,
+    );
+    const rowCallbackType = addType(
+      ROW + CALLBACK,
+      '(rowId: Id, forEachCell: (cellCallback: CellCallback<TId>) ' +
+        RETURNS_VOID +
+        ') ' +
+        RETURNS_VOID,
+      getCallbackDoc(A + ROW + ' Id, and a ' + CELL + ' iterator'),
+      tIdGeneric,
+    );
+    const tableIdForEachRowArrayType = addType(
+      'TableIdForEachRowArray',
+      `TId extends ${tableIdType} ? [tableId: TId, forEachRow: (rowCallback: ${rowCallbackType}<TId>)${RETURNS_VOID}] : never`,
+      TABLE + ' Ids and callback types',
+      `<TId = ${tableIdType}>`,
+      0,
+    );
+    const tableCallbackType = addType(
+      TABLE + CALLBACK,
+      `(...[tableId, forEachRow]: ${tableIdForEachRowArrayType})` +
+        RETURNS_VOID,
+      getCallbackDoc(A + TABLE + ' Id, and a ' + ROW + ' iterator'),
+      EMPTY_STRING,
+    );
+    const tableIdRowIdCellIdArrayType = addType(
+      'TableIdRowIdCellIdArray',
+      `TId extends ${tableIdType} ? [tableId: TId, rowId: Id, cellId: ${cellIdType}<TId>] : never`,
+      'Ids for GetCellChange',
+      `<TId = ${tableIdType}>`,
+      0,
+    );
+    const getCellChangeType = addType(
+      'GetCellChange',
+      `(...[tableId, rowId, cellId]: ${tableIdRowIdCellIdArrayType}) => CellChange`,
+      A_FUNCTION_FOR +
+        ` returning information about any Cell's changes during a ` +
+        TRANSACTION_,
+    );
+    const tablesListenerType = addType(
+      TABLES + LISTENER,
+      `(${storeParam}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})` +
+        RETURNS_VOID,
+      getListenerTypeDoc(1),
+    );
+    const tableIdsListenerType = addType(
+      TABLE_IDS + LISTENER,
+      `(${storeParam})` + RETURNS_VOID,
+      getListenerTypeDoc(2),
+    );
+    const tableListenerType = addType(
+      TABLE + LISTENER,
+      `(${storeParam}, tableId: ${tableIdType}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})` +
+        RETURNS_VOID,
+      getListenerTypeDoc(3),
+    );
+    const rowIdsListenerType = addType(
+      ROW_IDS + LISTENER,
+      `(${storeParam}, tableId: ${tableIdType})` + RETURNS_VOID,
+      getListenerTypeDoc(4, 3),
+    );
+    const sortedRowIdsListenerType = addType(
+      SORTED_ROW_IDS + LISTENER,
+      '(' +
+        getParameterList(
+          storeParam,
+          'tableId: ' + tableIdType,
+          'cellId: Id' + OR_UNDEFINED,
+          'descending: boolean',
+          'offset: number',
+          'limit: number' + OR_UNDEFINED,
+          'sortedRowIds: Ids',
+        ) +
+        ')' +
+        RETURNS_VOID,
+      getListenerTypeDoc(13, 3),
+    );
+    const rowListenerType = addType(
+      ROW + LISTENER,
+      '(' +
+        getParameterList(
+          `${storeParam}`,
+          'tableId: ' + tableIdType,
+          ROW_ID_PARAM,
+          `getCellChange: ${getCellChangeType}${OR_UNDEFINED}`,
+        ) +
+        ')' +
+        RETURNS_VOID,
+      getListenerTypeDoc(5, 3),
+    );
+    const cellIdsListenerType = addType(
+      CELL_IDS + LISTENER,
+      '(' +
+        getParameterList(
+          `${storeParam}`,
+          'tableId: ' + tableIdType,
+          ROW_ID_PARAM,
+        ) +
+        ')' +
+        RETURNS_VOID,
+      getListenerTypeDoc(6, 5),
+    );
+    const cellListenerArgsArrayInnerType = addType(
+      'CellListenerArgsArrayInner',
+      `CId extends ${cellIdType}<TId> ? [${storeParam}, tableId: TId, ${ROW_ID_PARAM}, cellId: CId, newCell: ${cellType}<TId, CId> ${OR_UNDEFINED}, oldCell: ${cellType}<TId, CId> ${OR_UNDEFINED}, getCellChange: ${getCellChangeType} ${OR_UNDEFINED}] : never`,
+      'Cell args for CellListener',
+      `<TId extends ${tableIdType}, CId = ${cellIdType}<TId>>`,
+      0,
+    );
+    const cellListenerArgsArrayOuterType = addType(
+      'CellListenerArgsArrayOuter',
+      `TId extends ${tableIdType} ? ` +
+        cellListenerArgsArrayInnerType +
+        '<TId> : never',
+      'Table args for CellListener',
+      `<TId = ${tableIdType}>`,
+      0,
+    );
+    const cellListenerType = addType(
+      CELL + LISTENER,
+      `(...[${storeInstance}, tableId, rowId, cellId, newCell, oldCell, getCellChange]: ${cellListenerArgsArrayOuterType})` +
+        RETURNS_VOID,
+      getListenerTypeDoc(7, 5),
+    );
+    const invalidCellListenerType = addType(
+      INVALID + CELL + LISTENER,
+      `(${storeParam}, tableId: Id, ${ROW_ID_PARAM}, cellId: Id, invalidCells: any[])` +
+        RETURNS_VOID,
+      getListenerTypeDoc(8),
+    );
+    return [
+      tablesType,
+      tablesWhenSetType,
+      tableIdType,
+      tableType,
+      tableWhenSetType,
+      rowType,
+      rowWhenSetType,
+      cellIdType,
+      cellType,
+      cellCallbackType,
+      rowCallbackType,
+      tableCallbackType,
+      tablesListenerType,
+      tableIdsListenerType,
+      tableListenerType,
+      rowIdsListenerType,
+      sortedRowIdsListenerType,
+      rowListenerType,
+      cellIdsListenerType,
+      cellListenerType,
+      invalidCellListenerType,
+    ];
+  };
+  const getValuesTypes = (storeInstance, storeType) => {
+    const storeParam = storeInstance + ': ' + storeType;
+    const valuesType = addType(
+      VALUES,
+      getFieldTypeList(
+        ...mapValuesSchema(
+          (valueId, type, defaultValue) =>
+            `'${valueId}'${
+              isUndefined(defaultValue) ? '?' : EMPTY_STRING
+            }: ${type}`,
+        ),
+      ),
+      getTheContentOfTheStoreDoc(2, 5),
+    );
+    const valuesWhenSetType = addType(
+      VALUES + WHEN_SET,
+      getFieldTypeList(
+        ...mapValuesSchema((valueId, type) => `'${valueId}'?: ${type}`),
+      ),
+      getTheContentOfTheStoreDoc(2, 5, 1),
+    );
+    const valueIdType = addType(
+      VALUE + ID,
+      'keyof ' + valuesType,
+      'A ' + VALUE + ' Id in ' + THE_STORE,
+    );
+    const valueType = addType(
+      VALUE,
+      NON_NULLABLE + `<${valuesType}[VId]>`,
+      'A ' + VALUE + ' Id in ' + THE_STORE,
+      `<VId extends ${valueIdType}>`,
+    );
+    const valueIdValueArrayType = addType(
+      'ValueIdValueArray',
+      `VId extends ${valueIdType} ? [valueId: VId, value: ${valueType}<VId>] : never`,
+      VALUE + ' Ids and types in ' + THE_STORE,
+      `<VId = ${valueIdType}>`,
+      0,
+    );
+    const valueCallbackType = addType(
+      VALUE + CALLBACK,
+      `(...[valueId, value]: ${valueIdValueArrayType})` + 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(
+      VALUES + LISTENER,
+      `(${storeParam}, getValueChange: ${getValueChangeType}${OR_UNDEFINED})` +
+        RETURNS_VOID,
+      getListenerTypeDoc(9),
+    );
+    const valueIdsListenerType = addType(
+      VALUE_IDS + LISTENER,
+      `(${storeParam})` + RETURNS_VOID,
+      getListenerTypeDoc(10),
+    );
+    const valueListenerArgsArrayType = addType(
+      'ValueListenerArgsArray',
+      `VId extends ${valueIdType} ? [${storeParam}, valueId: VId, newValue: ${valueType}<VId> ${OR_UNDEFINED}, oldValue: ${valueType}<VId> ${OR_UNDEFINED}, getValueChange: ${getValueChangeType} ${OR_UNDEFINED}] : never`,
+      'Value args for ValueListener',
+      `<VId = ${valueIdType}>`,
+      0,
+    );
+    const valueListenerType = addType(
+      VALUE + LISTENER,
+      `(...[${storeInstance}, valueId, newValue, oldValue, getValueChange]: ` +
+        valueListenerArgsArrayType +
+        ')' +
+        RETURNS_VOID,
+      getListenerTypeDoc(11),
+    );
+    const invalidValueListenerType = addType(
+      INVALID + VALUE + LISTENER,
+      `(${storeParam}, valueId: Id, invalidValues: any[])` + RETURNS_VOID,
+      getListenerTypeDoc(12),
+    );
+    return [
+      valuesType,
+      valuesWhenSetType,
+      valueIdType,
+      valueType,
+      valueCallbackType,
+      valuesListenerType,
+      valueIdsListenerType,
+      valueListenerType,
+      invalidValueListenerType,
+    ];
+  };
+  const getTransactionListenerType = (storeInstance, storeType) =>
+    addType(
+      TRANSACTION + LISTENER,
+      `(${storeInstance}: ${storeType}, cellsTouched: boolean, valuesTouched: boolean)` +
+        RETURNS_VOID,
+      A_FUNCTION_FOR + ' listening to the completion of a ' + TRANSACTION_,
+    );
+  return [getTablesTypes, getValuesTypes, getTransactionListenerType];
+};
+
 const storeMethod = (method, parameters = EMPTY_STRING, cast = EMPTY_STRING) =>
   `store.${method}(${parameters})` + (cast ? ' as ' + cast : EMPTY_STRING);
 const fluentStoreMethod = (method, parameters = EMPTY_STRING) =>
@@ -397,6 +781,8 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
     valuesSchema,
     addConstant,
   );
+  const [getTablesTypes, getValuesTypes, getTransactionListenerType] =
+    getTypeFunctions(addType, mapTablesSchema, mapCellSchema, mapValuesSchema);
   const methods = mapNew();
   const getMethods = (location = 0) =>
     mapMap(methods, ([parameters, returnType, body, doc, generic], name) => {
@@ -451,6 +837,7 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
     params = EMPTY_STRING,
     paramsInCall = EMPTY_STRING,
     mutator = 1,
+    generic = EMPTY_STRING,
   ) =>
     addMethod(
       ADD + underlyingName + LISTENER,
@@ -466,6 +853,7 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
         mutator ? 'mutator' : EMPTY_STRING,
       ),
       doc,
+      generic,
     );
   const moduleDefinition = `./${camel(module)}.d`;
   const storeType = camel(module, 1);
@@ -481,63 +869,77 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
     `create${storeType} as create${storeType}Decl`,
   );
   if (!objIsEmpty(tablesSchema)) {
+    addImport(0, 'tinybase', 'CellChange');
+    addImport(null, 'tinybase', IDS);
+    const [
+      tablesType,
+      tablesWhenSetType,
+      tableIdType,
+      tableType,
+      tableWhenSetType,
+      rowType,
+      rowWhenSetType,
+      cellIdType,
+      _cellType,
+      cellCallbackType,
+      rowCallbackType,
+      tableCallbackType,
+      tablesListenerType,
+      tableIdsListenerType,
+      tableListenerType,
+      rowIdsListenerType,
+      sortedRowIdsListenerType,
+      rowListenerType,
+      cellIdsListenerType,
+      cellListenerType,
+      invalidCellListenerType,
+    ] = getTablesTypes(storeInstance, storeType);
     const tablesTypes = mapNew();
     mapTablesSchema((tableId, tableName) => {
+      const tableIdGeneric = `<'${tableId}'>`;
       const tableTypes = [
+        // Table
         addType(
           tableName + TABLE,
-          `{[rowId: Id]: ${tableName}Row}`,
+          tableType + tableIdGeneric,
           REPRESENTS + ` the '${tableId}' ` + TABLE,
         ),
+        // TableWhenSet
+        addType(
+          tableName + TABLE + WHEN_SET,
+          tableWhenSetType + tableIdGeneric,
+          REPRESENTS + ` the '${tableId}' ` + TABLE + WHEN_SETTING_IT,
+        ),
+        // Row
         addType(
           tableName + ROW,
-          `{${join(
-            mapCellSchema(
-              tableId,
-              (cellId, type, defaultValue) =>
-                `'${cellId}'${
-                  isUndefined(defaultValue) ? '?' : EMPTY_STRING
-                }: ${type};`,
-            ),
-            ' ',
-          )}}`,
+          rowType + tableIdGeneric,
           getRowTypeDoc(tableId),
         ),
+        // RowWhenSet
         addType(
-          tableName + ROW + 'WhenSet',
-          `{${join(
-            mapCellSchema(tableId, (cellId, type) => `'${cellId}'?: ${type};`),
-            ' ',
-          )}}`,
+          tableName + ROW + WHEN_SET,
+          rowWhenSetType + tableIdGeneric,
           getRowTypeDoc(tableId, 1),
         ),
+        // CellId
         addType(
           tableName + CELL + ID,
-          join(
-            mapCellSchema(tableId, (cellId) => `'${cellId}'`),
-            ' | ',
-          ),
+          cellIdType + tableIdGeneric,
           `A Cell Id for the '${tableId}' ` + TABLE,
         ),
+        // CellCallback
         addType(
           tableName + CELL + CALLBACK,
-          `(...[cellId, cell]: ${join(
-            mapCellSchema(
-              tableId,
-              (cellId, type) => `[cellId: '${cellId}', cell: ${type}]`,
-            ),
-            ' | ',
-          )})` + RETURNS_VOID,
+          cellCallbackType + tableIdGeneric,
           getCallbackDoc(
             `a Cell Id and value from a Row in the '${tableId}' ` + TABLE,
           ),
         ),
+        // RowCallback
         addType(
           tableName + ROW + CALLBACK,
-          `(rowId: Id, forEachCell: (cellCallback: ${tableName}CellCallback)` +
-            RETURNS_VOID +
-            ')' +
-            RETURNS_VOID,
+          rowCallbackType + tableIdGeneric,
           getCallbackDoc(
             `a Row Id from the '${tableId}' Table, and a Cell iterator`,
           ),
@@ -546,129 +948,29 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
       mapSet(tablesTypes, tableId, tableTypes);
       addImport(1, moduleDefinition, ...tableTypes);
     });
-    addImport(null, 'tinybase', IDS);
-    const tablesType = addType(
-      TABLES,
-      `{${join(
-        mapTablesSchema(
-          (tableId) => `'${tableId}'?: ${mapGet(tablesTypes, tableId)?.[0]};`,
-        ),
-        ' ',
-      )}}`,
-      getTheContentOfTheStoreDoc(1, 5),
-    );
-    const tableIdType = addType(
-      TABLE + ID,
-      join(
-        mapTablesSchema((tableId) => `'${tableId}'`),
-        ' | ',
-      ),
-      'A ' + TABLE + ' Id in ' + THE_STORE,
-    );
-    const tableCallbackType = addType(
-      TABLE + CALLBACK,
-      `(...[tableId, rowCallback]: ${join(
-        mapTablesSchema(
-          (tableId) =>
-            `[tableId: '${tableId}', forEachRow: (rowCallback: ${
-              mapGet(tablesTypes, tableId)?.[5]
-            })${RETURNS_VOID}]`,
-        ),
-        ' | ',
-      )})` + RETURNS_VOID,
-      getCallbackDoc(A + TABLE + ' Id, and a Row iterator'),
-    );
-    const getCellChangeType = addType(
-      'GetCellChange',
-      `(...[tableId, rowId, cellId]: ${join(
-        mapTablesSchema(
-          (tableId) =>
-            `[tableId: '${tableId}', rowId: Id, cellId: ${
-              mapGet(tablesTypes, tableId)?.[3]
-            }]`,
-        ),
-        ' | ',
-      )}) => CellChange`,
-      A_FUNCTION_FOR +
-        ` returning information about any Cell's changes during a ` +
-        TRANSACTION_,
-    );
-    const tablesListenerType = addType(
-      TABLES + LISTENER,
-      `(${storeInstance}: ${storeType}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})` +
-        RETURNS_VOID,
-      getListenerTypeDoc(1),
-    );
-    const tableIdsListenerType = addType(
-      TABLE_IDS + LISTENER,
-      `(${storeInstance}: ${storeType})` + RETURNS_VOID,
-      getListenerTypeDoc(2),
-    );
-    const tableListenerType = addType(
-      TABLE + LISTENER,
-      `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})` +
-        RETURNS_VOID,
-      getListenerTypeDoc(3),
-    );
-    const rowIdsListenerType = addType(
-      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(
-      ROW + LISTENER,
-      `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, rowId: Id, getCellChange: ${getCellChangeType}${OR_UNDEFINED})` +
-        RETURNS_VOID,
-      getListenerTypeDoc(5, 3),
-    );
-    const cellIdsListenerType = addType(
-      CELL_IDS + LISTENER,
-      `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, rowId: Id)` +
-        RETURNS_VOID,
-      getListenerTypeDoc(6, 5),
-    );
-    const cellListenerType = addType(
-      CELL + LISTENER,
-      `(...[${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(
-      INVALID + CELL + LISTENER,
-      `(${storeInstance}: ${storeType}, tableId: Id, rowId: Id, cellId: Id, invalidCells: any[])` +
-        RETURNS_VOID,
-      getListenerTypeDoc(8),
+    addImport(
+      1,
+      moduleDefinition,
+      tablesType,
+      tablesWhenSetType,
+      tableIdType,
+      cellIdType,
+      tableCallbackType,
+      tablesListenerType,
+      tableIdsListenerType,
+      tableListenerType,
+      rowIdsListenerType,
+      sortedRowIdsListenerType,
+      rowListenerType,
+      cellIdsListenerType,
+      cellListenerType,
+      invalidCellListenerType,
     );
     sharedTableTypes = [
       tablesType,
+      tablesWhenSetType,
       tableIdType,
+      cellIdType,
       tablesListenerType,
       tableIdsListenerType,
       tableListenerType,
@@ -683,7 +985,7 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
       [
         [tablesType],
         [BOOLEAN],
-        [storeType, 'tables: ' + tablesType, 'tables'],
+        [storeType, 'tables: ' + tablesWhenSetType, 'tables'],
         [storeType],
       ],
       ([returnType, params, paramsInCall], verb) =>
@@ -715,18 +1017,19 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
     );
     mapTablesSchema((tableId, tableName, TABLE_ID) => {
       const [
-        tableType,
-        rowType,
-        rowWhenSetType,
-        cellIdType,
-        cellCallbackType,
-        rowCallbackType,
+        tableType2,
+        tableWhenSetType2,
+        rowType2,
+        rowWhenSetType2,
+        cellIdType2,
+        cellCallbackType2,
+        rowCallbackType2,
       ] = mapGet(tablesTypes, tableId);
       arrayForEach(
         [
-          [tableType],
+          [tableType2],
           [BOOLEAN],
-          [storeType, 'table: ' + tableType, ', table'],
+          [storeType, 'table: ' + tableWhenSetType2, ', table'],
           [storeType],
         ],
         ([returnType, params, paramsInCall = EMPTY_STRING], verb) =>
@@ -755,9 +1058,7 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
         SORTED_ROW_IDS,
         IDS,
         getIdsDoc(ROW, getTableDoc(tableId), 1),
-        'cellId?: ' +
-          cellIdType +
-          ', descending?: boolean, offset?: number, limit?: number',
+        'cellId?: ' + cellIdType2 + SORTED_ARGS,
         TABLE_ID + ', cellId, descending, offset, limit',
       );
       addProxyMethod(
@@ -766,16 +1067,16 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
         ROW,
         VOID,
         getForEachDoc(ROW, getTableDoc(tableId)),
-        'rowCallback: ' + rowCallbackType,
+        'rowCallback: ' + rowCallbackType2,
         TABLE_ID + ', rowCallback as any',
       );
       arrayForEach(
         [
-          [rowType],
+          [rowType2],
           [BOOLEAN],
-          [storeType, ', row: ' + rowWhenSetType, ', row'],
+          [storeType, ', row: ' + rowWhenSetType2, ', row'],
           [storeType],
-          [storeType, ', partialRow: ' + rowWhenSetType, ', partialRow'],
+          [storeType, ', partialRow: ' + rowWhenSetType2, ', partialRow'],
         ],
         (
           [returnType, params = EMPTY_STRING, paramsInCall = EMPTY_STRING],
@@ -787,7 +1088,7 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
             ROW,
             returnType,
             getRowContentDoc(tableId, verb),
-            'rowId: Id' + params,
+            ROW_ID_PARAM + params,
             TABLE_ID + ', rowId' + paramsInCall,
           ),
       );
@@ -796,17 +1097,17 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
         tableName,
         ROW,
         ID + OR_UNDEFINED,
-        'Adds a new Row to ' + getTableDoc(tableId),
-        'row: ' + rowWhenSetType,
+        'Add a new Row to ' + getTableDoc(tableId),
+        'row: ' + rowWhenSetType2,
         TABLE_ID + ', row',
       );
       addProxyMethod(
         0,
         tableName,
         CELL_IDS,
-        cellIdType + SQUARE_BRACKETS,
+        cellIdType2 + SQUARE_BRACKETS,
         getIdsDoc(CELL, getRowDoc(tableId)),
-        'rowId: ' + ID,
+        ROW_ID_PARAM,
         TABLE_ID + ', rowId',
       );
       addProxyMethod(
@@ -815,7 +1116,7 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
         CELL,
         VOID,
         getForEachDoc(CELL, getRowDoc(tableId)),
-        'rowId: Id, cellCallback: ' + cellCallbackType,
+        ROW_ID_PARAM + ', cellCallback: ' + cellCallbackType2,
         TABLE_ID + ', rowId, cellCallback as any',
       );
       mapCellSchema(
@@ -842,7 +1143,7 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
                 CELL,
                 returnType,
                 getCellContentDoc(tableId, cellId, verb),
-                'rowId: Id' + params,
+                ROW_ID_PARAM + params,
                 TABLE_ID + ', rowId, ' + CELL_ID + paramsInCall,
               ),
           );
@@ -890,13 +1191,15 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
       sortedRowIdsListenerType,
       getListenerDoc(13, 3, 1),
       getParameterList(
-        'tableId: ' + tableIdType,
-        'cellId: Id' + OR_UNDEFINED,
+        'tableId: TId',
+        `cellId: ${cellIdType}<TId>` + OR_UNDEFINED,
         'descending: boolean',
         'offset: number',
         'limit: number' + OR_UNDEFINED,
       ),
       getParameterList('tableId', 'cellId', 'descending', 'offset', 'limit'),
+      1,
+      '<TId extends TableId>',
     );
     addProxyListener(
       ROW,
@@ -918,7 +1221,7 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
       getListenerDoc(7, 5),
       `tableId: ${tableIdType} | null, rowId: IdOrNull, cellId: ${join(
         mapTablesSchema(
-          (tableId) => mapGet(tablesTypes, tableId)?.[3] ?? EMPTY_STRING,
+          (tableId) => mapGet(tablesTypes, tableId)?.[4] ?? EMPTY_STRING,
         ),
         ' | ',
       )} | null`,
@@ -931,27 +1234,10 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
       `tableId: IdOrNull, rowId: IdOrNull, cellId: IdOrNull`,
       'tableId, rowId, cellId',
     );
-    addImport(
-      1,
-      moduleDefinition,
-      tablesType,
-      tableIdType,
-      tableCallbackType,
-      tablesListenerType,
-      tableIdsListenerType,
-      tableListenerType,
-      rowIdsListenerType,
-      sortedRowIdsListenerType,
-      rowListenerType,
-      cellIdsListenerType,
-      cellListenerType,
-      invalidCellListenerType,
-      ...collValues(mapCellOrValueTypes),
-    );
-    addImport(0, 'tinybase', 'CellChange');
+    addImport(1, moduleDefinition, ...collValues(mapCellOrValueTypes));
     arrayPush(
       createSteps,
-      '.setTablesSchema({',
+      '.set' + TABLES + SCHEMA + '({',
       flat(
         mapTablesSchema((tableId, _, TABLE_ID) => [
           `[${TABLE_ID}]: {`,
@@ -977,83 +1263,28 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
     );
   }
   if (!objIsEmpty(valuesSchema)) {
-    const valuesType = addType(
-      VALUES,
-      '{' +
-        join(
-          mapValuesSchema(
-            (valueId, type, defaultValue) =>
-              `'${valueId}'${
-                isUndefined(defaultValue) ? '?' : EMPTY_STRING
-              }: ${type};`,
-          ),
-          ' ',
-        ) +
-        '}',
-      getTheContentOfTheStoreDoc(2, 5),
-    );
-    const valuesWhenSetType = addType(
-      VALUES + 'WhenSet',
-      '{' +
-        join(
-          mapValuesSchema((valueId, type) => `'${valueId}'?: ${type};`),
-          ' ',
-        ) +
-        '}',
-      getTheContentOfTheStoreDoc(2, 5, 1),
-    );
-    const valueIdType = addType(
-      VALUE + ID,
-      join(
-        mapValuesSchema((valueId) => `'${valueId}'`),
-        ' | ',
-      ),
-      'A Value Id in ' + THE_STORE,
-    );
-    const valueCallbackType = addType(
-      VALUE + CALLBACK,
-      `(...[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(
-      VALUES + LISTENER,
-      `(${storeInstance}: ${storeType}, getValueChange: ${getValueChangeType}${OR_UNDEFINED})` +
-        RETURNS_VOID,
-      getListenerTypeDoc(9),
-    );
-    const valueIdsListenerType = addType(
-      VALUE_IDS + LISTENER,
-      `(${storeInstance}: ${storeType})` + RETURNS_VOID,
-      getListenerTypeDoc(10),
-    );
-    const valueListenerType = addType(
-      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,
-      getListenerTypeDoc(11),
-    );
-    const invalidValueListenerType = addType(
-      INVALID + VALUE + LISTENER,
-      `(${storeInstance}: ${storeType}, valueId: Id, invalidValues: any[])` +
-        RETURNS_VOID,
-      getListenerTypeDoc(12),
+    const [
+      valuesType,
+      valuesWhenSetType,
+      valueIdType,
+      _valueType,
+      valueCallbackType,
+      valuesListenerType,
+      valueIdsListenerType,
+      valueListenerType,
+      invalidValueListenerType,
+    ] = getValuesTypes(storeInstance, storeType);
+    addImport(
+      1,
+      moduleDefinition,
+      valuesType,
+      valuesWhenSetType,
+      valueIdType,
+      valueCallbackType,
+      valuesListenerType,
+      valueIdsListenerType,
+      valueListenerType,
+      invalidValueListenerType,
     );
     sharedValueTypes = [
       valuesType,
@@ -1156,24 +1387,12 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
       `valueId: IdOrNull`,
       'valueId',
     );
-    addImport(
-      1,
-      moduleDefinition,
-      valuesType,
-      valuesWhenSetType,
-      valueIdType,
-      valueCallbackType,
-      valuesListenerType,
-      valueIdsListenerType,
-      valueListenerType,
-      invalidValueListenerType,
-      ...collValues(mapCellOrValueTypes),
-    );
+    addImport(1, moduleDefinition, ...collValues(mapCellOrValueTypes));
     addImport(0, 'tinybase', 'ValueChange');
     arrayPush(
       createSteps,
-      '.setValuesSchema({',
-      mapValuesSchema((valueId, type, defaultValue, VALUE_ID) => [
+      '.set' + VALUES + SCHEMA + '({',
+      mapValuesSchema((_, type, defaultValue, VALUE_ID) => [
         `[${VALUE_ID}]: {[${addConstant(
           snake(TYPE),
           `'${TYPE}'`,
@@ -1197,12 +1416,6 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
     ),
   );
   addImport(null, 'tinybase', 'DoRollback', ID, 'IdOrNull', JSON$1, 'Store');
-  const transactionListenerType = addType(
-    TRANSACTION + LISTENER,
-    `(${storeInstance}: ${storeType}, cellsTouched: boolean, valuesTouched: boolean)` +
-      RETURNS_VOID,
-    A_FUNCTION_FOR + ' listening to the completion of a ' + TRANSACTION_,
-  );
   addProxyMethod(
     0,
     EMPTY_STRING,
@@ -1216,16 +1429,16 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
     JSON$1,
     storeType,
     getTheContentOfTheStoreDoc(0, 7),
-    'json: ' + JSON$1,
-    'json',
+    'tablesAndValuesJson: ' + JSON$1,
+    'tablesAndValuesJson',
   );
   addProxyMethod(
     7,
     EMPTY_STRING,
     TRANSACTION_,
     'Return',
-    'Execute a ' + TRANSACTION_ + ' to make multiple mutations',
-    'actions: () => Return, doRollback?: DoRollback',
+    TRANSACTION_DOC,
+    DO_ACTIONS_AND_ROLLBACK_PARAMS,
     'actions, doRollback',
     '<Return>',
   );
@@ -1234,17 +1447,21 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
     EMPTY_STRING,
     'start' + TRANSACTION,
     storeType,
-    'Explicitly starts a ' + TRANSACTION_,
+    START_TRANSACTION_DOC,
   );
   addProxyMethod(
     7,
     EMPTY_STRING,
     'finish' + TRANSACTION,
     storeType,
-    'Explicitly finishes a ' + TRANSACTION_,
-    'doRollback?: DoRollback,',
+    FINISH_TRANSACTION_DOC,
+    DO_ROLLBACK_PARAM,
     'doRollback',
   );
+  const transactionListenerType = getTransactionListenerType(
+    storeInstance,
+    storeType,
+  );
   addProxyListener(
     'WillFinish' + TRANSACTION,
     transactionListenerType,
@@ -1266,9 +1483,9 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
     EMPTY_STRING,
     'call' + LISTENER,
     storeType,
-    `Manually provoke a listener to be called`,
-    `listenerId: Id`,
-    `listenerId`,
+    'Manually provoke a listener to be called',
+    'listenerId: Id',
+    'listenerId',
   );
   addProxyMethod(
     3,
@@ -1337,13 +1554,6 @@ const DEPS = 'Deps';
 const getGet = (noun) => GET + noun;
 const getGetAndGetDeps = (noun) =>
   getParameterList(getGet(noun), getGet(noun) + DEPS);
-const getPropsTypeList = (...props) =>
-  '{' +
-  join(
-    arrayMap(props, (prop) => 'readonly ' + prop),
-    '; ',
-  ) +
-  '}';
 const DEBUG_IDS_PROP_TYPE = 'debugIds?: boolean';
 const DEBUG_IDS_PROP = 'debugIds={debugIds}';
 const DEPS_SUFFIX = DEPS + '?: React.DependencyList';
@@ -1509,7 +1719,7 @@ const getStoreUiReactApi = (
   );
   const providerPropsType = addType(
     PROVIDER + PROPS,
-    getPropsTypeList(
+    getPropTypeList(
       storeInstance + OPTIONAL_COLON + storeType,
       storeInstance + `ById?: {[${storeInstance}Id: Id]: ${storeType}}`,
     ),
@@ -1580,7 +1790,9 @@ const getStoreUiReactApi = (
   if (!objIsEmpty(tablesSchema)) {
     const [
       tablesType,
+      tablesWhenSetType,
       tableIdType,
+      cellIdType,
       tablesListenerType,
       tableIdsListenerType,
       tableListenerType,
@@ -1595,6 +1807,7 @@ const getStoreUiReactApi = (
       null,
       moduleDefinition,
       tablesType,
+      tablesWhenSetType,
       tableIdType,
       tablesListenerType,
       tableIdsListenerType,
@@ -1605,6 +1818,7 @@ const getStoreUiReactApi = (
       cellIdsListenerType,
       cellListenerType,
     );
+    addImport(0, moduleDefinition, cellIdType);
     addImport(1, moduleDefinition, storeType);
     addImport(null, 'tinybase', IDS, 'IdOrNull');
     const tableView = addInternalFunction(
@@ -1678,14 +1892,14 @@ const getStoreUiReactApi = (
       PARAMETERIZED_CALLBACK,
       getTheContentOfTheStoreDoc(1, 9) + BASED_ON_A_PARAMETER,
       getParameterList(
-        getGet(TABLES) + GETTER_ARGS + tablesType,
+        getGet(TABLES) + GETTER_ARGS + tablesWhenSetType,
         getGet(TABLES) + DEPS_SUFFIX,
       ),
       getGetAndGetDeps(TABLES),
       GENERIC_PARAMETER,
       getParameterList(
         THEN_PREFIX,
-        `tables: ${tablesType})` + RETURNS_VOID,
+        `tables: ${tablesWhenSetType})` + RETURNS_VOID,
         THEN_DEPS,
       ),
       THEN_AND_THEN_DEPS_IN_CALL,
@@ -1701,35 +1915,86 @@ const getStoreUiReactApi = (
       THEN_AND_THEN_DEPS,
       THEN_AND_THEN_DEPS_IN_CALL,
     );
+    const cellPropsType = addType(
+      CELL + PROPS,
+      getPropTypeList(
+        'tableId?: TId',
+        'rowId: Id',
+        'cellId?: CId',
+        storeInstance + OPTIONAL_COLON + storeType,
+        DEBUG_IDS_PROP_TYPE,
+      ),
+      getPropsDoc(A + CELL),
+      `<TId extends ${tableIdType}, CId extends ${cellIdType}<TId>>`,
+    );
+    const rowPropsType = addType(
+      ROW + PROPS,
+      getPropTypeList(
+        `tableId?: TId`,
+        'rowId: Id',
+        storeInstance + OPTIONAL_COLON + storeType,
+        'cellComponents?: {readonly [CId in ' +
+          cellIdType +
+          `<TId>]?: ComponentType<${cellPropsType}<TId, CId>>;}`,
+        `getCellComponentProps?: (cellId: ${cellIdType}<TId>) => ExtraProps`,
+        SEPARATOR_PROP_TYPE,
+        DEBUG_IDS_PROP_TYPE,
+      ),
+      getPropsDoc(A + ROW),
+      `<TId extends ${tableIdType}>`,
+    );
+    const tablePropsType = addType(
+      TABLE + PROPS,
+      getPropTypeList(
+        `tableId?: TId`,
+        storeInstance + OPTIONAL_COLON + storeType,
+        `rowComponent?: ComponentType<${rowPropsType}<TId>>`,
+        `getRowComponentProps?: (rowId: Id) => ExtraProps`,
+        SEPARATOR_PROP_TYPE,
+        DEBUG_IDS_PROP_TYPE,
+      ),
+      getPropsDoc(A + TABLE),
+      `<TId extends ${tableIdType}>`,
+    );
+    const sortedTablePropsType = addType(
+      'Sorted' + TABLE + PROPS,
+      getPropTypeList(
+        `tableId?: TId`,
+        'cellId?: ' + cellIdType + '<TId>',
+        'descending?: boolean',
+        'offset?: number',
+        'limit?: number',
+        storeInstance + OPTIONAL_COLON + storeType,
+        `rowComponent?: ComponentType<${rowPropsType}<TId>>`,
+        `getRowComponentProps?: (rowId: Id) => ExtraProps`,
+        SEPARATOR_PROP_TYPE,
+        DEBUG_IDS_PROP_TYPE,
+      ),
+      getPropsDoc(A + 'sorted ' + TABLE),
+      `<TId extends ${tableIdType}>`,
+    );
     const tablesPropsType = addType(
       TABLES + PROPS,
-      getPropsTypeList(
+      getPropTypeList(
         storeInstance + OPTIONAL_COLON + storeType,
-        'tableComponents?: {' +
-          join(
-            mapTablesSchema(
-              (tableId, tableName) =>
-                `'${tableId}'?: ComponentType<${tableName}TableProps>`,
-            ),
-            ', ',
-          ) +
-          '}',
+        'tableComponents?: {readonly [TId in ' +
+          tableIdType +
+          `]?: ComponentType<${tablePropsType}<TId>>;}`,
         `getTableComponentProps?: (tableId: ${tableIdType}) => ExtraProps`,
         SEPARATOR_PROP_TYPE,
         DEBUG_IDS_PROP_TYPE,
       ),
       getPropsDoc(getTheContentOfDoc(1, 1)),
     );
-    const cellPropsType = addType(
-      CELL + PROPS,
-      getPropsTypeList(
-        'rowId: Id',
-        storeInstance + OPTIONAL_COLON + storeType,
-        DEBUG_IDS_PROP_TYPE,
-      ),
-      getPropsDoc('a Cell'),
+    addImport(
+      1,
+      uiReactModuleDefinition,
+      tablesPropsType,
+      tablePropsType,
+      sortedTablePropsType,
+      rowPropsType,
+      cellPropsType,
     );
-    addImport(1, uiReactModuleDefinition, tablesPropsType, cellPropsType);
     addComponent(
       TABLES + VIEW,
       '{' +
@@ -1740,11 +2005,12 @@ const getStoreUiReactApi = (
         tablesPropsType,
       [
         wrap + `(${useTableIds}(${storeInstance}).map((tableId) => {`,
-        'const Table = tableComponents?.[tableId] ?? ' +
+        'const Table = (tableComponents?.[tableId] ?? ' +
           getDefaultTableComponent +
-          '(tableId);',
+          `(tableId)) as React.ComponentType<TableProps<typeof tableId>>;`,
         'return <Table',
         `{...${getProps}(getTableComponentProps, tableId)}`,
+        'tableId={tableId}',
         'key={tableId}',
         storeProp,
         DEBUG_IDS_PROP,
@@ -1754,25 +2020,21 @@ const getStoreUiReactApi = (
       getTheContentOfTheStoreDoc(1, 13) + AND_REGISTERS,
     );
     mapTablesSchema((tableId, tableName, TABLE_ID) => {
-      const [tableType, rowType, rowWhenSetType, cellIdType] = mapGet(
-        tablesTypes,
-        tableId,
-      );
-      addImport(
-        0,
-        moduleDefinition,
+      const [
         tableType,
+        tableWhenSetType,
         rowType,
         rowWhenSetType,
-        cellIdType,
-      );
+        cellIdType2,
+      ] = mapGet(tablesTypes, tableId);
       addImport(
-        1,
+        null,
         moduleDefinition,
         tableType,
+        tableWhenSetType,
         rowType,
         rowWhenSetType,
-        cellIdType,
+        cellIdType2,
       );
       addProxyHook(
         tableName + TABLE,
@@ -1796,7 +2058,7 @@ const getStoreUiReactApi = (
         IDS,
         getIdsDoc(ROW, getTableDoc(tableId), 1) + AND_REGISTERS,
         'cellId?: ' +
-          cellIdType +
+          cellIdType2 +
           ', descending?: boolean, offset?: number, limit?: number',
         TABLE_ID + ', cellId, descending, offset, limit',
       );
@@ -1811,7 +2073,7 @@ const getStoreUiReactApi = (
       const useCellIds = addProxyHook(
         tableName + CELL_IDS,
         CELL_IDS,
-        cellIdType + SQUARE_BRACKETS,
+        cellIdType2 + SQUARE_BRACKETS,
         getIdsDoc(CELL, getRowDoc(tableId)) + AND_REGISTERS,
         TYPED_ROW_ID,
         getParameterList(TABLE_ID, ROW_ID),
@@ -1822,14 +2084,14 @@ const getStoreUiReactApi = (
         PARAMETERIZED_CALLBACK,
         getTableContentDoc(tableId, 9) + BASED_ON_A_PARAMETER,
         getParameterList(
-          getGet(TABLE) + GETTER_ARGS + tableType,
+          getGet(TABLE) + GETTER_ARGS + tableWhenSetType,
           getGet(TABLE) + DEPS_SUFFIX,
         ),
         getParameterList(TABLE_ID, getGetAndGetDeps(TABLE)),
         GENERIC_PARAMETER,
         getParameterList(
           THEN_PREFIX,
-          `table: ${tableType})` + RETURNS_VOID,
+          `table: ${tableWhenSetType})` + RETURNS_VOID,
           THEN_DEPS,
         ),
         THEN_AND_THEN_DEPS_IN_CALL,
@@ -1904,68 +2166,15 @@ const getStoreUiReactApi = (
         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,
-      );
-      const rowPropsType = addType(
-        tableName + 'RowProps',
-        getPropsTypeList(
-          'rowId: Id',
-          storeInstance + OPTIONAL_COLON + storeType,
-          'cellComponents?: {' +
-            join(
-              mapCellSchema(
-                tableId,
-                (cellId) => `'${cellId}'?: ComponentType<${cellPropsType}>`,
-              ),
-              ', ',
-            ) +
-            '}',
-          `getCellComponentProps?: (cellId: ${cellIdType}) => ExtraProps`,
-          SEPARATOR_PROP_TYPE,
-          DEBUG_IDS_PROP_TYPE,
-        ),
-        getPropsDoc(getRowDoc(tableId)),
-      );
-      const tablePropsType = addType(
-        tableName + 'TableProps',
-        getPropsTypeList(
-          storeInstance + OPTIONAL_COLON + storeType,
-          `rowComponent?: ComponentType<${rowPropsType}>`,
-          `getRowComponentProps?: (rowId: Id) => ExtraProps`,
-          SEPARATOR_PROP_TYPE,
-          DEBUG_IDS_PROP_TYPE,
-        ),
-        getPropsDoc(getTableDoc(tableId)),
-      );
-      const sortedTablePropsType = addType(
-        tableName + 'SortedTableProps',
-        getPropsTypeList(
-          'cellId?: ' + cellIdType,
-          'descending?: boolean',
-          'offset?: number',
-          'limit?: number',
-          storeInstance + OPTIONAL_COLON + storeType,
-          `rowComponent?: ComponentType<${rowPropsType}>`,
-          `getRowComponentProps?: (rowId: Id) => ExtraProps`,
-          SEPARATOR_PROP_TYPE,
-          DEBUG_IDS_PROP_TYPE,
-        ),
-        getPropsDoc(getTableDoc(tableId)) + ', sorted',
-      );
-      addImport(
-        1,
-        uiReactModuleDefinition,
-        rowPropsType,
-        tablePropsType,
-        sortedTablePropsType,
+        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,
       );
       const rowView = addComponent(
         tableName + ROW + VIEW,
@@ -1973,17 +2182,20 @@ const getStoreUiReactApi = (
           storeInstance +
           ', cellComponents, getCellComponentProps' +
           SEPARATOR_AND_DEBUG_IDS +
-          '}: ' +
-          rowPropsType,
+          `}: ${rowPropsType}<'${tableId}'>`,
         [
           wrap + `(${useCellIds}(rowId, ${storeInstance}).map((cellId) => {`,
-          'const Cell = cellComponents?.[cellId] ?? ' +
+          'const Cell = (cellComponents?.[cellId] ?? ' +
             getDefaultCellComponent +
-            `(${TABLE_ID}, cellId);`,
+            `(${TABLE_ID}, cellId)) as React.ComponentType<CellProps<typeof ` +
+            TABLE_ID +
+            ', typeof cellId>>;',
           'return <Cell',
           `{...${getProps}(getCellComponentProps, cellId)} `,
           'key={cellId}',
+          `tableId={${TABLE_ID}}`,
           ROW_ID_PROP,
+          'cellId={cellId}',
           storeProp,
           DEBUG_IDS_PROP,
           '/>;',
@@ -1994,7 +2206,8 @@ const getStoreUiReactApi = (
       addComponent(
         tableName + 'Sorted' + TABLE + VIEW,
         '{cellId, descending, offset, limit, ...props}: ' +
-          sortedTablePropsType,
+          sortedTablePropsType +
+          `<'${tableId}'>`,
         tableView +
           '(props, ' +
           useSortedRowIds +
@@ -2003,7 +2216,7 @@ const getStoreUiReactApi = (
       );
       addComponent(
         tableName + TABLE + VIEW,
-        'props: ' + tablePropsType,
+        `props: ${tablePropsType}<'${tableId}'>`,
         tableView +
           '(props, ' +
           useRowIds +
@@ -2056,7 +2269,9 @@ const getStoreUiReactApi = (
           );
           addComponent(
             tableName + cellName + CELL + VIEW,
-            `{rowId, ${storeInstance}, debugIds}: ` + cellPropsType,
+            `{rowId, ${storeInstance}, debugIds}: ` +
+              cellPropsType +
+              `<'${tableId}', '${cellId}'>`,
             [
               wrap +
                 `('' + ${useCell}(rowId, ` +
@@ -2070,7 +2285,7 @@ const getStoreUiReactApi = (
     });
     const cellIdsType = join(
       mapTablesSchema(
-        (tableId) => mapGet(tablesTypes, tableId)?.[3] ?? EMPTY_STRING,
+        (tableId) => mapGet(tablesTypes, tableId)?.[4] ?? EMPTY_STRING,
       ),
       ' | ',
     );
@@ -2253,24 +2468,21 @@ const getStoreUiReactApi = (
     );
     const valuePropsType = addType(
       VALUE + PROPS,
-      getPropsTypeList(
+      getPropTypeList(
+        `valueId?: VId`,
         storeInstance + OPTIONAL_COLON + storeType,
         DEBUG_IDS_PROP_TYPE,
       ),
       getPropsDoc('a Value'),
+      `<VId extends ${valueIdType}>`,
     );
     const valuesPropsType = addType(
       VALUES + PROPS,
-      getPropsTypeList(
+      getPropTypeList(
         storeInstance + OPTIONAL_COLON + storeType,
-        'valueComponents?: {' +
-          join(
-            mapValuesSchema(
-              (valueId) => `'${valueId}'?: ComponentType<${valuePropsType}>`,
-            ),
-            ', ',
-          ) +
-          '}',
+        'valueComponents?: {readonly [VId in ' +
+          valueIdType +
+          `]?: ComponentType<${valuePropsType}<VId>>;}`,
         `getValueComponentProps?: (valueId: ${valueIdType}) => ExtraProps`,
         SEPARATOR_PROP_TYPE,
         DEBUG_IDS_PROP_TYPE,
@@ -2344,7 +2556,7 @@ const getStoreUiReactApi = (
       );
       addComponent(
         valueName + VALUE + VIEW,
-        `{${storeInstance}, debugIds}: ` + valuePropsType,
+        `{${storeInstance}, debugIds}: ${valuePropsType}<'${valueId}'>`,
         [
           wrap +
             `('' + ${useValue}(` +
@@ -2431,6 +2643,597 @@ const getStoreApi = (tablesSchema, valuesSchema, module) => {
   ];
 };
 
+const MAY_CONTRADICT_REFINEMENT =
+  '. Note that this may contradict the generated type refinements';
+const getStoreCoreRefinement = (tablesSchema, valuesSchema, _module) => {
+  const [
+    build,
+    addImport,
+    addType,
+    _addInternalFunction,
+    _addConstant,
+    getImports,
+    getTypes,
+    _getConstants,
+  ] = getCodeFunctions();
+  const [mapTablesSchema, mapCellSchema, mapValuesSchema] = getSchemaFunctions(
+    tablesSchema,
+    valuesSchema,
+    () => EMPTY_STRING,
+  );
+  const [getTablesTypes, getValuesTypes, getTransactionListenerType] =
+    getTypeFunctions(addType, mapTablesSchema, mapCellSchema, mapValuesSchema);
+  const methods = mapNew();
+  const getMethods = () =>
+    mapMap(methods, ([parameters, returnType, doc, generic], name) => [
+      comment(doc),
+      name + generic + `(${getParameterList(...parameters)}): ${returnType};`,
+      EMPTY_STRING,
+    ]);
+  const addMethod = (
+    name,
+    parameters,
+    returnType,
+    doc,
+    generic = EMPTY_STRING,
+  ) =>
+    mapUnique(methods, name, [
+      isArray(parameters) ? parameters : [parameters],
+      returnType,
+      doc,
+      generic,
+    ]);
+  addImport(
+    0,
+    'tinybase',
+    ID,
+    IDS,
+    ID_OR_NULL,
+    'StoreListenerStats',
+    JSON$1,
+    TABLES + SCHEMA,
+    VALUES + SCHEMA,
+    'DoRollback',
+  );
+  let tablesTypes;
+  if (objIsEmpty(tablesSchema)) {
+    tablesTypes = [
+      TABLES,
+      TABLES,
+      ID,
+      TABLE,
+      TABLE,
+      ROW,
+      ROW,
+      ID,
+      CELL,
+      CELL + CALLBACK,
+      ROW + CALLBACK,
+      TABLE + CALLBACK,
+      TABLES + LISTENER,
+      TABLE_IDS + LISTENER,
+      TABLE + LISTENER,
+      ROW_IDS + LISTENER,
+      SORTED_ROW_IDS + LISTENER,
+      ROW + LISTENER,
+      CELL_IDS + LISTENER,
+      CELL + LISTENER,
+      INVALID + CELL + LISTENER,
+    ];
+    addImport(0, 'tinybase', ...tablesTypes);
+    arrayPush(tablesTypes, ID, ID_OR_NULL, ID, EMPTY_STRING, ID, EMPTY_STRING);
+  } else {
+    addImport(0, 'tinybase', 'CellChange');
+    tablesTypes = getTablesTypes('store', STORE);
+    arrayForEach([3, 4, 5, 6, 7, 9, 10], (i) => (tablesTypes[i] += '<TId>'));
+    tablesTypes[8] += '<TId, CId>';
+    arrayPush(
+      tablesTypes,
+      'TId',
+      'TId | null',
+      join(
+        mapTablesSchema((tableId2) => `CellId<'${tableId2}'>`),
+        ' | ',
+      ),
+      `<TId extends ${tablesTypes[2]}>`,
+      'CId',
+      `<TId extends ${tablesTypes[2]}, CId extends ${tablesTypes[7]}>`,
+    );
+  }
+  const [
+    tablesType,
+    tablesWhenSetType,
+    tableIdType,
+    tableType,
+    tableWhenSetType,
+    rowType,
+    rowWhenSetType,
+    cellIdType,
+    cellType,
+    cellCallbackType,
+    rowCallbackType,
+    tableCallbackType,
+    tablesListenerType,
+    tableIdsListenerType,
+    tableListenerType,
+    rowIdsListenerType,
+    sortedRowIdsListenerType,
+    rowListenerType,
+    cellIdsListenerType,
+    cellListenerType,
+    invalidCellListenerType,
+    tableId,
+    tableIdOrNull,
+    allCellIdsType,
+    tIdGeneric,
+    cId,
+    cIdGeneric,
+  ] = tablesTypes;
+  const tableIdParam = 'tableId: ' + tableId;
+  const rowIdParams = getParameterList(tableIdParam, ROW_ID_PARAM);
+  const cellIdParams = getParameterList(rowIdParams, 'cellId: ' + cId);
+  const tableIdOrNullParam = 'tableId: ' + tableIdOrNull;
+  const rowIdOrNullParams = getParameterList(
+    tableIdOrNullParam,
+    ROW_ID_OR_NULL_PARAM,
+  );
+  const cellIdOrNullParams = getParameterList(
+    rowIdOrNullParams,
+    'cellId: ' + allCellIdsType,
+  );
+  arrayForEach(
+    [[tablesType], [BOOLEAN], [STORE, 'tables: ' + tablesWhenSetType], [STORE]],
+    ([returnType, params], verb) =>
+      addMethod(
+        METHOD_PREFIX_VERBS[verb] + TABLES,
+        params ?? EMPTY_STRING,
+        returnType,
+        getTheContentOfTheStoreDoc(1, verb),
+      ),
+  );
+  addMethod(
+    GET + TABLE_IDS,
+    EMPTY_STRING,
+    tableIdType + SQUARE_BRACKETS,
+    getIdsDoc(TABLE, THE_STORE),
+  );
+  addMethod(
+    METHOD_PREFIX_VERBS[5] + TABLE,
+    'tableCallback: ' + tableCallbackType,
+    VOID,
+    getForEachDoc(TABLE, THE_STORE),
+  );
+  arrayForEach(
+    [
+      [tableType, tableIdParam],
+      [BOOLEAN, tableIdParam],
+      [STORE, [tableIdParam, 'table: ' + tableWhenSetType]],
+      [STORE, tableIdParam],
+    ],
+    ([returnType, params], verb) =>
+      addMethod(
+        METHOD_PREFIX_VERBS[verb] + TABLE,
+        params ?? EMPTY_STRING,
+        returnType,
+        getContentDoc(verb, 3),
+        tIdGeneric,
+      ),
+  );
+  addMethod(
+    GET + ROW_IDS,
+    tableIdParam,
+    IDS,
+    getIdsDoc(ROW, A + TABLE),
+    tIdGeneric,
+  );
+  addMethod(
+    GET + SORTED_ROW_IDS,
+    [tableIdParam, 'cellId?: ' + cellIdType + SORTED_ARGS],
+    IDS,
+    getIdsDoc(ROW, A + TABLE),
+    tIdGeneric,
+  );
+  addMethod(
+    METHOD_PREFIX_VERBS[5] + ROW,
+    [tableIdParam, 'rowCallback: ' + rowCallbackType],
+    VOID,
+    getForEachDoc(ROW, A + TABLE),
+    tIdGeneric,
+  );
+  arrayForEach(
+    [
+      [rowType, rowIdParams],
+      [BOOLEAN, rowIdParams],
+      [STORE, [rowIdParams, 'row: ' + rowWhenSetType]],
+      [STORE, rowIdParams],
+    ],
+    ([returnType, params], verb) =>
+      addMethod(
+        METHOD_PREFIX_VERBS[verb] + ROW,
+        params ?? EMPTY_STRING,
+        returnType,
+        getContentDoc(verb, 5),
+        tIdGeneric,
+      ),
+  );
+  addMethod(
+    'set' + PARTIAL + ROW,
+    [tableIdParam, ROW_ID_PARAM, 'partialRow: ' + rowWhenSetType],
+    STORE,
+    getContentDoc(4, 5),
+    tIdGeneric,
+  );
+  addMethod(
+    ADD + ROW,
+    [tableIdParam, 'row: ' + rowWhenSetType],
+    ID + OR_UNDEFINED,
+    'Add a new ' + ROW,
+    tIdGeneric,
+  );
+  addMethod(
+    GET + CELL_IDS,
+    [tableIdParam, ROW_ID_PARAM],
+    cellIdType + SQUARE_BRACKETS,
+    getIdsDoc(CELL, A + ROW),
+    tIdGeneric,
+  );
+  addMethod(
+    METHOD_PREFIX_VERBS[5] + CELL,
+    [tableIdParam, ROW_ID_PARAM, 'cellCallback: ' + cellCallbackType],
+    VOID,
+    getForEachDoc(CELL, A + ROW),
+    tIdGeneric,
+  );
+  arrayForEach(
+    [
+      [cellType, cellIdParams],
+      [BOOLEAN, cellIdParams],
+      [STORE, [cellIdParams, 'cell: ' + cellType]],
+      [STORE, cellIdParams],
+    ],
+    ([returnType, params], verb) =>
+      addMethod(
+        METHOD_PREFIX_VERBS[verb] + CELL,
+        params ?? EMPTY_STRING,
+        returnType,
+        getContentDoc(verb, 7),
+        cIdGeneric,
+      ),
+  );
+  addMethod(
+    ADD + TABLES + LISTENER,
+    [LISTENER_ + ': ' + tablesListenerType, 'mutator?: boolean'],
+    ID,
+    getTheContentOfTheStoreDoc(1, 8) + ' changes',
+  );
+  addMethod(
+    ADD + TABLE_IDS + LISTENER,
+    [LISTENER_ + ': ' + tableIdsListenerType, 'mutator?: boolean'],
+    ID,
+    getListenerDoc(2, 0, 1),
+  );
+  addMethod(
+    ADD + TABLE + LISTENER,
+    [
+      tableIdOrNullParam,
+      LISTENER_ + ': ' + tableListenerType,
+      'mutator?: boolean',
+    ],
+    ID,
+    getListenerDoc(3, 0),
+    tIdGeneric,
+  );
+  addMethod(
+    ADD + ROW_IDS + LISTENER,
+    [
+      tableIdOrNullParam,
+      LISTENER_ + ': ' + rowIdsListenerType,
+      'mutator?: boolean',
+    ],
+    ID,
+    getListenerDoc(4, 3, 1),
+    tIdGeneric,
+  );
+  addMethod(
+    ADD + SORTED_ROW_IDS + LISTENER,
+    [
+      tableIdParam,
+      'cellId: ' + cellIdType + OR_UNDEFINED,
+      'descending: boolean',
+      'offset: number',
+      'limit: number' + OR_UNDEFINED,
+      LISTENER_ + ': ' + sortedRowIdsListenerType,
+      'mutator?: boolean',
+    ],
+    ID,
+    getListenerDoc(13, 3, 1),
+    tIdGeneric,
+  );
+  addMethod(
+    ADD + ROW + LISTENER,
+    [
+      rowIdOrNullParams,
+      LISTENER_ + ': ' + rowListenerType,
+      'mutator?: boolean',
+    ],
+    ID,
+    getListenerDoc(5, 3),
+    tIdGeneric,
+  );
+  addMethod(
+    ADD + CELL_IDS + LISTENER,
+    [
+      rowIdOrNullParams,
+      LISTENER_ + ': ' + cellIdsListenerType,
+      'mutator?: boolean',
+    ],
+    ID,
+    getListenerDoc(6, 5, 1),
+    tIdGeneric,
+  );
+  addMethod(
+    ADD + CELL + LISTENER,
+    [
+      cellIdOrNullParams,
+      LISTENER_ + ': ' + cellListenerType,
+      'mutator?: boolean',
+    ],
+    ID,
+    getListenerDoc(7, 5),
+    tIdGeneric,
+  );
+  addMethod(
+    ADD + INVALID + CELL + LISTENER,
+    [
+      'tableId: ' + ID_OR_NULL,
+      'rowId: ' + ID_OR_NULL,
+      'cellId: ' + ID_OR_NULL,
+      LISTENER_ + ': ' + invalidCellListenerType,
+      'mutator?: boolean',
+    ],
+    ID,
+    REGISTERS_A_LISTENER + ' whenever an invalid Cell change was attempted',
+  );
+  let valuesTypes;
+  if (objIsEmpty(valuesSchema)) {
+    valuesTypes = [
+      VALUES,
+      VALUES,
+      ID,
+      VALUE,
+      VALUE + CALLBACK,
+      VALUES + LISTENER,
+      VALUE_IDS + LISTENER,
+      VALUE + LISTENER,
+      INVALID + VALUE + LISTENER,
+    ];
+    addImport(0, 'tinybase', ...valuesTypes);
+    arrayPush(valuesTypes, ID, ID_OR_NULL, EMPTY_STRING);
+  } else {
+    addImport(0, 'tinybase', 'ValueChange');
+    valuesTypes = getValuesTypes('store', STORE);
+    valuesTypes[3] += '<VId>';
+    arrayPush(
+      valuesTypes,
+      'VId',
+      'VId | null',
+      `<VId extends ${valuesTypes[2]}>`,
+    );
+  }
+  const [
+    valuesType,
+    valuesWhenSetType,
+    valueIdType,
+    valueType,
+    valueCallbackType,
+    valuesListenerType,
+    valueIdsListenerType,
+    valueListenerType,
+    invalidValueListenerType,
+    valueId,
+    valueIdOrNull,
+    vIdGeneric,
+  ] = valuesTypes;
+  const valueIdParam = 'valueId: ' + valueId;
+  arrayForEach(
+    [[valuesType], [BOOLEAN], [STORE, 'values: ' + valuesWhenSetType], [STORE]],
+    ([returnType, params], verb) =>
+      addMethod(
+        METHOD_PREFIX_VERBS[verb] + VALUES,
+        params ?? EMPTY_STRING,
+        returnType,
+        getTheContentOfTheStoreDoc(2, verb),
+      ),
+  );
+  addMethod(
+    'set' + PARTIAL + VALUES,
+    'partialValues: ' + valuesWhenSetType,
+    STORE,
+    getTheContentOfTheStoreDoc(2, 4),
+  );
+  addMethod(
+    GET + VALUE_IDS,
+    EMPTY_STRING,
+    valueIdType + SQUARE_BRACKETS,
+    getIdsDoc(VALUE, THE_STORE),
+  );
+  addMethod(
+    METHOD_PREFIX_VERBS[5] + VALUE,
+    'valueCallback: ' + valueCallbackType,
+    VOID,
+    getForEachDoc(VALUE, THE_STORE),
+  );
+  arrayForEach(
+    [
+      [valueType, valueIdParam],
+      [BOOLEAN, valueIdParam],
+      [STORE, [valueIdParam, 'value: ' + valueType]],
+      [STORE, valueIdParam],
+    ],
+    ([returnType, params], verb) =>
+      addMethod(
+        METHOD_PREFIX_VERBS[verb] + VALUE,
+        params ?? EMPTY_STRING,
+        returnType,
+        getContentDoc(verb, 11),
+        vIdGeneric,
+      ),
+  );
+  addMethod(
+    ADD + VALUES + LISTENER,
+    [LISTENER_ + ': ' + valuesListenerType, 'mutator?: boolean'],
+    ID,
+    getTheContentOfTheStoreDoc(2, 8) + ' changes',
+  );
+  addMethod(
+    ADD + VALUE_IDS + LISTENER,
+    [LISTENER_ + ': ' + valueIdsListenerType, 'mutator?: boolean'],
+    ID,
+    getListenerDoc(10, 0, 1),
+  );
+  addMethod(
+    ADD + VALUE + LISTENER,
+    [
+      'valueId: ' + valueIdOrNull,
+      LISTENER_ + ': ' + valueListenerType,
+      'mutator?: boolean',
+    ],
+    ID,
+    getListenerDoc(11, 0),
+    vIdGeneric,
+  );
+  addMethod(
+    ADD + INVALID + VALUE + LISTENER,
+    [
+      'valueId: ' + ID_OR_NULL,
+      LISTENER_ + ': ' + invalidValueListenerType,
+      'mutator?: boolean',
+    ],
+    ID,
+    REGISTERS_A_LISTENER + ' whenever an invalid Value change was attempted',
+  );
+  arrayForEach(
+    [
+      [EMPTY_STRING, 'tablesAndValues'],
+      [TABLES, 'tables'],
+      [VALUES, 'values'],
+    ],
+    ([noun, param], content) => {
+      addMethod(
+        GET + noun + JSON$1,
+        EMPTY_STRING,
+        JSON$1,
+        getTheContentOfTheStoreDoc(content, 6),
+      );
+      addMethod(
+        'set' + noun + JSON$1,
+        param + JSON$1 + ': ' + JSON$1,
+        STORE,
+        getTheContentOfTheStoreDoc(content, 7),
+      );
+      addMethod(
+        GET + noun + SCHEMA + JSON$1,
+        EMPTY_STRING,
+        JSON$1,
+        getTheContentOfTheStoreDoc(content, 14),
+      );
+      if (noun) {
+        addMethod(
+          'set' + noun + SCHEMA,
+          param + SCHEMA + ': ' + noun + SCHEMA,
+          STORE,
+          getTheContentOfTheStoreDoc(content, 15) + MAY_CONTRADICT_REFINEMENT,
+        );
+      }
+      addMethod(
+        'del' + noun + SCHEMA,
+        EMPTY_STRING,
+        STORE,
+        getTheContentOfTheStoreDoc(content, 16),
+      );
+    },
+  );
+  addMethod(
+    'set' + SCHEMA,
+    [
+      `tables${SCHEMA}: ` + TABLES + SCHEMA,
+      `values${SCHEMA}?: ` + VALUES + SCHEMA,
+    ],
+    STORE,
+    getTheContentOfTheStoreDoc(0, 15) + MAY_CONTRADICT_REFINEMENT,
+  );
+  addMethod(
+    TRANSACTION_,
+    DO_ACTIONS_AND_ROLLBACK_PARAMS,
+    'Return',
+    TRANSACTION_DOC,
+    '<Return>',
+  );
+  addMethod('start' + TRANSACTION, EMPTY_STRING, STORE, START_TRANSACTION_DOC);
+  addMethod(
+    'finish' + TRANSACTION,
+    DO_ROLLBACK_PARAM,
+    STORE,
+    FINISH_TRANSACTION_DOC,
+  );
+  const transactionListenerType = getTransactionListenerType('store', STORE);
+  addMethod(
+    ADD + 'WillFinish' + TRANSACTION + LISTENER,
+    LISTENER_ + ': ' + transactionListenerType,
+    ID,
+    REGISTERS_A_LISTENER + ' just before ' + THE_END_OF_THE_TRANSACTION,
+  );
+  addMethod(
+    ADD + 'DidFinish' + TRANSACTION + LISTENER,
+    LISTENER_ + ': ' + transactionListenerType,
+    ID,
+    REGISTERS_A_LISTENER + ' just after ' + THE_END_OF_THE_TRANSACTION,
+  );
+  addMethod(
+    'call' + LISTENER,
+    'listenerId: Id',
+    STORE,
+    'Manually provoke a listener to be called',
+  );
+  addMethod(
+    'del' + LISTENER,
+    'listenerId: Id',
+    STORE,
+    'Remove a listener that was previously added to ' + THE_STORE,
+  );
+  addMethod(
+    GET + LISTENER + 'Stats',
+    EMPTY_STRING,
+    'StoreListenerStats',
+    'Get listener statistics',
+  );
+  return [
+    build(
+      `export * from 'tinybase';`,
+      ...getImports(0),
+      ...getTypes(),
+      'export interface Store {',
+      ...getMethods(),
+      '}',
+      EMPTY_STRING,
+      comment(`Creates a Store object`),
+      'export function createStore(): Store',
+    ),
+  ];
+};
+
+const getStoreUiReactRefinement = (_tablesSchema, _valuesSchema, _module) => {
+  return [`export * from 'tinybase/ui-react';`];
+};
+
+const getStoreRefinement = (tablesSchema, valuesSchema, module) => {
+  if (objIsEmpty(tablesSchema) && objIsEmpty(valuesSchema)) {
+    return [EMPTY_STRING, EMPTY_STRING];
+  }
+  const [dTsCore] = getStoreCoreRefinement(tablesSchema, valuesSchema);
+  return [dTsCore, ...getStoreUiReactRefinement()];
+};
+
 const prettierConfig = {
   parser: 'typescript',
   singleQuote: true,
@@ -2438,6 +3241,13 @@ const prettierConfig = {
   bracketSpacing: false,
   jsdocSingleLineComment: false,
 };
+const getFormat = async () => {
+  try {
+    return (await import('prettier')).format;
+  } catch (e) {
+    return (str) => str;
+  }
+};
 const createTools = getCreateFunction((store) => {
   const getStoreStats = (detail) => {
     let totalTables = 0;
@@ -2531,18 +3341,21 @@ const createTools = getCreateFunction((store) => {
     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 (e) {
-      format = (str) => str;
-    }
+    const format = await getFormat();
     return arrayMap(getStoreApi$1(module), (file, f) =>
       formatJsDoc(
         format(file, {...prettierConfig, filepath: `_.${extensions[f]}`}),
       ),
     );
   };
+  const getStoreRefinement$1 = (module) =>
+    getStoreRefinement(getStoreTablesSchema(), getStoreValuesSchema());
+  const getPrettyStoreRefinement = async (module) => {
+    const format = await getFormat();
+    return arrayMap(getStoreRefinement$1(), (file) =>
+      formatJsDoc(format(file, {...prettierConfig, filepath: `_.d.ts`})),
+    );
+  };
   const getStore = () => store;
   const tools = {
     getStoreStats,
@@ -2550,6 +3363,8 @@ const createTools = getCreateFunction((store) => {
     getStoreValuesSchema,
     getStoreApi: getStoreApi$1,
     getPrettyStoreApi,
+    getStoreRefinement: getStoreRefinement$1,
+    getPrettyStoreRefinement,
     getStore,
   };
   return objFreeze(tools);