tinybase 5.0.0-beta.9 → 5.0.0

package/tools/with-schemas/index.js

@@ -0,0 +1,3298 @@
+const getTypeOf = (thing) => typeof thing;
+const TINYBASE = 'tinybase';
+const EMPTY_STRING = '';
+const COMMA = ',';
+const STRING = getTypeOf(EMPTY_STRING);
+const BOOLEAN = getTypeOf(true);
+const NUMBER = getTypeOf(0);
+const TYPE = 'type';
+const DEFAULT = 'default';
+const LISTENER = 'Listener';
+const GET = 'get';
+const ADD = 'add';
+const HAS = 'Has';
+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 promise = Promise;
+const isFiniteNumber = isFinite;
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
+const isString = (thing) => getTypeOf(thing) == STRING;
+const isArray = (thing) => Array.isArray(thing);
+const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
+const size = (arrayOrString) => arrayOrString.length;
+const promiseAll = async (promises) => promise.all(promises);
+
+const getCellOrValueType = (cellOrValue) => {
+  const type = getTypeOf(cellOrValue);
+  return isTypeStringOrBoolean(type) ||
+    (type == NUMBER && isFiniteNumber(cellOrValue))
+    ? type
+    : void 0;
+};
+
+const arrayEvery = (array, cb) => array.every(cb);
+const arraySort = (array, sorter) => array.sort(sorter);
+const arrayForEach = (array, cb) => array.forEach(cb);
+const arrayJoin = (array, sep = EMPTY_STRING) => array.join(sep);
+const arrayMap = (array, cb) => array.map(cb);
+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);
+const arrayShift = (array) => array.shift();
+
+const object = Object;
+const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
+const objEntries = object.entries;
+const isObject = (obj) =>
+  !isUndefined(obj) &&
+  ifNotUndefined(
+    getPrototypeOf(obj),
+    (objPrototype) =>
+      objPrototype == object.prototype ||
+      isUndefined(getPrototypeOf(objPrototype)),
+
+    /* istanbul ignore next */
+    () => true,
+  );
+const objIds = object.keys;
+const objFreeze = object.freeze;
+const objToArray = (obj, cb) =>
+  arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
+const objSize = (obj) => size(objIds(obj));
+const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+
+const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
+const collValues = (coll) => [...(coll?.values() ?? [])];
+const collForEach = (coll, cb) => coll?.forEach(cb);
+const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
+
+const mapNew = (entries) => new Map(entries);
+const mapGet = (map, key) => map?.get(key);
+const mapForEach = (map, cb) =>
+  collForEach(map, (value, key) => cb(key, value));
+const mapMap = (coll, cb) =>
+  arrayMap([...(coll?.entries() ?? [])], ([key, value]) => cb(value, key));
+const mapSet = (map, key, value) =>
+  isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
+  if (!collHas(map, key)) {
+    mapSet(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 AND_REGISTERS =
+  ', and registers a listener so that any changes to that result will cause a re-render';
+const CALLBACK = 'Callback';
+const CHANGES = 'Changes';
+const COUNT = 'Count';
+const DEL = 'Del';
+const DEPS = 'Deps';
+const DEPS_SUFFIX = DEPS + '?: React.DependencyList';
+const DO_ROLLBACK_PARAM = 'doRollback?: DoRollback';
+const DO_ACTIONS_AND_ROLLBACK_PARAMS =
+  'actions: () => Return, ' + DO_ROLLBACK_PARAM;
+const EXPORT = 'export';
+const ID = 'Id';
+const INVALID = 'Invalid';
+const JSON$1 = 'Json';
+const LISTENER_ = lower(LISTENER);
+const OPTIONAL_COLON = '?: ';
+const OR_UNDEFINED = ' | undefined';
+const NON_NULLABLE = 'NonNullable';
+const PARTIAL = 'Partial';
+const PROPS = 'Props';
+const PROVIDER = 'Provider';
+const REGISTERS_A_LISTENER = `Registers a ${LISTENER_} that will be called`;
+const REPRESENTS = 'Represents';
+const ROW_ID_PARAM = 'rowId: ' + ID;
+const SCHEMA = 'Schema';
+const SET = 'Set';
+const SORTED_ARGS = ', descending?: boolean, offset?: number, limit?: number';
+const SQUARE_BRACKETS = '[]';
+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 getHasDoc = (has = 0) => (has ? 'the existence of ' : '');
+const getTheContentOfDoc = (content = 0, theStore = 0, has = 0) =>
+  getHasDoc(has) +
+  `the ${CONTENT[content]}content of` +
+  (theStore ? SPACE + THE_STORE : EMPTY_STRING);
+const getTheContentOfTheStoreDoc = (content = 0, verb, set = 0, has = 0) =>
+  VERBS[verb] +
+  SPACE +
+  getHasDoc(has) +
+  getTheContentOfDoc(content, 1) +
+  (set ? ' when setting it' : 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 getPropsDoc = (childNoun) =>
+  'The props passed to a component that renders ' + childNoun;
+const getCallbackDoc = (takes) => 'A function that takes ' + takes;
+const getListenerTypeDoc = (childNoun, parentNoun = 0, has = 0) =>
+  A_FUNCTION_FOR +
+  ' listening to changes to ' +
+  getHasDoc(has) +
+  NOUNS[childNoun] +
+  ' in ' +
+  NOUNS[parentNoun];
+const getListenerDoc = (childNoun, parentNoun, pluralChild = 0, has = 0) =>
+  REGISTERS_A_LISTENER +
+  ' whenever ' +
+  getHasDoc(has) +
+  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, has = 0) =>
+  VERBS[verb] +
+  SPACE +
+  getTheContentOfDoc(0, 0, has) +
+  SPACE +
+  getTableDoc(tableId);
+const getRowContentDoc = (tableId, verb = 0, has = 0) =>
+  VERBS[verb] + ` ${getTheContentOfDoc(0, 0, has)} ` + getRowDoc(tableId);
+const getCellContentDoc = (tableId, cellId, verb = 0, has = 0) =>
+  VERBS[verb] +
+  SPACE +
+  getHasDoc(has) +
+  `the '${cellId}' Cell for ` +
+  getRowDoc(tableId);
+const getValueContentDoc = (valueId, verb = 0, has = 0) =>
+  VERBS[verb] + SPACE + getHasDoc(has) + `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',
+  '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,
+  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,
+  THE + CELL + SPACE + IDS + ' anywhere',
+  THE + 'number of Rows',
+  A + CELL + ' anywhere',
+];
+const CONTENT = [EMPTY_STRING, 'tabular ', 'keyed value '];
+
+const setNew = (entryOrEntries) =>
+  new Set(
+    isArray(entryOrEntries) || isUndefined(entryOrEntries)
+      ? entryOrEntries
+      : [entryOrEntries],
+  );
+const setAdd = (set, value) => set?.add(value);
+
+const NON_ALPHA = /[^A-Za-z]+/;
+const NON_ALPHANUMERIC = /[^A-Za-z0-9]+/;
+const JSDOC = /^( *)\/\*\* *(.*?) *\*\/$/gm;
+const stringHasComma = (str) => str.includes(COMMA);
+const mapUnique = (map, id, value, index = 1) => {
+  const uniqueId = `${id}${index == 1 ? '' : index}`;
+  if (collHas(map, uniqueId)) {
+    return mapUnique(map, id, value, index + 1);
+  } else {
+    mapSet(map, uniqueId, value);
+    return uniqueId;
+  }
+};
+const formatJsDoc = (file) =>
+  file.replace(JSDOC, (_, indent, text) => {
+    const lineLength = 77 - size(indent);
+    return `${indent}/**
+${text.replace(
+  new RegExp(`([^\\n]{1,${lineLength}})(\\s|$)`, 'g'),
+  `${indent} * $1
+`,
+)}${indent} */`;
+  });
+const flat = (array) => array.flat(1e3);
+const camel = (str, firstCap = 0) =>
+  arrayJoin(
+    arrayMap(
+      str.split(NON_ALPHANUMERIC),
+      (word, w) =>
+        (w > 0 || firstCap ? upper : lower)(slice(word, 0, 1)) + slice(word, 1),
+    ),
+  );
+const snake = (str) =>
+  upper(
+    arrayJoin(
+      (str && !NON_ALPHA.test(str[0]) ? str : ' ' + str).split(
+        NON_ALPHANUMERIC,
+      ),
+      '_',
+    ),
+  );
+const comment = (doc) => `/** ${doc}. */`;
+const getParameterList = (...params) =>
+  arrayJoin(
+    arrayFilter(params, (param) => param),
+    ', ',
+  );
+const getFieldTypeList = (...props) => '{' + arrayJoin(props, '; ') + '}';
+const getPropTypeList = (...props) =>
+  getFieldTypeList(...arrayMap(props, (prop) => 'readonly ' + prop));
+const getCodeFunctions = () => {
+  const allImports = [mapNew(), mapNew(), mapNew(), mapNew()];
+  const types = mapNew();
+  const constants = mapNew();
+  const build = (...lines) => arrayJoin(flat(lines), '\n');
+  const addImport = (location, source, ...items) =>
+    arrayForEach(items, (item) =>
+      arrayForEach([0, 1], (eachLocation) =>
+        (location ?? eachLocation) == eachLocation
+          ? setAdd(mapEnsure(allImports[eachLocation], source, setNew), item)
+          : 0,
+      ),
+    );
+  const addType = (name, body, doc, generic = EMPTY_STRING, exported = 1) =>
+    mapUnique(types, name, [body, doc, generic, exported]);
+  const addInternalFunction = (name, parameters, body) =>
+    mapUnique(
+      constants,
+      name,
+      isArray(body)
+        ? [`(${parameters}) => {`, body, '}']
+        : [`(${parameters}) => ${body}`],
+    );
+  const addConstant = (name, body) =>
+    mapGet(constants, name) === body ? name : mapUnique(constants, name, body);
+  const getSortableImport = (importMaybeAs) => {
+    const as = importMaybeAs.indexOf(' as ');
+    return as != -1 ? slice(importMaybeAs, as + 4) : importMaybeAs;
+  };
+  const getImports = (location = 0) =>
+    arrayMap(
+      [
+        ...arraySort(
+          mapMap(
+            allImports[location],
+            (items, source) =>
+              `import {${arrayJoin(
+                arraySort(collValues(items), (import1, import2) =>
+                  getSortableImport(import1) > getSortableImport(import2)
+                    ? 1
+                    : -1,
+                ),
+                ', ',
+              )}} 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, generic, exported], name) => [
+      comment(doc),
+      `${exported ? EXPORT + ' ' : EMPTY_STRING}type ${name}${generic} = ${body};`,
+      EMPTY_STRING,
+    ]);
+  const getConstants = () =>
+    mapMap(constants, (body, name) => {
+      body = isArray(body) ? body : [body];
+      arrayPush(body, `${arrayPop(body)};`);
+      return [`const ${name} = ${arrayShift(body)}`, body, EMPTY_STRING];
+    });
+  return [
+    build,
+    addImport,
+    addType,
+    addInternalFunction,
+    addConstant,
+    getImports,
+    getTypes,
+    getConstants,
+  ];
+};
+
+const getCreateFunction = (getFunction, initFunction) => {
+  const thingsByStore = /* @__PURE__ */ new WeakMap();
+  return (store) => {
+    if (!thingsByStore.has(store)) {
+      thingsByStore.set(store, getFunction(store));
+    }
+    const thing = thingsByStore.get(store);
+    return thing;
+  };
+};
+
+const getSchemaFunctions = (tablesSchema, valuesSchema, addConstant) => {
+  const mapTablesSchema = (callback) =>
+    objToArray(tablesSchema, (_, tableId) => {
+      return callback(
+        tableId,
+        camel(tableId, 1),
+        addConstant(snake(tableId), `'${tableId}'`),
+      );
+    });
+  const mapCellSchema = (tableId, callback) =>
+    objToArray(tablesSchema[tableId], (cellSchema, cellId) =>
+      callback(
+        cellId,
+        cellSchema[TYPE],
+        cellSchema[DEFAULT],
+        addConstant(snake(cellId), `'${cellId}'`),
+        camel(cellId, 1),
+      ),
+    );
+  const mapValuesSchema = (callback) =>
+    objToArray(valuesSchema, (valueSchema, valueId) =>
+      callback(
+        valueId,
+        valueSchema[TYPE],
+        valueSchema[DEFAULT],
+        addConstant(snake(valueId), `'${valueId}'`),
+        camel(valueId, 1),
+      ),
+    );
+  return [mapTablesSchema, mapCellSchema, mapValuesSchema];
+};
+
+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 tableCellCallbackType = addType(
+      TABLE + CELL + CALLBACK,
+      `(cellId: ${cellIdType}<TId>, count: number) ` + RETURNS_VOID,
+      getCallbackDoc(A + CELL + ' Id, and count of how many times it appears'),
+      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 hasTablesListenerType = addType(
+      HAS + TABLES + LISTENER,
+      `(${storeParam}, hasTables: boolean)` + RETURNS_VOID,
+      getListenerTypeDoc(1, 0, 1),
+    );
+    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 hasTableListenerType = addType(
+      HAS + TABLE + LISTENER,
+      `(${storeParam}, tableId: ${tableIdType}, hasTable: boolean)` +
+        RETURNS_VOID,
+      getListenerTypeDoc(3, 0, 1),
+    );
+    const tableListenerType = addType(
+      TABLE + LISTENER,
+      `(${storeParam}, tableId: ${tableIdType}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})` +
+        RETURNS_VOID,
+      getListenerTypeDoc(3),
+    );
+    const tableCellIdsListenerType = addType(
+      TABLE + CELL_IDS + LISTENER,
+      `(${storeParam}, tableId: ${tableIdType})` + RETURNS_VOID,
+      getListenerTypeDoc(14, 3),
+    );
+    const hasTableCellListenerArgsArrayInnerType = addType(
+      'HasTableCellListenerArgsArrayInner',
+      `CId extends ${cellIdType}<TId> ? [${storeParam}, tableId: TId, cellId: CId, hasTableCell: boolean] : never`,
+      'Cell args for HasTableCellListener',
+      `<TId extends ${tableIdType}, CId = ${cellIdType}<TId>>`,
+      0,
+    );
+    const hasTableCellListenerArgsArrayOuterType = addType(
+      'HasTableCellListenerArgsArrayOuter',
+      `TId extends ${tableIdType} ? ` +
+        hasTableCellListenerArgsArrayInnerType +
+        '<TId> : never',
+      'Table args for HasTableCellListener',
+      `<TId = ${tableIdType}>`,
+      0,
+    );
+    const hasTableCellListenerType = addType(
+      HAS + TABLE + CELL + LISTENER,
+      `(...[${storeInstance}, tableId, cellId, hasTableCell]: ` +
+        hasTableCellListenerArgsArrayOuterType +
+        ')' +
+        RETURNS_VOID,
+      getListenerTypeDoc(16, 3, 1),
+    );
+    const rowCountListenerType = addType(
+      ROW + 'Count' + LISTENER,
+      `(${storeParam}, tableId: ${tableIdType})` + RETURNS_VOID,
+      getListenerTypeDoc(15, 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 hasRowListenerType = addType(
+      HAS + ROW + LISTENER,
+      '(' +
+        getParameterList(
+          `${storeParam}`,
+          'tableId: ' + tableIdType,
+          ROW_ID_PARAM,
+          `hasRow: boolean`,
+        ) +
+        ')' +
+        RETURNS_VOID,
+      getListenerTypeDoc(5, 3, 1),
+    );
+    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 hasCellListenerArgsArrayInnerType = addType(
+      'HasCellListenerArgsArrayInner',
+      `CId extends ${cellIdType}<TId> ? [${storeParam}, tableId: TId, ${ROW_ID_PARAM}, cellId: CId, hasCell: boolean] : never`,
+      'Cell args for HasCellListener',
+      `<TId extends ${tableIdType}, CId = ${cellIdType}<TId>>`,
+      0,
+    );
+    const hasCellListenerArgsArrayOuterType = addType(
+      'HasCellListenerArgsArrayOuter',
+      `TId extends ${tableIdType} ? ` +
+        hasCellListenerArgsArrayInnerType +
+        '<TId> : never',
+      'Table args for HasCellListener',
+      `<TId = ${tableIdType}>`,
+      0,
+    );
+    const hasCellListenerType = addType(
+      HAS + CELL + LISTENER,
+      `(...[${storeInstance}, tableId, rowId, cellId, hasCell]: ` +
+        hasCellListenerArgsArrayOuterType +
+        ')' +
+        RETURNS_VOID,
+      getListenerTypeDoc(7, 5, 1),
+    );
+    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,
+      tableCellCallbackType,
+      tableCallbackType,
+      hasTablesListenerType,
+      tablesListenerType,
+      tableIdsListenerType,
+      hasTableListenerType,
+      tableListenerType,
+      tableCellIdsListenerType,
+      hasTableCellListenerType,
+      rowCountListenerType,
+      rowIdsListenerType,
+      sortedRowIdsListenerType,
+      hasRowListenerType,
+      rowListenerType,
+      cellIdsListenerType,
+      hasCellListenerType,
+      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 hasValuesListenerType = addType(
+      HAS + VALUES + LISTENER,
+      `(${storeParam}, hasValues: boolean)` + RETURNS_VOID,
+      getListenerTypeDoc(9, 0, 1),
+    );
+    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 hasValueListenerType = addType(
+      HAS + VALUE + LISTENER,
+      `(${storeParam}, valueId: ValueId, hasValue: boolean)` + RETURNS_VOID,
+      getListenerTypeDoc(11, 0, 1),
+    );
+    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,
+      hasValuesListenerType,
+      valuesListenerType,
+      valueIdsListenerType,
+      hasValueListenerType,
+      valueListenerType,
+      invalidValueListenerType,
+    ];
+  };
+  const getTransactionListenerType = (storeInstance, storeType) =>
+    addType(
+      TRANSACTION + LISTENER,
+      `(${storeInstance}: ${storeType})` + 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) =>
+  `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 [getTablesTypes, getValuesTypes, getTransactionListenerType] =
+    getTypeFunctions(addType, mapTablesSchema, mapCellSchema, mapValuesSchema);
+  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,
+    generic = EMPTY_STRING,
+  ) =>
+    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,
+      generic,
+    );
+  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,
+    storeType,
+    `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,
+      tableCellCallbackType,
+      tableCallbackType,
+      hasTablesListenerType,
+      tablesListenerType,
+      tableIdsListenerType,
+      hasTableListenerType,
+      tableListenerType,
+      tableCellIdsListenerType,
+      hasTableCellListenerType,
+      rowCountListenerType,
+      rowIdsListenerType,
+      sortedRowIdsListenerType,
+      hasRowListenerType,
+      rowListenerType,
+      cellIdsListenerType,
+      hasCellListenerType,
+      cellListenerType,
+      invalidCellListenerType,
+    ] = getTablesTypes(storeInstance, storeType);
+    const tablesTypes = mapNew();
+    mapTablesSchema((tableId, tableName) => {
+      const tableIdGeneric = `<'${tableId}'>`;
+      const tableTypes = [
+        // Table
+        addType(
+          tableName + TABLE,
+          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,
+          rowType + tableIdGeneric,
+          getRowTypeDoc(tableId),
+        ),
+        // RowWhenSet
+        addType(
+          tableName + ROW + WHEN_SET,
+          rowWhenSetType + tableIdGeneric,
+          getRowTypeDoc(tableId, 1),
+        ),
+        // CellId
+        addType(
+          tableName + CELL + ID,
+          cellIdType + tableIdGeneric,
+          `A Cell Id for the '${tableId}' ` + TABLE,
+        ),
+        // CellCallback
+        addType(
+          tableName + CELL + CALLBACK,
+          cellCallbackType + tableIdGeneric,
+          getCallbackDoc(
+            `a Cell Id and value from a Row in the '${tableId}' ` + TABLE,
+          ),
+        ),
+        // RowCallback
+        addType(
+          tableName + ROW + CALLBACK,
+          rowCallbackType + tableIdGeneric,
+          getCallbackDoc(
+            `a Row Id from the '${tableId}' Table, and a Cell iterator`,
+          ),
+        ),
+        // TableCellCallbackType
+        addType(
+          tableName + TABLE + CELL + CALLBACK,
+          tableCellCallbackType + tableIdGeneric,
+          getCallbackDoc(
+            `a Cell Id from anywhere in the '${tableId}' Table, and a count of how many times it appears`,
+          ),
+        ),
+      ];
+      mapSet(tablesTypes, tableId, tableTypes);
+      addImport(1, moduleDefinition, ...tableTypes);
+    });
+    addImport(
+      1,
+      moduleDefinition,
+      tablesType,
+      tablesWhenSetType,
+      tableIdType,
+      cellIdType,
+      tableCallbackType,
+      hasTablesListenerType,
+      tablesListenerType,
+      tableIdsListenerType,
+      hasTableListenerType,
+      tableListenerType,
+      tableCellIdsListenerType,
+      hasTableCellListenerType,
+      rowCountListenerType,
+      rowIdsListenerType,
+      sortedRowIdsListenerType,
+      hasRowListenerType,
+      rowListenerType,
+      cellIdsListenerType,
+      hasCellListenerType,
+      cellListenerType,
+      invalidCellListenerType,
+    );
+    sharedTableTypes = [
+      tablesType,
+      tablesWhenSetType,
+      tableIdType,
+      cellIdType,
+      hasTablesListenerType,
+      tablesListenerType,
+      tableIdsListenerType,
+      hasTableListenerType,
+      tableListenerType,
+      tableCellIdsListenerType,
+      hasTableCellListenerType,
+      rowCountListenerType,
+      rowIdsListenerType,
+      sortedRowIdsListenerType,
+      hasRowListenerType,
+      rowListenerType,
+      cellIdsListenerType,
+      hasCellListenerType,
+      cellListenerType,
+      tablesTypes,
+    ];
+    arrayForEach(
+      [
+        [tablesType],
+        [BOOLEAN],
+        [storeType, 'tables: ' + tablesWhenSetType, 'tables'],
+        [storeType],
+      ],
+      ([returnType, params, paramsInCall], verb) =>
+        addProxyMethod(
+          verb,
+          EMPTY_STRING,
+          TABLES,
+          returnType,
+          getTheContentOfTheStoreDoc(1, verb),
+          params,
+          paramsInCall,
+        ),
+    );
+    addProxyMethod(
+      0,
+      EMPTY_STRING,
+      TABLE_IDS,
+      tableIdType + SQUARE_BRACKETS,
+      getIdsDoc(TABLE, THE_STORE),
+    );
+    addProxyMethod(
+      5,
+      EMPTY_STRING,
+      TABLE,
+      VOID,
+      getForEachDoc(TABLE, THE_STORE),
+      'tableCallback: ' + tableCallbackType,
+      'tableCallback as any',
+    );
+    mapTablesSchema((tableId, tableName, TABLE_ID) => {
+      const [
+        tableType2,
+        tableWhenSetType2,
+        rowType2,
+        rowWhenSetType2,
+        cellIdType2,
+        cellCallbackType2,
+        rowCallbackType2,
+        tableCellCallbackType2,
+      ] = mapGet(tablesTypes, tableId);
+      arrayForEach(
+        [
+          [tableType2],
+          [BOOLEAN],
+          [storeType, 'table: ' + tableWhenSetType2, ', table'],
+          [storeType],
+        ],
+        ([returnType, params, paramsInCall = EMPTY_STRING], verb) =>
+          addProxyMethod(
+            verb,
+            tableName,
+            TABLE,
+            returnType,
+            getTableContentDoc(tableId, verb),
+            params,
+            TABLE_ID + paramsInCall,
+          ),
+      );
+      addProxyMethod(
+        0,
+        tableName,
+        TABLE + CELL_IDS,
+        IDS,
+        getIdsDoc(CELL, 'the whole of ' + getTableDoc(tableId)),
+        EMPTY_STRING,
+        TABLE_ID,
+      );
+      addProxyMethod(
+        5,
+        tableName,
+        TABLE + CELL,
+        VOID,
+        getForEachDoc(TABLE + CELL, 'the whole of ' + getTableDoc(tableId)),
+        'tableCellCallback: ' + tableCellCallbackType2,
+        TABLE_ID + ', tableCellCallback as any',
+      );
+      addProxyMethod(
+        0,
+        tableName,
+        ROW + COUNT,
+        'number',
+        'Gets the number of Rows in the ' + getTableDoc(tableId),
+        EMPTY_STRING,
+        TABLE_ID,
+      );
+      addProxyMethod(
+        0,
+        tableName,
+        ROW_IDS,
+        IDS,
+        getIdsDoc(ROW, getTableDoc(tableId)),
+        EMPTY_STRING,
+        TABLE_ID,
+      );
+      addProxyMethod(
+        0,
+        tableName,
+        SORTED_ROW_IDS,
+        IDS,
+        getIdsDoc(ROW, getTableDoc(tableId), 1),
+        'cellId?: ' + cellIdType2 + SORTED_ARGS,
+        TABLE_ID + ', cellId, descending, offset, limit',
+      );
+      addProxyMethod(
+        5,
+        tableName,
+        ROW,
+        VOID,
+        getForEachDoc(ROW, getTableDoc(tableId)),
+        'rowCallback: ' + rowCallbackType2,
+        TABLE_ID + ', rowCallback as any',
+      );
+      arrayForEach(
+        [
+          [rowType2],
+          [BOOLEAN],
+          [storeType, ', row: ' + rowWhenSetType2, ', row'],
+          [storeType],
+          [storeType, ', partialRow: ' + rowWhenSetType2, ', partialRow'],
+        ],
+        (
+          [returnType, params = EMPTY_STRING, paramsInCall = EMPTY_STRING],
+          verb,
+        ) =>
+          addProxyMethod(
+            verb,
+            tableName,
+            ROW,
+            returnType,
+            getRowContentDoc(tableId, verb),
+            ROW_ID_PARAM + params,
+            TABLE_ID + ', rowId' + paramsInCall,
+          ),
+      );
+      addProxyMethod(
+        6,
+        tableName,
+        ROW,
+        ID + OR_UNDEFINED,
+        'Add a new Row to ' + getTableDoc(tableId),
+        'row: ' + rowWhenSetType2 + ', reuseIds?: boolean',
+        TABLE_ID + ', row, reuseIds',
+      );
+      addProxyMethod(
+        0,
+        tableName,
+        CELL_IDS,
+        cellIdType2 + SQUARE_BRACKETS,
+        getIdsDoc(CELL, getRowDoc(tableId)),
+        ROW_ID_PARAM,
+        TABLE_ID + ', rowId',
+      );
+      addProxyMethod(
+        5,
+        tableName,
+        CELL,
+        VOID,
+        getForEachDoc(CELL, getRowDoc(tableId)),
+        ROW_ID_PARAM + ', cellCallback: ' + cellCallbackType2,
+        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),
+                ROW_ID_PARAM + params,
+                TABLE_ID + ', rowId, ' + CELL_ID + paramsInCall,
+              ),
+          );
+          addProxyMethod(
+            1,
+            tableName + cellName,
+            TABLE + CELL,
+            BOOLEAN,
+            VERBS[1] +
+              ` the '${cellId}' Cell anywhere in ` +
+              getTableDoc(tableId),
+            EMPTY_STRING,
+            TABLE_ID + ', ' + CELL_ID,
+          );
+        },
+      );
+    });
+    addProxyMethod(
+      0,
+      EMPTY_STRING,
+      TABLES + JSON$1,
+      JSON$1,
+      getTheContentOfTheStoreDoc(1, 6),
+    );
+    addProxyMethod(
+      2,
+      EMPTY_STRING,
+      TABLES + JSON$1,
+      storeType,
+      getTheContentOfTheStoreDoc(1, 7),
+      'tablesJson: ' + JSON$1,
+      'tables' + JSON$1,
+    );
+    addProxyListener(
+      HAS + TABLES,
+      hasTablesListenerType,
+      getTheContentOfTheStoreDoc(1, 8, 0, 1) + ' changes',
+    );
+    addProxyListener(
+      TABLES,
+      tablesListenerType,
+      getTheContentOfTheStoreDoc(1, 8) + ' changes',
+    );
+    addProxyListener(TABLE_IDS, tableIdsListenerType, getListenerDoc(2, 0, 1));
+    addProxyListener(
+      HAS + TABLE,
+      hasTableListenerType,
+      getListenerDoc(3, 0, 0, 1),
+      `tableId: ${tableIdType} | null`,
+      'tableId',
+    );
+    addProxyListener(
+      TABLE,
+      tableListenerType,
+      getListenerDoc(3, 0),
+      `tableId: ${tableIdType} | null`,
+      'tableId',
+    );
+    addProxyListener(
+      TABLE + CELL_IDS,
+      tableCellIdsListenerType,
+      getListenerDoc(14, 3, 1),
+      `tableId: ${tableIdType} | null`,
+      'tableId',
+    );
+    addProxyListener(
+      HAS + TABLE + CELL,
+      hasTableCellListenerType,
+      getListenerDoc(16, 3, 0, 1),
+      `tableId: ${tableIdType} | null, cellId: ${arrayJoin(
+        mapTablesSchema(
+          (tableId) => mapGet(tablesTypes, tableId)?.[4] ?? EMPTY_STRING,
+        ),
+        ' | ',
+      )} | null`,
+      'tableId,  cellId',
+    );
+    addProxyListener(
+      ROW + COUNT,
+      rowCountListenerType,
+      getListenerDoc(15, 3),
+      `tableId: ${tableIdType} | null`,
+      'tableId',
+    );
+    addProxyListener(
+      ROW_IDS,
+      rowIdsListenerType,
+      getListenerDoc(4, 3, 1),
+      `tableId: ${tableIdType} | null`,
+      'tableId',
+    );
+    addProxyListener(
+      SORTED_ROW_IDS,
+      sortedRowIdsListenerType,
+      getListenerDoc(13, 3, 1),
+      getParameterList(
+        '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(
+      HAS + ROW,
+      hasRowListenerType,
+      getListenerDoc(5, 3, 0, 1),
+      `tableId: ${tableIdType} | null, rowId: IdOrNull`,
+      'tableId, rowId',
+    );
+    addProxyListener(
+      ROW,
+      rowListenerType,
+      getListenerDoc(5, 3),
+      `tableId: ${tableIdType} | null, rowId: IdOrNull`,
+      'tableId, rowId',
+    );
+    addProxyListener(
+      CELL_IDS,
+      cellIdsListenerType,
+      getListenerDoc(6, 5, 1),
+      `tableId: ${tableIdType} | null, rowId: IdOrNull`,
+      'tableId, rowId',
+    );
+    addProxyListener(
+      HAS + CELL,
+      hasCellListenerType,
+      getListenerDoc(7, 5, 0, 1),
+      `tableId: ${tableIdType} | null, rowId: IdOrNull, cellId: ${arrayJoin(
+        mapTablesSchema(
+          (tableId) => mapGet(tablesTypes, tableId)?.[4] ?? EMPTY_STRING,
+        ),
+        ' | ',
+      )} | null`,
+      'tableId, rowId, cellId',
+    );
+    addProxyListener(
+      CELL,
+      cellListenerType,
+      getListenerDoc(7, 5),
+      `tableId: ${tableIdType} | null, rowId: IdOrNull, cellId: ${arrayJoin(
+        mapTablesSchema(
+          (tableId) => mapGet(tablesTypes, tableId)?.[4] ?? EMPTY_STRING,
+        ),
+        ' | ',
+      )} | null`,
+      'tableId, rowId, cellId',
+    );
+    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, moduleDefinition, ...collValues(mapCellOrValueTypes));
+    arrayPush(
+      createSteps,
+      '.set' + TABLES + SCHEMA + '({',
+      flat(
+        mapTablesSchema((tableId, _, TABLE_ID) => [
+          `[${TABLE_ID}]: {`,
+          ...mapCellSchema(
+            tableId,
+            (_2, type, defaultValue, CELL_ID) =>
+              `[${CELL_ID}]: {[${addConstant(
+                snake(TYPE),
+                `'${TYPE}'`,
+              )}]: ${addConstant(snake(type), `'${type}'`)}${isUndefined(defaultValue) ? EMPTY_STRING : `, [${addConstant(snake(DEFAULT), `'${DEFAULT}'`)}]: ` + (isString(defaultValue) ? addConstant(snake(defaultValue), `'${defaultValue}'`) : defaultValue)}},`,
+          ),
+          `},`,
+        ]),
+      ),
+      '})',
+    );
+  } else {
+    addImport(null, TINYBASE, TABLES);
+  }
+  if (!objIsEmpty(valuesSchema)) {
+    const [
+      valuesType,
+      valuesWhenSetType,
+      valueIdType,
+      _valueType,
+      valueCallbackType,
+      hasValuesListenerType,
+      valuesListenerType,
+      valueIdsListenerType,
+      hasValueListenerType,
+      valueListenerType,
+      invalidValueListenerType,
+    ] = getValuesTypes(storeInstance, storeType);
+    addImport(
+      1,
+      moduleDefinition,
+      valuesType,
+      valuesWhenSetType,
+      valueIdType,
+      valueCallbackType,
+      hasValuesListenerType,
+      valuesListenerType,
+      valueIdsListenerType,
+      hasValueListenerType,
+      valueListenerType,
+      invalidValueListenerType,
+    );
+    sharedValueTypes = [
+      valuesType,
+      valuesWhenSetType,
+      valueIdType,
+      hasValuesListenerType,
+      valuesListenerType,
+      valueIdsListenerType,
+      hasValueListenerType,
+      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,
+        ),
+    );
+    addProxyMethod(
+      0,
+      EMPTY_STRING,
+      VALUE_IDS,
+      valueIdType + SQUARE_BRACKETS,
+      getIdsDoc(VALUE, THE_STORE),
+    );
+    addProxyMethod(
+      5,
+      EMPTY_STRING,
+      VALUE,
+      `void`,
+      getForEachDoc(VALUE, THE_STORE),
+      `valueCallback: ${valueCallbackType}`,
+      'valueCallback as any',
+    );
+    mapValuesSchema((valueId, type, _, VALUE_ID, valueName) => {
+      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,
+          ),
+      );
+    });
+    addProxyMethod(
+      0,
+      EMPTY_STRING,
+      VALUES + JSON$1,
+      JSON$1,
+      getTheContentOfTheStoreDoc(2, 6),
+    );
+    addProxyMethod(
+      2,
+      EMPTY_STRING,
+      VALUES + JSON$1,
+      storeType,
+      getTheContentOfTheStoreDoc(2, 7),
+      'valuesJson: ' + JSON$1,
+      'values' + JSON$1,
+    );
+    addProxyListener(
+      HAS + VALUES,
+      hasValuesListenerType,
+      getTheContentOfTheStoreDoc(2, 8, 0, 1) + ' changes',
+    );
+    addProxyListener(
+      VALUES,
+      valuesListenerType,
+      getTheContentOfTheStoreDoc(2, 8) + ' changes',
+    );
+    addProxyListener(VALUE_IDS, valueIdsListenerType, getListenerDoc(10, 0, 1));
+    addProxyListener(
+      HAS + VALUE,
+      hasValueListenerType,
+      getListenerDoc(11, 0, 0, 1),
+      `valueId: ${valueIdType} | null`,
+      'valueId',
+    );
+    addProxyListener(
+      VALUE,
+      valueListenerType,
+      getListenerDoc(11, 0),
+      `valueId: ${valueIdType} | null`,
+      'valueId',
+    );
+    addProxyListener(
+      INVALID + VALUE,
+      invalidValueListenerType,
+      REGISTERS_A_LISTENER + ' whenever an invalid Value change was attempted',
+      `valueId: IdOrNull`,
+      'valueId',
+    );
+    addImport(1, moduleDefinition, ...collValues(mapCellOrValueTypes));
+    addImport(0, TINYBASE, 'ValueChange');
+    arrayPush(
+      createSteps,
+      '.set' + VALUES + SCHEMA + '({',
+      mapValuesSchema((_, type, defaultValue, VALUE_ID) => [
+        `[${VALUE_ID}]: {[${addConstant(
+          snake(TYPE),
+          `'${TYPE}'`,
+        )}]: ${addConstant(snake(type), `'${type}'`)}${isUndefined(defaultValue) ? EMPTY_STRING : `, [${addConstant(snake(DEFAULT), `'${DEFAULT}'`)}]: ` + (isString(defaultValue) ? addConstant(snake(defaultValue), `'${defaultValue}'`) : defaultValue)}},`,
+      ]),
+      '})',
+    );
+  } else {
+    addImport(null, TINYBASE, VALUES);
+  }
+  addProxyMethod(
+    0,
+    EMPTY_STRING,
+    'Content',
+    `[${TABLES}, ${VALUES}]`,
+    getTheContentOfTheStoreDoc(0, 0),
+  );
+  addProxyMethod(
+    2,
+    EMPTY_STRING,
+    'Content',
+    storeType,
+    getTheContentOfTheStoreDoc(0, 2),
+    `[tables, values]: [${TABLES}, ${VALUES}]`,
+    '[tables, values]',
+  );
+  addProxyMethod(
+    7,
+    EMPTY_STRING,
+    'applyChanges',
+    storeType,
+    `Applies a set of ${CHANGES} to the Store`,
+    'changes: ' + CHANGES,
+    'changes',
+  );
+  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',
+    JSON$1,
+    'Store',
+    CHANGES,
+  );
+  addProxyMethod(
+    0,
+    EMPTY_STRING,
+    JSON$1,
+    JSON$1,
+    getTheContentOfTheStoreDoc(0, 6),
+  );
+  addProxyMethod(
+    2,
+    EMPTY_STRING,
+    JSON$1,
+    storeType,
+    getTheContentOfTheStoreDoc(0, 7),
+    'tablesAndValuesJson: ' + JSON$1,
+    'tablesAndValuesJson',
+  );
+  addProxyMethod(
+    7,
+    EMPTY_STRING,
+    TRANSACTION_,
+    'Return',
+    TRANSACTION_DOC,
+    DO_ACTIONS_AND_ROLLBACK_PARAMS,
+    'actions, doRollback',
+    '<Return>',
+  );
+  addProxyMethod(
+    7,
+    EMPTY_STRING,
+    'start' + TRANSACTION,
+    storeType,
+    START_TRANSACTION_DOC,
+  );
+  addProxyMethod(
+    7,
+    EMPTY_STRING,
+    'finish' + TRANSACTION,
+    storeType,
+    FINISH_TRANSACTION_DOC,
+    DO_ROLLBACK_PARAM,
+    'doRollback',
+  );
+  const transactionListenerType = getTransactionListenerType(
+    storeInstance,
+    storeType,
+  );
+  addProxyListener(
+    'Start' + TRANSACTION,
+    transactionListenerType,
+    REGISTERS_A_LISTENER + ' just before the start of the ' + TRANSACTION_,
+    EMPTY_STRING,
+    EMPTY_STRING,
+    0,
+  );
+  addProxyListener(
+    'WillFinish' + TRANSACTION,
+    transactionListenerType,
+    REGISTERS_A_LISTENER + ' just before ' + THE_END_OF_THE_TRANSACTION,
+    EMPTY_STRING,
+    EMPTY_STRING,
+    0,
+  );
+  addProxyListener(
+    'DidFinish' + TRANSACTION,
+    transactionListenerType,
+    REGISTERS_A_LISTENER + ' just after ' + THE_END_OF_THE_TRANSACTION,
+    EMPTY_STRING,
+    EMPTY_STRING,
+    0,
+  );
+  addProxyMethod(
+    7,
+    EMPTY_STRING,
+    'call' + LISTENER,
+    storeType,
+    'Manually provoke a listener to be called',
+    'listenerId: Id',
+    'listenerId',
+  );
+  addProxyMethod(
+    3,
+    EMPTY_STRING,
+    LISTENER,
+    storeType,
+    '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',
+  );
+  addImport(1, TINYBASE, 'createStore');
+  addImport(
+    1,
+    moduleDefinition,
+    storeType,
+    `create${storeType} as create${storeType}Decl`,
+    transactionListenerType,
+  );
+  addConstant('store', ['createStore()', ...createSteps]);
+  addInternalFunction('fluent', 'actions: () => Store', [
+    'actions();',
+    `return ${storeInstance};`,
+  ]);
+  addInternalFunction(
+    'proxy',
+    `listener: any`,
+    `(_: Store, ...params: any[]) => listener(${storeInstance}, ...params)`,
+  );
+  addConstant(storeInstance, ['{', ...getMethods(1), '}']);
+  return [
+    build(
+      ...getImports(0),
+      ...getTypes(),
+      EXPORT + ' interface ' + storeType + ' {',
+      ...getMethods(0),
+      '}',
+      EMPTY_STRING,
+      comment(`Creates a ${storeType} object`),
+      EXPORT + ' function create' + storeType + '(): ' + storeType + ';',
+    ),
+    build(
+      ...getImports(1),
+      EXPORT +
+        ' const create' +
+        storeType +
+        ': typeof create' +
+        storeType +
+        'Decl = () => {',
+      ...getConstants(),
+      `return Object.freeze(${storeInstance});`,
+      '};',
+    ),
+    sharedTableTypes,
+    sharedValueTypes,
+  ];
+};
+
+const getGet = (noun) => GET + noun;
+const getGetAndGetDeps = (noun) =>
+  getParameterList(getGet(noun), getGet(noun) + DEPS);
+const DEBUG_IDS_PROP_TYPE = 'debugIds?: boolean';
+const DEBUG_IDS_PROP = 'debugIds={debugIds}';
+const THEN_DEPS = 'then' + DEPS_SUFFIX;
+const PARAMETER = 'Parameter';
+const GETTER_ARGS = ': (parameter: ' + PARAMETER + ', store: Store) => ';
+const USE_CONTEXT = 'const contextValue = useContext(Context);';
+const BASED_ON_A_PARAMETER = ', based on a parameter';
+const COLON_SPACE = ': ';
+const GENERIC_PARAMETER = '<' + PARAMETER + ',>';
+const PARAMETERIZED_CALLBACK =
+  PARAMETER + 'ized' + CALLBACK + '<' + PARAMETER + '>';
+const ROW_ID = 'rowId';
+const ROW_ID_PROP = 'rowId={rowId}';
+const SEPARATOR_AND_DEBUG_IDS = ', separator, debugIds';
+const SEPARATOR_PROP_TYPE = 'separator?: ReactElement | string';
+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 TYPED_ROW_ID = ROW_ID + COLON_SPACE + ID;
+const VIEW = 'View';
+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 storeProp = storeInstance + `={${storeInstance}}`;
+  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,
+      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`,
+    );
+    return 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,
+    'Store',
+    CALLBACK,
+    PARAMETER + 'ized' + CALLBACK,
+  );
+  addImport(0, tinyBaseUiReact, 'ComponentReturnType');
+  addImport(1, tinyBaseUiReact, 'useCellIds');
+  addImport(null, tinyBaseUiReact, 'ExtraProps');
+  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(
+    PROVIDER + PROPS,
+    getPropTypeList(
+      storeInstance + OPTIONAL_COLON + storeType,
+      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(0, 'react', 'ReactElement', 'ComponentType');
+  addImport(1, 'react', 'React');
+  addImport(1, uiReactModuleDefinition, storeOrStoreIdType, providerPropsType);
+  const storeOrStoreIdParameter =
+    storeOrStoreId + OPTIONAL_COLON + 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)`,
+    ],
+  );
+  const getProps = addInternalFunction(
+    'getProps',
+    'getProps: ((id: any) => ExtraProps) | undefined, id: Id',
+    '(getProps == null) ? ({} as ExtraProps) : getProps(id)',
+  );
+  const wrap = addInternalFunction(
+    'wrap',
+    getParameterList(
+      'children: any',
+      'separator?: any',
+      'encloseWithId?: boolean',
+      'id?: Id',
+    ),
+    [
+      'const separated = separator==null || !Array.isArray(children)',
+      ' ? children',
+      ' : children.map((child, c) => (c > 0 ? [separator, child] : child));',
+      `return encloseWithId ? [id, ':{', separated, '}'] : separated;`,
+    ],
+  );
+  const useCustomOrDefaultCellIds = addInternalFunction(
+    'useCustomOrDefaultCellIds',
+    getParameterList(
+      'customCellIds: Ids | undefined',
+      'tableId: Id',
+      'rowId: Id',
+      `${storeOrStoreId}?: ${storeOrStoreIdType} | undefined`,
+    ),
+    [
+      `const defaultCellIds = ${useHook}(${storeOrStoreId}, useCellIds, [tableId, rowId]);`,
+      'return customCellIds ?? defaultCellIds;',
+    ],
+  );
+  const NullComponent = addConstant('NullComponent', `() => null`);
+  if (!objIsEmpty(tablesSchema)) {
+    const [
+      tablesType,
+      tablesWhenSetType,
+      tableIdType,
+      cellIdType,
+      hasTablesListenerType,
+      tablesListenerType,
+      tableIdsListenerType,
+      hasTableListenerType,
+      tableListenerType,
+      tableCellIdsListenerType,
+      hasTableCellListenerType,
+      rowCountListenerType,
+      rowIdsListenerType,
+      sortedRowIdsListenerType,
+      hasRowListenerType,
+      rowListenerType,
+      cellIdsListenerType,
+      hasCellListenerType,
+      cellListenerType,
+      tablesTypes,
+    ] = sharedTableTypes;
+    addImport(
+      null,
+      moduleDefinition,
+      tablesType,
+      tablesWhenSetType,
+      tableIdType,
+      hasTablesListenerType,
+      tablesListenerType,
+      tableIdsListenerType,
+      hasTableListenerType,
+      tableListenerType,
+      tableCellIdsListenerType,
+      hasTableCellListenerType,
+      rowCountListenerType,
+      rowIdsListenerType,
+      sortedRowIdsListenerType,
+      hasRowListenerType,
+      rowListenerType,
+      cellIdsListenerType,
+      cellListenerType,
+      hasCellListenerType,
+    );
+    addImport(0, moduleDefinition, cellIdType);
+    addImport(1, moduleDefinition, storeType);
+    addImport(null, TINYBASE, IDS, 'IdOrNull');
+    const tableView = addInternalFunction(
+      'tableView',
+      `{${storeInstance}, rowComponent, getRowComponentProps, customCellIds` +
+        SEPARATOR_AND_DEBUG_IDS +
+        '}: any, rowIds: Ids, tableId: Id, defaultRowComponent: React.ComponentType<any>',
+      [
+        'const Row = rowComponent ?? defaultRowComponent;',
+        `return ${wrap}(rowIds.map((rowId) => (`,
+        '<Row',
+        '{...' + getProps + '(getRowComponentProps, rowId)}',
+        'key={rowId}',
+        'tableId={tableId}',
+        ROW_ID_PROP,
+        'customCellIds={customCellIds}',
+        storeProp,
+        DEBUG_IDS_PROP,
+        '/>',
+        '))',
+        SEPARATOR_AND_DEBUG_IDS,
+        ', tableId,',
+        ');',
+      ],
+    );
+    const getDefaultTableComponent = addInternalFunction(
+      'getDefaultTableComponent',
+      'tableId: Id',
+      arrayJoin(
+        mapTablesSchema(
+          (_, tableName, TABLE_ID) =>
+            `tableId == ${TABLE_ID} ? ${tableName}TableView : `,
+        ),
+      ) + NullComponent,
+    );
+    const getDefaultCellComponent = addInternalFunction(
+      'getDefaultCellComponent',
+      'tableId: Id, cellId: Id',
+      arrayJoin(
+        mapTablesSchema(
+          (tableId, tableName, TABLE_ID) =>
+            `tableId == ${TABLE_ID} ? ${
+              arrayJoin(
+                mapCellSchema(
+                  tableId,
+                  (_, _2, _3, CELL_ID, cellName) =>
+                    `cellId == ${CELL_ID} ? ` +
+                    tableName +
+                    cellName +
+                    'CellView : ',
+                ),
+              ) + NullComponent
+            } : `,
+        ),
+      ) + NullComponent,
+    );
+    addProxyHook(
+      HAS + TABLES,
+      HAS + TABLES,
+      BOOLEAN,
+      getTheContentOfTheStoreDoc(1, 0, 0, 1) + AND_REGISTERS,
+    );
+    addProxyHook(
+      TABLES,
+      TABLES,
+      tablesType,
+      getTheContentOfTheStoreDoc(1, 0) + AND_REGISTERS,
+    );
+    const useTableIds = 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 + tablesWhenSetType,
+        getGet(TABLES) + DEPS_SUFFIX,
+      ),
+      getGetAndGetDeps(TABLES),
+      GENERIC_PARAMETER,
+      getParameterList(
+        THEN_PREFIX,
+        `tables: ${tablesWhenSetType})` + 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,
+    );
+    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`,
+        `customCellIds?: ${cellIdType}<TId>[]`,
+        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`,
+        `customCellIds?: CellId<TId>[]`,
+        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`,
+        `customCellIds?: CellId<TId>[]`,
+        SEPARATOR_PROP_TYPE,
+        DEBUG_IDS_PROP_TYPE,
+      ),
+      getPropsDoc(A + 'sorted ' + TABLE),
+      `<TId extends ${tableIdType}>`,
+    );
+    const tablesPropsType = addType(
+      TABLES + PROPS,
+      getPropTypeList(
+        storeInstance + OPTIONAL_COLON + storeType,
+        'tableComponents?: {readonly [TId in ' +
+          tableIdType +
+          `]?: ComponentType<${tablePropsType}<TId>>;}`,
+        `getTableComponentProps?: (tableId: ${tableIdType}) => ExtraProps`,
+        SEPARATOR_PROP_TYPE,
+        DEBUG_IDS_PROP_TYPE,
+      ),
+      getPropsDoc(getTheContentOfDoc(1, 1)),
+    );
+    addImport(
+      1,
+      uiReactModuleDefinition,
+      tablesPropsType,
+      tablePropsType,
+      sortedTablePropsType,
+      rowPropsType,
+      cellPropsType,
+    );
+    addComponent(
+      TABLES + VIEW,
+      '{' +
+        storeInstance +
+        ', tableComponents, getTableComponentProps' +
+        SEPARATOR_AND_DEBUG_IDS +
+        '}: ' +
+        tablesPropsType,
+      [
+        wrap + `(${useTableIds}(${storeInstance}).map((tableId) => {`,
+        'const Table = (tableComponents?.[tableId] ?? ' +
+          getDefaultTableComponent +
+          `(tableId)) as React.ComponentType<TableProps<typeof tableId>>;`,
+        'return <Table',
+        `{...${getProps}(getTableComponentProps, tableId)}`,
+        'tableId={tableId}',
+        'key={tableId}',
+        storeProp,
+        DEBUG_IDS_PROP,
+        '/>;',
+        '}), separator)',
+      ],
+      getTheContentOfTheStoreDoc(1, 13) + AND_REGISTERS,
+    );
+    mapTablesSchema((tableId, tableName, TABLE_ID) => {
+      const [
+        tableType,
+        tableWhenSetType,
+        rowType,
+        rowWhenSetType,
+        cellIdType2,
+      ] = mapGet(tablesTypes, tableId);
+      addImport(
+        null,
+        moduleDefinition,
+        tableType,
+        tableWhenSetType,
+        rowType,
+        rowWhenSetType,
+        cellIdType2,
+      );
+      addProxyHook(
+        HAS + tableName + TABLE,
+        HAS + TABLE,
+        BOOLEAN,
+        getTableContentDoc(tableId, 0, 1) + AND_REGISTERS,
+        EMPTY_STRING,
+        TABLE_ID,
+      );
+      addProxyHook(
+        tableName + TABLE,
+        TABLE,
+        tableType,
+        getTableContentDoc(tableId) + AND_REGISTERS,
+        EMPTY_STRING,
+        TABLE_ID,
+      );
+      addProxyHook(
+        tableName + TABLE + CELL_IDS,
+        TABLE + CELL_IDS,
+        IDS,
+        getIdsDoc(CELL, 'the whole of ' + getTableDoc(tableId)) + AND_REGISTERS,
+        EMPTY_STRING,
+        TABLE_ID,
+      );
+      addProxyHook(
+        tableName + ROW + COUNT,
+        ROW + COUNT,
+        NUMBER,
+        'Gets the number of Rows in ' + getTableDoc(tableId) + AND_REGISTERS,
+        EMPTY_STRING,
+        TABLE_ID,
+      );
+      const useRowIds = addProxyHook(
+        tableName + ROW_IDS,
+        ROW_IDS,
+        IDS,
+        getIdsDoc(ROW, getTableDoc(tableId)) + AND_REGISTERS,
+        EMPTY_STRING,
+        TABLE_ID,
+      );
+      const useSortedRowIds = addProxyHook(
+        tableName + SORTED_ROW_IDS,
+        SORTED_ROW_IDS,
+        IDS,
+        getIdsDoc(ROW, getTableDoc(tableId), 1) + AND_REGISTERS,
+        'cellId?: ' +
+          cellIdType2 +
+          ', descending?: boolean, offset?: number, limit?: number',
+        TABLE_ID + ', cellId, descending, offset, limit',
+      );
+      addProxyHook(
+        HAS + tableName + ROW,
+        HAS + ROW,
+        BOOLEAN,
+        getRowContentDoc(tableId, 0, 1) + AND_REGISTERS,
+        TYPED_ROW_ID,
+        getParameterList(TABLE_ID, ROW_ID),
+      );
+      addProxyHook(
+        tableName + ROW,
+        ROW,
+        rowType,
+        getRowContentDoc(tableId) + AND_REGISTERS,
+        TYPED_ROW_ID,
+        getParameterList(TABLE_ID, ROW_ID),
+      );
+      addProxyHook(
+        tableName + CELL_IDS,
+        CELL_IDS,
+        cellIdType2 + 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 + tableWhenSetType,
+          getGet(TABLE) + DEPS_SUFFIX,
+        ),
+        getParameterList(TABLE_ID, getGetAndGetDeps(TABLE)),
+        GENERIC_PARAMETER,
+        getParameterList(
+          THEN_PREFIX,
+          `table: ${tableWhenSetType})` + 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,
+          ) +
+          ', reuseRowIds?: boolean',
+        THEN_AND_THEN_DEPS_IN_CALL + ', reuseRowIds',
+      );
+      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,
+      );
+      const rowView = addComponent(
+        tableName + ROW + VIEW,
+        '{rowId, ' +
+          storeInstance +
+          ', cellComponents, getCellComponentProps, customCellIds' +
+          SEPARATOR_AND_DEBUG_IDS +
+          `}: ${rowPropsType}<'${tableId}'>`,
+        [
+          wrap +
+            `(${useCustomOrDefaultCellIds}(customCellIds, ` +
+            TABLE_ID +
+            `, rowId, ${storeInstance}).map((cellId: ${cellIdType2}) => {`,
+          'const Cell = (cellComponents?.[cellId] ?? ' +
+            getDefaultCellComponent +
+            `(${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,
+          '/>;',
+          '})' + SEPARATOR_AND_DEBUG_IDS + ', rowId)',
+        ],
+        getRowContentDoc(tableId, 13) + AND_REGISTERS,
+      );
+      addComponent(
+        tableName + 'Sorted' + TABLE + VIEW,
+        '{cellId, descending, offset, limit, ...props}: ' +
+          sortedTablePropsType +
+          `<'${tableId}'>`,
+        tableView +
+          '(props, ' +
+          useSortedRowIds +
+          `(cellId, descending, offset, limit, props.${storeInstance}), ${TABLE_ID}, ${rowView});`,
+        getTableContentDoc(tableId, 13) + ', sorted' + AND_REGISTERS,
+      );
+      addComponent(
+        tableName + TABLE + VIEW,
+        `props: ${tablePropsType}<'${tableId}'>`,
+        tableView +
+          '(props, ' +
+          useRowIds +
+          `(props.${storeInstance}), ${TABLE_ID}, ${rowView});`,
+        getTableContentDoc(tableId, 13) + AND_REGISTERS,
+      );
+      mapCellSchema(
+        tableId,
+        (cellId, type, defaultValue, CELL_ID, cellName) => {
+          const mapCellType = 'Map' + camel(type, 1);
+          addImport(0, moduleDefinition, mapCellType);
+          addImport(1, moduleDefinition, mapCellType);
+          addProxyHook(
+            HAS + tableName + cellName + TABLE + CELL,
+            HAS + TABLE + CELL,
+            BOOLEAN,
+            `Gets ${getHasDoc(1)}the '${cellId}' Cell anywhere in ` +
+              getTableDoc(tableId) +
+              AND_REGISTERS,
+            EMPTY_STRING,
+            getParameterList(TABLE_ID, CELL_ID),
+          );
+          addProxyHook(
+            HAS + tableName + cellName + CELL,
+            HAS + CELL,
+            BOOLEAN,
+            getCellContentDoc(tableId, cellId, 0, 1) + AND_REGISTERS,
+            TYPED_ROW_ID,
+            getParameterList(TABLE_ID, ROW_ID, CELL_ID),
+          );
+          const useCell = 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,
+          );
+          addComponent(
+            tableName + cellName + CELL + VIEW,
+            `{rowId, ${storeInstance}, debugIds}: ` +
+              cellPropsType +
+              `<'${tableId}', '${cellId}'>`,
+            [
+              wrap +
+                `('' + ${useCell}(rowId, ` +
+                storeInstance +
+                `) ?? '', undefined, debugIds, ${CELL_ID})`,
+            ],
+            getCellContentDoc(tableId, cellId, 13) + AND_REGISTERS,
+          );
+        },
+      );
+    });
+    const cellIdsType = arrayJoin(
+      mapTablesSchema(
+        (tableId) => mapGet(tablesTypes, tableId)?.[4] ?? EMPTY_STRING,
+      ),
+      ' | ',
+    );
+    addProxyHook(
+      HAS + TABLES + LISTENER,
+      HAS + TABLES + LISTENER,
+      VOID,
+      getTheContentOfTheStoreDoc(1, 8, 0, 1) + ' changes',
+      getListenerHookParams(hasTablesListenerType),
+      getListenerHookParamsInCall(),
+    );
+    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(
+      HAS + TABLE + LISTENER,
+      HAS + TABLE + LISTENER,
+      VOID,
+      getListenerDoc(3, 0, 0, 1),
+      getListenerHookParams(
+        hasTableListenerType,
+        `tableId: ${tableIdType} | null`,
+      ),
+      getListenerHookParamsInCall('tableId'),
+    );
+    addProxyHook(
+      TABLE + LISTENER,
+      TABLE + LISTENER,
+      VOID,
+      getListenerDoc(3, 0),
+      getListenerHookParams(
+        tableListenerType,
+        `tableId: ${tableIdType} | null`,
+      ),
+      getListenerHookParamsInCall('tableId'),
+    );
+    addProxyHook(
+      TABLE + CELL_IDS + LISTENER,
+      TABLE + CELL_IDS + LISTENER,
+      VOID,
+      getListenerDoc(14, 3, 1),
+      getListenerHookParams(
+        tableCellIdsListenerType,
+        `tableId: ${tableIdType} | null`,
+      ),
+      getListenerHookParamsInCall('tableId'),
+    );
+    addProxyHook(
+      HAS + TABLE + CELL + LISTENER,
+      HAS + TABLE + CELL + LISTENER,
+      VOID,
+      getListenerDoc(16, 3, 0, 1),
+      getListenerHookParams(
+        hasTableCellListenerType,
+        `tableId: ${tableIdType} | null`,
+        `cellId: ${cellIdsType} | null`,
+      ),
+      getListenerHookParamsInCall('tableId', 'cellId'),
+    );
+    addProxyHook(
+      ROW + COUNT + LISTENER,
+      ROW + COUNT + LISTENER,
+      VOID,
+      getListenerDoc(15, 3),
+      getListenerHookParams(
+        rowCountListenerType,
+        `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(
+      HAS + ROW + LISTENER,
+      HAS + ROW + LISTENER,
+      VOID,
+      getListenerDoc(5, 3, 0, 1),
+      getListenerHookParams(
+        hasRowListenerType,
+        `tableId: ${tableIdType} | null`,
+        ROW_ID + `: IdOrNull`,
+      ),
+      getListenerHookParamsInCall('tableId', ROW_ID),
+    );
+    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(
+      HAS + CELL + LISTENER,
+      HAS + CELL + LISTENER,
+      VOID,
+      getListenerDoc(7, 5, 0, 1),
+      getListenerHookParams(
+        hasCellListenerType,
+        `tableId: ${tableIdType} | null`,
+        ROW_ID + `: IdOrNull`,
+        `cellId: ${cellIdsType} | null`,
+      ),
+      getListenerHookParamsInCall('tableId', ROW_ID, 'cellId'),
+    );
+    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,
+      hasValuesListenerType,
+      valuesListenerType,
+      valueIdsListenerType,
+      hasValueListenerType,
+      valueListenerType,
+    ] = sharedValueTypes;
+    addImport(null, moduleDefinition, ...sharedValueTypes);
+    addImport(1, moduleDefinition, storeType);
+    const getDefaultValueComponent = addInternalFunction(
+      'getDefaultValueComponent',
+      'valueId: Id',
+      arrayJoin(
+        mapValuesSchema(
+          (_, _2, _3, VALUE_ID, valueName) =>
+            `valueId == ${VALUE_ID} ? ` + valueName + 'ValueView : ',
+        ),
+      ) + NullComponent,
+    );
+    addProxyHook(
+      HAS + VALUES,
+      HAS + VALUES,
+      BOOLEAN,
+      getTheContentOfTheStoreDoc(2, 0, 0, 1) + AND_REGISTERS,
+    );
+    addProxyHook(
+      VALUES,
+      VALUES,
+      valuesType,
+      getTheContentOfTheStoreDoc(2, 0) + AND_REGISTERS,
+    );
+    const useValueIds = 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,
+    );
+    const valuePropsType = addType(
+      VALUE + PROPS,
+      getPropTypeList(
+        `valueId?: VId`,
+        storeInstance + OPTIONAL_COLON + storeType,
+        DEBUG_IDS_PROP_TYPE,
+      ),
+      getPropsDoc('a Value'),
+      `<VId extends ${valueIdType}>`,
+    );
+    const valuesPropsType = addType(
+      VALUES + PROPS,
+      getPropTypeList(
+        storeInstance + OPTIONAL_COLON + storeType,
+        'valueComponents?: {readonly [VId in ' +
+          valueIdType +
+          `]?: ComponentType<${valuePropsType}<VId>>;}`,
+        `getValueComponentProps?: (valueId: ${valueIdType}) => ExtraProps`,
+        SEPARATOR_PROP_TYPE,
+        DEBUG_IDS_PROP_TYPE,
+      ),
+      getPropsDoc(getTheContentOfDoc(2, 1)),
+    );
+    addImport(1, uiReactModuleDefinition, valuesPropsType, valuePropsType);
+    addComponent(
+      VALUES + VIEW,
+      '{' +
+        storeInstance +
+        ', valueComponents, getValueComponentProps' +
+        SEPARATOR_AND_DEBUG_IDS +
+        '}: ' +
+        valuesPropsType,
+      [
+        wrap + `(${useValueIds}(${storeInstance}).map((valueId) => {`,
+        'const Value = valueComponents?.[valueId] ?? ' +
+          getDefaultValueComponent +
+          '(valueId);',
+        'return <Value',
+        `{...${getProps}(getValueComponentProps, valueId)}`,
+        'key={valueId}',
+        storeProp,
+        DEBUG_IDS_PROP,
+        '/>;',
+        '}), separator)',
+      ],
+      getTheContentOfTheStoreDoc(2, 13) + AND_REGISTERS,
+    );
+    mapValuesSchema((valueId, type, _, VALUE_ID, valueName) => {
+      const mapValueType = 'Map' + camel(type, 1);
+      addImport(0, moduleDefinition, mapValueType);
+      addImport(1, moduleDefinition, mapValueType);
+      addProxyHook(
+        HAS + valueName + VALUE,
+        HAS + VALUE,
+        BOOLEAN,
+        getValueContentDoc(valueId, 0, 1) + AND_REGISTERS,
+        EMPTY_STRING,
+        VALUE_ID,
+      );
+      const useValue = 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,
+      );
+      addComponent(
+        valueName + VALUE + VIEW,
+        `{${storeInstance}, debugIds}: ${valuePropsType}<'${valueId}'>`,
+        [
+          wrap +
+            `('' + ${useValue}(` +
+            storeInstance +
+            `) ?? '', undefined, debugIds, ${VALUE_ID})`,
+        ],
+        getValueContentDoc(valueId, 13) + AND_REGISTERS,
+      );
+    });
+    addProxyHook(
+      HAS + VALUES + LISTENER,
+      HAS + VALUES + LISTENER,
+      VOID,
+      getTheContentOfTheStoreDoc(2, 8, 0, 1) + ' changes',
+      getListenerHookParams(hasValuesListenerType),
+      getListenerHookParamsInCall(),
+    );
+    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(
+      HAS + VALUE + LISTENER,
+      HAS + VALUE + LISTENER,
+      VOID,
+      getListenerDoc(11, 0, 0, 1),
+      getListenerHookParams(
+        hasValueListenerType,
+        `valueId: ${valueIdType} | null`,
+      ),
+      getListenerHookParamsInCall('valueId'),
+    );
+    addProxyHook(
+      VALUE + LISTENER,
+      VALUE + LISTENER,
+      VOID,
+      getListenerDoc(11, 0),
+      getListenerHookParams(
+        valueListenerType,
+        `valueId: ${valueIdType} | null`,
+      ),
+      getListenerHookParamsInCall('valueId'),
+    );
+  }
+  addComponent(
+    PROVIDER,
+    `{${storeInstance}, ${storeInstance}ById, children}: ` +
+      providerPropsType +
+      ' & {readonly 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,
+    ),
+  ];
+};
+
+const jsonParse = JSON.parse;
+
+const PRETTIER = 'prettier/';
+const PRETTIER_PLUGINS = PRETTIER + 'plugins/';
+const prettierConfig = {
+  parser: 'typescript',
+  singleQuote: true,
+  trailingComma: 'all',
+  bracketSpacing: false,
+  jsdocSingleLineComment: false,
+};
+const createTools = getCreateFunction((store) => {
+  const getStoreStats = (detail) => {
+    let totalTables = 0;
+    let totalRows = 0;
+    let totalCells = 0;
+    const tables = {};
+    store.forEachTable((tableId, forEachRow) => {
+      totalTables++;
+      let tableRows = 0;
+      let tableCells = 0;
+      const rows = {};
+      forEachRow((rowId, forEachCell) => {
+        tableRows++;
+        let rowCells = 0;
+        forEachCell(() => rowCells++);
+        tableCells += rowCells;
+        if (detail) {
+          rows[rowId] = {rowCells};
+        }
+      });
+      totalRows += tableRows;
+      totalCells += tableCells;
+      if (detail) {
+        tables[tableId] = {tableRows, tableCells, rows};
+      }
+    });
+    return {
+      totalTables,
+      totalRows,
+      totalCells,
+      totalValues: size(store.getValueIds()),
+      jsonLength: size(store.getJson()),
+      ...(detail ? {detail: {tables}} : {}),
+    };
+  };
+  const getStoreTablesSchema = () => {
+    const tablesSchema = jsonParse(store.getTablesSchemaJson());
+    if (
+      !objIsEmpty(tablesSchema) ||
+      arrayEvery(store.getTableIds(), (tableId) => {
+        const rowIds = store.getRowIds(tableId);
+        const cellsMeta = mapNew();
+        if (
+          arrayEvery(rowIds, (rowId) =>
+            arrayEvery(store.getCellIds(tableId, rowId), (cellId) => {
+              const value = store.getCell(tableId, rowId, cellId);
+              const cellMeta = mapEnsure(cellsMeta, cellId, () => [
+                getCellOrValueType(value),
+                mapNew(),
+                [0],
+                0,
+              ]);
+              const [type, values, [maxCount]] = cellMeta;
+              const count = mapEnsure(values, value, () => 0) + 1;
+              if (count > maxCount) {
+                cellMeta[2] = [count, value];
+              }
+              mapSet(values, value, count);
+              cellMeta[3]++;
+              return type == getCellOrValueType(value);
+            }),
+          )
+        ) {
+          tablesSchema[tableId] = {};
+          collForEach(cellsMeta, ([type, , [, maxValue], count], cellId) => {
+            tablesSchema[tableId][cellId] = {
+              [TYPE]: type,
+              ...(count == size(rowIds) ? {[DEFAULT]: maxValue} : {}),
+            };
+          });
+          return 1;
+        }
+      })
+    ) {
+      return tablesSchema;
+    }
+    return {};
+  };
+  const getStoreValuesSchema = () => {
+    const valuesSchema = jsonParse(store.getValuesSchemaJson());
+    if (objIsEmpty(valuesSchema)) {
+      store.forEachValue((valueId, value) => {
+        valuesSchema[valueId] = {
+          [TYPE]: getCellOrValueType(value),
+        };
+      });
+    }
+    return valuesSchema;
+  };
+  const getStoreApi$1 = (module) =>
+    getStoreApi(getStoreTablesSchema(), getStoreValuesSchema(), module);
+  const getPrettyStoreApi = async (module) => {
+    const extensions = ['d.ts', 'ts', 'd.ts', 'tsx'];
+    const plugins = [];
+    let format;
+    try {
+      format = (await import(PRETTIER + 'standalone')).format;
+      arrayPush(
+        plugins,
+        await import(PRETTIER_PLUGINS + 'estree'),
+        await import(PRETTIER_PLUGINS + 'typescript'),
+      );
+    } catch (e) {
+      format = async (str) => str;
+    }
+    return await promiseAll(
+      arrayMap(getStoreApi$1(module), async (file, f) =>
+        formatJsDoc(
+          await format(file, {
+            ...prettierConfig,
+            plugins,
+            filepath: `_.${extensions[f]}`,
+          }),
+        ),
+      ),
+    );
+  };
+  const getStore = () => store;
+  const tools = {
+    getStoreStats,
+    getStoreTablesSchema,
+    getStoreValuesSchema,
+    getStoreApi: getStoreApi$1,
+    getPrettyStoreApi,
+    getStore,
+  };
+  return objFreeze(tools);
+});
+
+export {createTools};