@dereekb/firebase 10.2.0 → 11.0.1

package/index.cjs.js

@@ -13,47 +13,6 @@ var storage = require('firebase/storage');
 var classTransformer = require('class-transformer');
 var classValidator = require('class-validator');
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-function __metadata(metadataKey, metadataValue) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
-}
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 var check = function (it) {
@@ -2276,6 +2235,7 @@ $$5({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
  */
 class AbstractFirestoreDocumentDataAccessorWrapper {
   constructor(accessor) {
+    this.accessor = void 0;
     this.accessor = accessor;
   }
   get documentRef() {
@@ -2398,6 +2358,9 @@ $$4({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }
 class ModifyBeforeSetFirestoreDocumentDataAccessorWrapper extends AbstractFirestoreDocumentDataAccessorWrapper {
   constructor(accessor, config) {
     super(accessor);
+    this.config = void 0;
+    this.modifier = void 0;
+    this.set = void 0;
     this.config = config;
     const when = config.when;
     this.modifier = util.mergeModifiers(util.asArray(config.modifier));
@@ -2498,6 +2461,28 @@ function copyUserRelatedDataAccessorFactoryFunction() {
 }
 
 // MARK: Utility
+
+function _await$a(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function _async$a(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
 exports.FirestoreAccessorStreamMode = void 0;
 (function (FirestoreAccessorStreamMode) {
   /**
@@ -2558,15 +2543,13 @@ function mapDataFromSnapshot(options) {
  * @returns
  */
 function updateWithAccessorUpdateAndConverterFunction(accessor, converter) {
-  return (data, params) => __awaiter(this, void 0, void 0, function* () {
+  return _async$a(function (data, params) {
     const updateInput = util.filterUndefinedValues(data);
     const updateData = converter.toFirestore(updateInput, {
       merge: true
     }); // treat it as a merge
     // Only update
-    if (!util.objectHasNoKeys(updateData)) {
-      return params != null ? accessor.update(updateData, params) : accessor.update(updateData);
-    }
+    return util.objectHasNoKeys(updateData) ? _await$a() : params != null ? accessor.update(updateData, params) : accessor.update(updateData);
   });
 }
 
@@ -2588,13 +2571,33 @@ exports.FirestoreDocumentContextType = void 0;
  * @param accessor
  * @returns
  */
+
+function _await$9(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function _async$9(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
 function incrementUpdateWithAccessorFunction(accessor) {
-  return data => __awaiter(this, void 0, void 0, function* () {
+  return _async$9(function (data) {
     const updateData = util.filterFalsyAndEmptyValues(data);
     // Only update
-    if (!util.objectHasNoKeys(updateData)) {
-      return accessor.increment(updateData);
-    }
+    return util.objectHasNoKeys(updateData) ? _await$9() : accessor.increment(updateData);
   });
 }
 
@@ -2604,10 +2607,12 @@ function incrementUpdateWithAccessorFunction(accessor) {
  */
 class AbstractFirestoreDocument {
   constructor(accessor, documentAccessor) {
-    this.accessor = accessor;
-    this.documentAccessor = documentAccessor;
+    this.accessor = void 0;
+    this.documentAccessor = void 0;
     this.stream$ = rxjs$1.lazyFrom(() => this.accessor.stream());
     this.data$ = rxjs$1.lazyFrom(() => dataFromSnapshotStream(this.stream$));
+    this.accessor = accessor;
+    this.documentAccessor = documentAccessor;
   }
   get modelType() {
     return this.modelIdentity.modelType;
@@ -2714,11 +2719,11 @@ function limitedFirestoreDocumentAccessorFactory(config) {
   } = config;
   const expectedCollectionName = firestoreAccessorDriver.fuzzedPathForPath ? firestoreAccessorDriver.fuzzedPathForPath(modelIdentity.collectionName) : modelIdentity.collectionName;
   const converterFactory = inputConverterFactory ? ref => {
-    var _a;
-    return ref ? (_a = inputConverterFactory(ref)) !== null && _a !== void 0 ? _a : inputDefaultConverter : inputDefaultConverter;
+    var _inputConverterFactor;
+    return ref ? (_inputConverterFactor = inputConverterFactory(ref)) != null ? _inputConverterFactor : inputDefaultConverter : inputDefaultConverter;
   } : () => inputDefaultConverter;
   const result = context => {
-    const databaseContext = context !== null && context !== void 0 ? context : config.firestoreAccessorDriver.defaultContextFactory();
+    const databaseContext = context != null ? context : config.firestoreAccessorDriver.defaultContextFactory();
     const dataAccessorFactory = interceptAccessorFactory ? interceptAccessorFactory(databaseContext.accessorFactory) : databaseContext.accessorFactory;
     function loadDocument(ref) {
       if (!ref) {
@@ -2729,9 +2734,9 @@ function limitedFirestoreDocumentAccessorFactory(config) {
       return makeDocument(accessor, documentAccessor);
     }
     function documentRefForKey(fullPath) {
-      var _a;
+      var _ref$parent;
       const ref = firestoreAccessorDriver.docAtPath(firestoreContext.firestore, fullPath);
-      if (((_a = ref.parent) === null || _a === void 0 ? void 0 : _a.id) !== expectedCollectionName) {
+      if (((_ref$parent = ref.parent) == null ? void 0 : _ref$parent.id) !== expectedCollectionName) {
         throw new Error(`unexpected key/path "${fullPath}" for expected type "${modelIdentity.collectionName}"/"${modelIdentity.modelType}".`);
       }
       const converter = converterFactory(ref);
@@ -2851,6 +2856,56 @@ function extendFirestoreCollectionWithSingleDocumentAccessor(x, singleItemIdenti
   x.loadDocumentForWriteBatch = singleAccessor.loadDocumentForWriteBatch;
 }
 
+/**
+ * MappedUseAsyncFunction to load a snapshot from the input document and use it.
+ *
+ * @param document
+ * @param use
+ * @param defaultValue
+ * @returns
+ */
+
+function _empty$3() {} /**
+                      * MappedUseAsyncFunction to load snapshot data from the input document and use it.
+                      */
+function _awaitIgnored$2(value, direct) {
+  if (!direct) {
+    return value && value.then ? value.then(_empty$3) : Promise.resolve();
+  }
+}
+function _invoke$3(body, then) {
+  var result = body();
+  if (result && result.then) {
+    return result.then(then);
+  }
+  return then(result);
+}
+function _await$8(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function _async$8(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
+const useDocumentSnapshot = _async$8(function (document, use, defaultValue) {
+  return _await$8(document == null ? void 0 : document.accessor.get(), function (snapshot) {
+    return util.useAsync(snapshot, use, defaultValue);
+  });
+});
 function newDocuments(documentAccessor, count) {
   return util.makeWithFactory(() => documentAccessor.newDocument(), count);
 }
@@ -2862,17 +2917,21 @@ function newDocuments(documentAccessor, count) {
  * @returns
  */
 function makeDocuments(documentAccessor, make) {
-  var _a;
-  const newDocumentFn = (_a = make.newDocument) !== null && _a !== void 0 ? _a : () => documentAccessor.newDocument();
+  var _make$newDocument;
+  const newDocumentFn = (_make$newDocument = make.newDocument) != null ? _make$newDocument : () => documentAccessor.newDocument();
   return util.performMakeLoop({
     count: make.count,
-    make: i => __awaiter(this, void 0, void 0, function* () {
+    make: _async$8(function (i) {
       const document = newDocumentFn(documentAccessor);
-      const data = yield make.init(i, document);
-      if (data != null) {
-        yield document.accessor.create(data);
-      }
-      return document;
+      return _await$8(make.init(i, document), function (data) {
+        return _invoke$3(function () {
+          if (data != null) {
+            return _awaitIgnored$2(document.accessor.create(data));
+          }
+        }, function () {
+          return document;
+        });
+      });
     })
   });
 }
@@ -3028,23 +3087,6 @@ function setIdAndKeyFromKeyIdRefOnDocumentData(data, modelRef) {
   target.key = modelRef.key; // set the path/key on data
   return target;
 }
-/**
- * MappedUseAsyncFunction to load a snapshot from the input document and use it.
- *
- * @param document
- * @param use
- * @param defaultValue
- * @returns
- */
-function useDocumentSnapshot(document, use, defaultValue) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const snapshot = yield document === null || document === void 0 ? void 0 : document.accessor.get();
-    return util.useAsync(snapshot, use, defaultValue);
-  });
-}
-/**
- * MappedUseAsyncFunction to load snapshot data from the input document and use it.
- */
 const useDocumentSnapshotData = util.wrapUseAsyncFunction(useDocumentSnapshot, x => x.data());
 // MARK: Key Accessors
 function firestoreModelIdFromDocument(document) {
@@ -3184,7 +3226,7 @@ function snapshotConverterFunctions(config) {
         };
       }
       if (mergeFields) {
-        toOptions = Object.assign(Object.assign({}, toOptions), {
+        toOptions = Object.assign({}, toOptions, {
           fields: asTopLevelFieldPaths(mergeFields)
         });
       }
@@ -3675,7 +3717,7 @@ handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
 const FIRESTORE_EMPTY_VALUE = null;
 
 function firestoreField(config) {
-  var _a;
+  var _config$defaultBefore;
   return {
     from: config.default != null ? {
       default: util.asObjectCopyFactory(config.default),
@@ -3685,7 +3727,7 @@ function firestoreField(config) {
       convert: config.fromData
     },
     to: {
-      default: (_a = config.defaultBeforeSave) !== null && _a !== void 0 ? _a : FIRESTORE_EMPTY_VALUE,
+      default: (_config$defaultBefore = config.defaultBeforeSave) != null ? _config$defaultBefore : FIRESTORE_EMPTY_VALUE,
       convert: config.toData
     }
   };
@@ -3701,7 +3743,7 @@ function firestorePassThroughField() {
 function optionalFirestoreField(config) {
   // NOTE: Typings for this function internally is weird due to the support for both the one and two type transforms.
   if (config) {
-    const inputConfig = config !== null && config !== void 0 ? config : {};
+    const inputConfig = config != null ? config : {};
     const {
       dontStoreDefaultReadValue,
       dontStoreValueIf: inputDontStoreValueIf,
@@ -3714,9 +3756,9 @@ function optionalFirestoreField(config) {
       transformFromData,
       transformToData
     } = inputConfig;
-    const transformData = inputTransformData !== null && inputTransformData !== void 0 ? inputTransformData : util.passThrough;
-    const transformFrom = transformFromData !== null && transformFromData !== void 0 ? transformFromData : transformData;
-    const baseTransformTo = transformToData !== null && transformToData !== void 0 ? transformToData : transformData;
+    const transformData = inputTransformData != null ? inputTransformData : util.passThrough;
+    const transformFrom = transformFromData != null ? transformFromData : transformData;
+    const baseTransformTo = transformToData != null ? transformToData : transformData;
     const dontStoreValueIf = inputDontStoreValueIf != null ? util.isEqualToValueDecisionFunction(inputDontStoreValueIf) : null;
     const transformTo = dontStoreValueIf != null ? value => {
       const dontStoreCheck = dontStoreValueIf(value);
@@ -3759,8 +3801,8 @@ function optionalFirestoreField(config) {
       };
     } else {
       toData = x => {
-        var _a;
-        return x != null ? (_a = transformTo(x)) !== null && _a !== void 0 ? _a : null : x;
+        var _transformTo;
+        return x != null ? (_transformTo = transformTo(x)) != null ? _transformTo : null : x;
       };
     }
     return firestoreField({
@@ -3774,24 +3816,24 @@ function optionalFirestoreField(config) {
 }
 const DEFAULT_FIRESTORE_STRING_FIELD_VALUE = '';
 function firestoreString(config) {
-  const transform = util.transformStringFunctionConfig(config === null || config === void 0 ? void 0 : config.transform);
+  const transform = util.transformStringFunctionConfig(config == null ? void 0 : config.transform);
   const transformData = transform ? util.transformStringFunction(transform) : util.passThrough;
-  return firestoreField(Object.assign(Object.assign({
+  return firestoreField(Object.assign({
     default: DEFAULT_FIRESTORE_STRING_FIELD_VALUE
-  }, config), {
+  }, config, {
     fromData: transformData,
     toData: transformData
   }));
 }
 function optionalFirestoreString(config) {
-  const transform = util.transformStringFunctionConfig(config === null || config === void 0 ? void 0 : config.transform);
+  const transform = util.transformStringFunctionConfig(config == null ? void 0 : config.transform);
   const transformData = transform ? util.transformStringFunction(transform) : util.passThrough;
-  return optionalFirestoreField(Object.assign(Object.assign({}, config), {
+  return optionalFirestoreField(Object.assign({}, config, {
     transformData
   }));
 }
 function firestoreEnum(config) {
-  return firestoreField(Object.assign(Object.assign({}, config), {
+  return firestoreField(Object.assign({}, config, {
     fromData: util.passThrough,
     toData: util.passThrough
   }));
@@ -3810,22 +3852,22 @@ function optionalFirestoreUID() {
 const firestoreModelKeyString = firestoreString();
 const firestoreModelIdString = firestoreString();
 function firestoreDate(config = {}) {
-  var _a, _b;
+  var _config$default, _config$defaultBefore2;
   return firestoreField({
-    default: (_a = config.default) !== null && _a !== void 0 ? _a : () => new Date(),
-    defaultBeforeSave: (_b = config.defaultBeforeSave) !== null && _b !== void 0 ? _b : config.saveDefaultAsNow ? date.formatToISO8601DateString : null,
+    default: (_config$default = config.default) != null ? _config$default : () => new Date(),
+    defaultBeforeSave: (_config$defaultBefore2 = config.defaultBeforeSave) != null ? _config$defaultBefore2 : config.saveDefaultAsNow ? date.formatToISO8601DateString : null,
     fromData: input => date.toJsDate(input),
     toData: input => date.toISODateString(input)
   });
 }
 function optionalFirestoreDate(config) {
-  const inputDontStoreValueIf = config === null || config === void 0 ? void 0 : config.dontStoreValueIf;
+  const inputDontStoreValueIf = config == null ? void 0 : config.dontStoreValueIf;
   let dontStoreValueIf = inputDontStoreValueIf;
   if (dontStoreValueIf != null && util.isDate(dontStoreValueIf)) {
     const comparisonDate = dontStoreValueIf;
     dontStoreValueIf = x => date.isSameDate(x, comparisonDate);
   }
-  return optionalFirestoreField(Object.assign(Object.assign({}, config), {
+  return optionalFirestoreField(Object.assign({}, config, {
     dontStoreValueIf,
     transformFromData: input => {
       return date.toJsDate(input);
@@ -3846,41 +3888,41 @@ function optionalFirestoreBoolean(config) {
   return optionalFirestoreField(config);
 }
 function firestoreNumber(config) {
-  var _a;
-  const transform = (config === null || config === void 0 ? void 0 : config.transform) ? typeof config.transform === 'function' ? {
-    transform: config === null || config === void 0 ? void 0 : config.transform
-  } : config === null || config === void 0 ? void 0 : config.transform : undefined;
+  var _config$defaultBefore3;
+  const transform = config != null && config.transform ? typeof config.transform === 'function' ? {
+    transform: config == null ? void 0 : config.transform
+  } : config == null ? void 0 : config.transform : undefined;
   const transformData = transform ? util.transformNumberFunction(transform) : util.passThrough;
-  return firestoreField(Object.assign(Object.assign({}, config), {
-    defaultBeforeSave: ((_a = config.defaultBeforeSave) !== null && _a !== void 0 ? _a : config.saveDefault) ? config.default : undefined,
+  return firestoreField(Object.assign({}, config, {
+    defaultBeforeSave: ((_config$defaultBefore3 = config.defaultBeforeSave) != null ? _config$defaultBefore3 : config.saveDefault) ? config.default : undefined,
     fromData: transformData,
     toData: transformData
   }));
 }
 function optionalFirestoreNumber(config) {
-  const transform = (config === null || config === void 0 ? void 0 : config.transform) ? typeof config.transform === 'function' ? {
-    transform: config === null || config === void 0 ? void 0 : config.transform
-  } : config === null || config === void 0 ? void 0 : config.transform : undefined;
+  const transform = config != null && config.transform ? typeof config.transform === 'function' ? {
+    transform: config == null ? void 0 : config.transform
+  } : config == null ? void 0 : config.transform : undefined;
   const transformData = transform ? util.transformNumberFunction(transform) : util.passThrough;
-  return optionalFirestoreField(Object.assign(Object.assign({}, config), {
+  return optionalFirestoreField(Object.assign({}, config, {
     transformData
   }));
 }
 function firestoreArray(config) {
-  var _a;
+  var _config$default2;
   const sortFn = util.sortValuesFunctionOrMapIdentityWithSortRef(config);
   return firestoreField({
-    default: (_a = config.default) !== null && _a !== void 0 ? _a : () => [],
+    default: (_config$default2 = config.default) != null ? _config$default2 : () => [],
     defaultBeforeSave: config.defaultBeforeSave,
     fromData: x => sortFn(x, false),
     toData: x => sortFn(x, true)
   });
 }
 function optionalFirestoreArray(config) {
-  var _a;
+  var _config$dontStoreIfEm;
   const sortFn = util.sortValuesFunctionOrMapIdentityWithSortRef(config);
-  const inputDontStoreIf = config === null || config === void 0 ? void 0 : config.dontStoreIf;
-  const shouldNotStoreIfEmpty = (_a = config === null || config === void 0 ? void 0 : config.dontStoreIfEmpty) !== null && _a !== void 0 ? _a : false;
+  const inputDontStoreIf = config == null ? void 0 : config.dontStoreIf;
+  const shouldNotStoreIfEmpty = (_config$dontStoreIfEm = config == null ? void 0 : config.dontStoreIfEmpty) != null ? _config$dontStoreIfEm : false;
   let dontStoreIf;
   if (inputDontStoreIf != null) {
     dontStoreIf = shouldNotStoreIfEmpty ? x => x.length === 0 || inputDontStoreIf(x) : inputDontStoreIf;
@@ -3889,35 +3931,35 @@ function optionalFirestoreArray(config) {
       return x.length === 0;
     } : undefined;
   }
-  const inputFilterUnique = (config === null || config === void 0 ? void 0 : config.filterUnique) === true ? util.unique : config === null || config === void 0 ? void 0 : config.filterUnique;
+  const inputFilterUnique = (config == null ? void 0 : config.filterUnique) === true ? util.unique : config == null ? void 0 : config.filterUnique;
   const filterUniqueValuesFn = inputFilterUnique != null ? x => {
     const result = inputFilterUnique(x);
     return result;
   } : undefined;
-  const inputTransformData = config === null || config === void 0 ? void 0 : config.transformData;
+  const inputTransformData = config == null ? void 0 : config.transformData;
   const sortArrayFn = util.isMapIdentityFunction(sortFn) ? undefined : x => sortFn(x, true);
   const transformData = util.chainMapSameFunctions([filterUniqueValuesFn, inputTransformData, sortArrayFn]);
-  return optionalFirestoreField(Object.assign(Object.assign({}, config), {
+  return optionalFirestoreField(Object.assign({}, config, {
     dontStoreIf,
     transformData
   }));
 }
 function firestoreUniqueArray(config) {
-  var _a;
+  var _config$default3;
   const {
     filterUnique: inputFilterUnique
   } = config;
   const filterUnique = inputFilterUnique === true ? util.unique : inputFilterUnique;
   const sortFn = util.sortValuesFunctionOrMapIdentityWithSortRef(config);
   return firestoreField({
-    default: (_a = config.default) !== null && _a !== void 0 ? _a : () => [],
+    default: (_config$default3 = config.default) != null ? _config$default3 : () => [],
     defaultBeforeSave: config.defaultBeforeSave,
     fromData: x => sortFn(filterUnique(x), false),
     toData: x => sortFn(filterUnique(x), true)
   });
 }
 function firestoreUniqueKeyedArray(config) {
-  return firestoreUniqueArray(Object.assign(Object.assign({}, config), {
+  return firestoreUniqueArray(Object.assign({}, config, {
     filterUnique: util.filterUniqueFunction(config.readKey)
   }));
 }
@@ -3928,20 +3970,20 @@ function firestoreUniqueKeyedArray(config) {
  * @returns
  */
 function firestoreEnumArray(config = {}) {
-  return firestoreUniqueArray(Object.assign(Object.assign({}, config), {
+  return firestoreUniqueArray(Object.assign({}, config, {
     filterUnique: util.unique
   }));
 }
 function firestoreUniqueStringArray(config) {
   const filterUnique = config != null ? util.filterUniqueTransform(config) : util.unique;
-  return firestoreUniqueArray(Object.assign(Object.assign({}, config), {
+  return firestoreUniqueArray(Object.assign({}, config, {
     filterUnique: filterUnique
   }));
 }
 const firestoreModelKeyArrayField = firestoreUniqueStringArray({});
 const firestoreModelIdArrayField = firestoreModelKeyArrayField;
 function firestoreUniqueNumberArray(config) {
-  return firestoreUniqueArray(Object.assign(Object.assign({}, config), {
+  return firestoreUniqueArray(Object.assign({}, config, {
     filterUnique: util.unique
   }));
 }
@@ -3952,14 +3994,14 @@ function firestoreUniqueNumberArray(config) {
  * @returns
  */
 function firestoreEncodedArray(config) {
-  var _a;
+  var _config$default4;
   const {
     fromData,
     toData
   } = config.convert;
   const sortFn = util.sortValuesFunctionOrMapIdentityWithSortRef(config);
   return firestoreField({
-    default: (_a = config.default) !== null && _a !== void 0 ? _a : () => [],
+    default: (_config$default4 = config.default) != null ? _config$default4 : () => [],
     defaultBeforeSave: config.defaultBeforeSave,
     fromData: input => sortFn(input.map(fromData), false),
     toData: input => util.filterMaybeValues(sortFn(input, true).map(toData))
@@ -3972,12 +4014,12 @@ function firestoreEncodedArray(config) {
  * @returns
  */
 function firestoreDencoderArray(config) {
-  var _a;
+  var _config$default5;
   const {
     dencoder
   } = config;
   return firestoreField({
-    default: (_a = config.default) !== null && _a !== void 0 ? _a : () => [],
+    default: (_config$default5 = config.default) != null ? _config$default5 : () => [],
     defaultBeforeSave: config.defaultBeforeSave,
     fromData: input => dencoder(input),
     toData: input => dencoder(input)
@@ -3990,12 +4032,12 @@ function firestoreDencoderArray(config) {
  * @returns
  */
 function firestoreDencoderStringArray(config) {
-  var _a;
+  var _config$default6;
   const {
     dencoder
   } = config;
   return firestoreField({
-    default: (_a = config.default) !== null && _a !== void 0 ? _a : () => [],
+    default: (_config$default6 = config.default) != null ? _config$default6 : () => [],
     defaultBeforeSave: config.defaultBeforeSave,
     fromData: input => dencoder(input),
     toData: input => dencoder(input)
@@ -4010,7 +4052,7 @@ function firestoreDencoderStringArray(config) {
  * @returns
  */
 function firestoreMap(config = {}) {
-  var _a;
+  var _config$default7;
   const {
     mapFilter: filter = util.KeyValueTypleValueFilter.NULL,
     mapFieldValues
@@ -4021,7 +4063,7 @@ function firestoreMap(config = {}) {
   });
   const makeCopy = mapFieldValues ? util.mapObjectMapFunction(mapFieldValues) : util.copyObject;
   return firestoreField({
-    default: (_a = config.default) !== null && _a !== void 0 ? _a : () => ({}),
+    default: (_config$default7 = config.default) != null ? _config$default7 : () => ({}),
     fromData: util.passThrough,
     toData: model => {
       const copy = makeCopy(model);
@@ -4054,7 +4096,7 @@ const firestoreModelIdGrantedRoleMap = firestoreModelKeyGrantedRoleMap;
  * @returns
  */
 function firestoreEncodedObjectMap(config) {
-  var _a;
+  var _config$default8;
   const {
     mapFilter: filter = util.KeyValueTypleValueFilter.EMPTY,
     encoder,
@@ -4065,7 +4107,7 @@ function firestoreEncodedObjectMap(config) {
     filter
   });
   return firestoreField({
-    default: (_a = config.default) !== null && _a !== void 0 ? _a : () => ({}),
+    default: (_config$default8 = config.default) != null ? _config$default8 : () => ({}),
     fromData: input => {
       const copy = util.copyObject(input);
       const result = util.mapObjectMap(copy, decoder);
@@ -4090,7 +4132,7 @@ function firestoreDencoderMap(config) {
   const {
     dencoder
   } = config;
-  return firestoreEncodedObjectMap(Object.assign(Object.assign({}, config), {
+  return firestoreEncodedObjectMap(Object.assign({}, config, {
     encoder: dencoder,
     decoder: dencoder
   }));
@@ -4140,17 +4182,30 @@ function firestoreFieldConfigToModelMapFunctionsRef(config) {
  * @returns
  */
 function firestoreObjectArray(config) {
-  var _a, _b;
+  var _config$objectField, _config$default9;
   const {
-    filterUnique: inputFilterUnique
+    filterUnique: inputFilterUnique,
+    filter: filterFn
   } = config;
-  const filterUnique = inputFilterUnique !== null && inputFilterUnique !== void 0 ? inputFilterUnique : util.MAP_IDENTITY;
-  const objectField = (_a = config.objectField) !== null && _a !== void 0 ? _a : firestoreFieldConfigToModelMapFunctionsRef(config.firestoreField);
+  const objectField = (_config$objectField = config.objectField) != null ? _config$objectField : firestoreFieldConfigToModelMapFunctionsRef(config.firestoreField);
   const sortFn = util.sortValuesFunctionOrMapIdentityWithSortRef(config);
   const {
     from,
     to: baseTo
   } = util.toModelMapFunctions(objectField);
+  let performFiltering;
+  if (inputFilterUnique != null ? inputFilterUnique : filterFn) {
+    const filterUnique = inputFilterUnique != null ? inputFilterUnique : util.MAP_IDENTITY;
+    performFiltering = x => {
+      let result = filterUnique(x);
+      if (filterFn) {
+        result = result.filter(filterFn);
+      }
+      return result;
+    };
+  } else {
+    performFiltering = util.MAP_IDENTITY;
+  }
   const to = x => {
     // remove null/undefined values from each field when converting to in order to mirror firestore usage (undefined is treated like null)
     const base = baseTo(x);
@@ -4158,27 +4213,27 @@ function firestoreObjectArray(config) {
     return nullishfilteredOut;
   };
   return firestoreField({
-    default: (_b = config.default) !== null && _b !== void 0 ? _b : () => [],
+    default: (_config$default9 = config.default) != null ? _config$default9 : () => [],
     defaultBeforeSave: config.defaultBeforeSave,
-    fromData: input => sortFn(filterUnique(input.map(x => from(x))), false),
-    toData: input => util.filterMaybeValues(sortFn(filterUnique(input), true)).map(x => to(x)) // filter then sort then map
+    fromData: input => sortFn(performFiltering(input.map(x => from(x))), false),
+    toData: input => util.filterMaybeValues(sortFn(performFiltering(input), true)).map(x => to(x)) // filter then sort then map
   });
 }
 /**
  * A nested object field that uses other FirestoreFieldConfig configurations to map a field.
  */
 function firestoreSubObject(config) {
-  var _a, _b;
+  var _config$defaultBefore4, _config$default10;
   const mapFunctions = util.toModelMapFunctions(config.objectField);
   const {
     from: fromData,
     to: toData
   } = mapFunctions;
   const defaultWithFields = () => fromData({});
-  const defaultBeforeSave = (_a = config.defaultBeforeSave) !== null && _a !== void 0 ? _a : config.saveDefaultObject ? () => toData({}) : null;
+  const defaultBeforeSave = (_config$defaultBefore4 = config.defaultBeforeSave) != null ? _config$defaultBefore4 : config.saveDefaultObject ? () => toData({}) : null;
   const mapFunctionsConfig = util.build({
     base: firestoreField({
-      default: (_b = config.default) !== null && _b !== void 0 ? _b : defaultWithFields,
+      default: (_config$default10 = config.default) != null ? _config$default10 : defaultWithFields,
       defaultBeforeSave,
       fromData,
       toData
@@ -4203,7 +4258,7 @@ function firestoreLatLngString(config) {
     default: defaultValue,
     defaultBeforeSave,
     precision
-  } = config !== null && config !== void 0 ? config : {};
+  } = config != null ? config : {};
   const transform = util.latLngStringFunction({
     precision,
     wrap: false,
@@ -4224,7 +4279,7 @@ function firestoreTimezoneString(config) {
   const {
     default: defaultValue,
     defaultBeforeSave
-  } = config !== null && config !== void 0 ? config : {};
+  } = config != null ? config : {};
   return firestoreString({
     default: defaultValue || util.DEFAULT_LAT_LNG_STRING_VALUE,
     defaultBeforeSave
@@ -4388,18 +4443,18 @@ const firestoreMapZoomLevel = firestoreNumber({
 });
 function firestoreBitwiseSet(config) {
   const dencoder = util.bitwiseSetDencoder(config.maxIndex);
-  return firestoreField(Object.assign(Object.assign({
+  return firestoreField(Object.assign({
     default: () => new Set()
-  }, config), {
+  }, config, {
     fromData: dencoder,
     toData: dencoder
   }));
 }
 function firestoreBitwiseSetMap(config) {
   const dencoder = util.bitwiseSetDencoder(config.maxIndex);
-  return firestoreEncodedObjectMap(Object.assign(Object.assign({
+  return firestoreEncodedObjectMap(Object.assign({
     mapFilter: util.KeyValueTypleValueFilter.FALSY
-  }, config), {
+  }, config, {
     encoder: dencoder,
     decoder: dencoder
   }));
@@ -4408,16 +4463,16 @@ function firestoreBitwiseObjectMap(config) {
   const {
     dencoder
   } = config;
-  return firestoreEncodedObjectMap(Object.assign(Object.assign({
+  return firestoreEncodedObjectMap(Object.assign({
     mapFilter: util.KeyValueTypleValueFilter.FALSY
-  }, config), {
+  }, config, {
     encoder: dencoder,
     decoder: dencoder
   }));
 }
 
 function unsupportedFirestoreDriverFunctionError(message) {
-  throw new Error(message !== null && message !== void 0 ? message : 'This function is not supported by this Firestore driver.');
+  throw new Error(message != null ? message : 'This function is not supported by this Firestore driver.');
 }
 /**
  * Asserts that the input data is not an empty object and has keys.
@@ -4442,7 +4497,8 @@ function firebaseQuerySnapshotAccumulator(iteration, mapSnapshots) {
   return rxjs$1.itemAccumulator(iteration, mapSnapshots);
 }
 function firebaseQueryItemAccumulator(iteration, mapItem) {
-  mapItem = mapItem !== null && mapItem !== void 0 ? mapItem : x => x;
+  var _mapItem;
+  mapItem = (_mapItem = mapItem) != null ? _mapItem : x => x;
   const snapshotData = documentDataFunction(true);
   const mapFn = x => {
     const result = util.filterMaybeValues(x.map(y => {
@@ -4700,31 +4756,31 @@ function whereDateIsBetween(fieldPath, range, sortDirection) {
     start,
     end
   } = range;
-  return [orderBy(fieldPath, sortDirection !== null && sortDirection !== void 0 ? sortDirection : 'asc'), where(fieldPath, '>=', start.toISOString()), where(fieldPath, '<', end.toISOString())];
+  return [orderBy(fieldPath, sortDirection != null ? sortDirection : 'asc'), where(fieldPath, '>=', start.toISOString()), where(fieldPath, '<', end.toISOString())];
 }
 function whereDateIsOnOrAfter(fieldPath, date = new Date()) {
   return where(fieldPath, '>=', date.toISOString());
 }
 function whereDateIsOnOrAfterWithSort(fieldPath, date = new Date(), sortDirection) {
-  return [orderBy(fieldPath, sortDirection !== null && sortDirection !== void 0 ? sortDirection : 'asc'), whereDateIsOnOrAfter(fieldPath, date)];
+  return [orderBy(fieldPath, sortDirection != null ? sortDirection : 'asc'), whereDateIsOnOrAfter(fieldPath, date)];
 }
 function whereDateIsOnOrBefore(fieldPath, date = new Date()) {
   return where(fieldPath, '<=', date.toISOString());
 }
 function whereDateIsOnOrBeforeWithSort(fieldPath, date = new Date(), sortDirection) {
-  return [orderBy(fieldPath, sortDirection !== null && sortDirection !== void 0 ? sortDirection : 'desc'), whereDateIsOnOrBefore(fieldPath, date)];
+  return [orderBy(fieldPath, sortDirection != null ? sortDirection : 'desc'), whereDateIsOnOrBefore(fieldPath, date)];
 }
 function whereDateIsAfter(fieldPath, date = new Date()) {
   return where(fieldPath, '>', date.toISOString());
 }
 function whereDateIsAfterWithSort(fieldPath, date = new Date(), sortDirection) {
-  return [orderBy(fieldPath, sortDirection !== null && sortDirection !== void 0 ? sortDirection : 'asc'), whereDateIsAfter(fieldPath, date)];
+  return [orderBy(fieldPath, sortDirection != null ? sortDirection : 'asc'), whereDateIsAfter(fieldPath, date)];
 }
 function whereDateIsBefore(fieldPath, date = new Date()) {
   return where(fieldPath, '<', date.toISOString());
 }
 function whereDateIsBeforeWithSort(fieldPath, date = new Date(), sortDirection) {
-  return [orderBy(fieldPath, sortDirection !== null && sortDirection !== void 0 ? sortDirection : 'desc'), whereDateIsBefore(fieldPath, date)];
+  return [orderBy(fieldPath, sortDirection != null ? sortDirection : 'desc'), whereDateIsBefore(fieldPath, date)];
 }
 
 function filterDisallowedFirestoreItemPageIteratorInputContraints(constraints) {
@@ -4749,10 +4805,10 @@ function makeFirestoreItemPageIteratorDelegate() {
       const {
         limit: filterLimit,
         constraints: filterConstraints
-      } = filter !== null && filter !== void 0 ? filter : {};
+      } = filter != null ? filter : {};
       return prevQueryResult$.pipe(rxjs.exhaustMap(prevResult => {
-        if ((prevResult === null || prevResult === void 0 ? void 0 : prevResult.snapshot.empty) === true) {
-          // TODO: Shouldn't happen. Remove this later.
+        if ((prevResult == null ? void 0 : prevResult.snapshot.empty) === true) {
+          // TODO(REMOVE): Shouldn't happen. Remove this later.
           return rxjs.of({
             end: true
           });
@@ -4769,7 +4825,7 @@ function makeFirestoreItemPageIteratorDelegate() {
             constraints.push(startAfterFilter);
           }
           // Add Limit
-          const limitCount = filterLimit !== null && filterLimit !== void 0 ? filterLimit : itemsPerPage + (startAfterFilter ? 1 : 0); // todo: may not be needed.
+          const limitCount = filterLimit != null ? filterLimit : itemsPerPage + (startAfterFilter ? 1 : 0); // todo: may not be needed.
           const limitConstraint = limit(limitCount);
           const constraintsWithLimit = [...constraints, limitConstraint];
           // make query
@@ -4787,7 +4843,7 @@ function makeFirestoreItemPageIteratorDelegate() {
                 },
                 stream(options) {
                   // todo: consider allowing limit to be changed here to stream a subset. This will be useful for detecting collection changes.
-                  return driver.streamDocs(batchQuery, options === null || options === void 0 ? void 0 : options.options);
+                  return driver.streamDocs(batchQuery, options == null ? void 0 : options.options);
                 }
               },
               end: snapshot.empty
@@ -4819,12 +4875,12 @@ class FirestoreItemPageIterationInstance extends rxjs$1.MappedPageItemIterationI
  */
 function firestoreItemPageIterationFactory(baseConfig) {
   return filter => {
-    var _a;
+    var _filter$maxPageLoadLi;
     const result = firestoreItemPageIteration({
       queryLike: baseConfig.queryLike,
       itemsPerPage: baseConfig.itemsPerPage,
       firestoreQueryDriver: baseConfig.firestoreQueryDriver,
-      maxPageLoadLimit: (_a = filter === null || filter === void 0 ? void 0 : filter.maxPageLoadLimit) !== null && _a !== void 0 ? _a : baseConfig.maxPageLoadLimit,
+      maxPageLoadLimit: (_filter$maxPageLoadLi = filter == null ? void 0 : filter.maxPageLoadLimit) != null ? _filter$maxPageLoadLi : baseConfig.maxPageLoadLimit,
       filter
     });
     return result;
@@ -4843,6 +4899,28 @@ function firestoreItemPageIteration(config) {
  * @param config
  * @returns
  */
+
+function _async$7(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
+function _await$7(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
 function firestoreQueryFactory(config) {
   const {
     queryLike,
@@ -4859,14 +4937,15 @@ function firestoreQueryFactory(config) {
     const query = makeQuery(inputQuery, ...allConstraints);
     const result = {
       query,
-      countDocs: () => __awaiter(this, void 0, void 0, function* () {
+      countDocs: _async$7(function () {
         return countDocs(query);
       }),
-      getFirstDoc: transaction => __awaiter(this, void 0, void 0, function* () {
+      getFirstDoc: _async$7(function (transaction) {
         const contraintsForOneDoc = addOrReplaceLimitInConstraints(1)(allConstraints);
         const query = makeQuery(inputQuery, ...contraintsForOneDoc);
-        const result = yield getDocs(query, transaction);
-        return result.docs[0];
+        return _await$7(getDocs(query, transaction), function (result) {
+          return result.docs[0];
+        });
       }),
       getDocs: transaction => getDocs(query, transaction),
       streamDocs: () => streamDocs(query),
@@ -4917,209 +4996,104 @@ function readFirestoreModelKeyFromDocumentSnapshot(snapshot) {
  * @param config
  * @returns
  */
-function iterateFirestoreDocumentSnapshotPairs(config) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const {
-      iterateSnapshotPair,
-      documentAccessor
-    } = config;
-    const loadPairForSnapshot = firestoreDocumentSnapshotPairsLoaderInstance(documentAccessor);
-    return iterateFirestoreDocumentSnapshots(Object.assign(Object.assign({}, config), {
-      iterateSnapshot: snapshot => __awaiter(this, void 0, void 0, function* () {
-        const pair = loadPairForSnapshot(snapshot);
-        return iterateSnapshotPair(pair);
-      })
-    }));
-  });
-}
+
 /**
- * Iterates through the results of a Firestore query by each document snapshot by itself.
+ * Iterates through the results of a Firestore query in several batches.
  *
  * @param config
  * @returns
  */
-function iterateFirestoreDocumentSnapshots(config) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const {
-      iterateSnapshot,
-      performTasksConfig,
-      snapshotsPerformTasksConfig
-    } = config;
-    return iterateFirestoreDocumentSnapshotBatches(Object.assign(Object.assign({}, config), {
-      maxParallelCheckpoints: 1,
-      iterateSnapshotBatch: docSnapshots => __awaiter(this, void 0, void 0, function* () {
-        const performTasksResult = yield util.performAsyncTasks(docSnapshots, iterateSnapshot, Object.assign({
-          sequential: true
-        }, snapshotsPerformTasksConfig !== null && snapshotsPerformTasksConfig !== void 0 ? snapshotsPerformTasksConfig : Object.assign(Object.assign({}, performTasksConfig), {
-          nonConcurrentTaskKeyFactory: undefined,
-          beforeRetry: undefined
-        }) // don't pass the nonConcurrentTaskKeyFactory
-        ));
-
-        return performTasksResult;
-      })
-    }));
-  });
+function _async$6(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
 }
-/**
- * Iterates through the results of a Firestore query by each FirestoreDocumentSnapshotDataPair.
- *
- * @param config
- * @returns
- */
-function iterateFirestoreDocumentSnapshotPairBatches(config) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const {
-      iterateSnapshotPairsBatch,
-      documentAccessor
-    } = config;
-    const loadPairForSnapshot = firestoreDocumentSnapshotPairsLoaderInstance(documentAccessor);
-    return iterateFirestoreDocumentSnapshotBatches(Object.assign(Object.assign({}, config), {
-      maxParallelCheckpoints: 1,
-      iterateSnapshotBatch: (snapshots, batchIndex) => __awaiter(this, void 0, void 0, function* () {
-        const pairs = snapshots.map(loadPairForSnapshot);
-        return iterateSnapshotPairsBatch(pairs, batchIndex);
-      })
-    }));
-  });
+
+// MARK: Utility
+function _await$6(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
 }
-/**
- * Default batch size for iterateFirestoreDocumentSnapshotBatches().
- *
- * 25 documents per batch.
- */
-const DEFAULT_ITERATE_FIRESTORE_DOCUMENT_SNAPSHOT_BATCHES_BATCH_SIZE = 25;
-/**
- * Iterates through the results of a Firestore query by each document snapshot.
- *
- * @param config
- * @returns
- */
-function iterateFirestoreDocumentSnapshotBatches(config) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const {
-      iterateSnapshotBatch,
-      batchSizeForSnapshots: inputBatchSizeForSnapshots,
-      performTasksConfig,
-      batchSize: inputBatchSize
-    } = config;
-    const batchSize = inputBatchSize === null ? null : inputBatchSize !== null && inputBatchSize !== void 0 ? inputBatchSize : DEFAULT_ITERATE_FIRESTORE_DOCUMENT_SNAPSHOT_BATCHES_BATCH_SIZE;
-    const batchSizeForSnapshots = inputBatchSizeForSnapshots !== null && inputBatchSizeForSnapshots !== void 0 ? inputBatchSizeForSnapshots : () => batchSize;
-    return iterateFirestoreDocumentSnapshotCheckpoints(Object.assign(Object.assign({}, config), {
-      iterateCheckpoint: docSnapshots => __awaiter(this, void 0, void 0, function* () {
-        if (docSnapshots.length > 0) {
-          const batchSizeForSnapshotsResult = yield batchSizeForSnapshots(docSnapshots);
-          const batches = batchSizeForSnapshotsResult === null ? [docSnapshots] : util.batch(docSnapshots, batchSizeForSnapshotsResult);
-          let i = 0;
-          const performTasksResult = yield util.performAsyncTasks(batches, x => iterateSnapshotBatch(x, i++), Object.assign({
-            sequential: true
-          }, performTasksConfig));
-          return performTasksResult.results.map(([snapshots, result], i) => ({
-            snapshots,
-            result,
-            i
-          }));
-        } else {
-          return [];
-        }
-      })
-    }));
-  });
+function _empty$2() {}
+function _awaitIgnored$1(value, direct) {
+  if (!direct) {
+    return value && value.then ? value.then(_empty$2) : Promise.resolve();
+  }
 }
-/**
- * Creates a IterateFirestoreDocumentSnapshotCheckpointsFilterCheckpointSnapshotsFunction that filters out any repeat documents.
- *
- * Repeat documents can occur in cases where the document is updated and the query matches it again for a different reason.
- *
- * @param readKeyFunction
- */
-function filterRepeatCheckpointSnapshots(readKeyFunction = x => x.id) {
-  const allowOnceFilter = util.allowValueOnceFilter(readKeyFunction);
-  return snapshots => __awaiter(this, void 0, void 0, function* () {
-    return snapshots.filter(allowOnceFilter);
-  });
+function _invoke$2(body, then) {
+  var result = body();
+  if (result && result.then) {
+    return result.then(then);
+  }
+  return then(result);
 }
-/**
- * Iterates through the results of a Firestore query in several batches.
- *
- * @param config
- * @returns
- */
-function iterateFirestoreDocumentSnapshotCheckpoints(config) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const {
-      iterateCheckpoint,
-      filterCheckpointSnapshots: inputFilterCheckpointSnapshot,
-      handleRepeatCursor: inputHandleRepeatCursor,
-      waitBetweenCheckpoints,
-      useCheckpointResult,
-      constraintsFactory: inputConstraintsFactory,
-      dynamicConstraints: inputDynamicConstraints,
-      queryFactory,
-      maxParallelCheckpoints = 1,
-      limitPerCheckpoint: inputLimitPerCheckpoint,
-      totalSnapshotsLimit: inputTotalSnapshotsLimit
-    } = config;
-    const constraintsInputIsFactory = typeof inputConstraintsFactory === 'function';
-    const constraintsFactory = constraintsInputIsFactory && inputDynamicConstraints !== false ? inputConstraintsFactory : util.asGetter(util.getValueFromGetter(inputConstraintsFactory));
-    /**
-     * Default to the input total snapshots limit if no limit is provided, otherwise there will be no limit.
-     */
-    const limitPerCheckpoint = inputLimitPerCheckpoint !== null && inputLimitPerCheckpoint !== void 0 ? inputLimitPerCheckpoint : inputTotalSnapshotsLimit;
-    const totalSnapshotsLimit = inputTotalSnapshotsLimit !== null && inputTotalSnapshotsLimit !== void 0 ? inputTotalSnapshotsLimit : Number.MAX_SAFE_INTEGER;
-    let currentIndex = 0;
-    let hasReachedEnd = false;
-    let totalSnapshotsLimitReached = false;
-    let totalSnapshotsVisited = 0;
-    let cursorDocument;
-    const visitedCursorPaths = new Set();
-    const handleRepeatCursor = typeof inputHandleRepeatCursor === 'function' ? inputHandleRepeatCursor : () => inputHandleRepeatCursor;
-    const filterCheckpointSnapshot = inputFilterCheckpointSnapshot !== null && inputFilterCheckpointSnapshot !== void 0 ? inputFilterCheckpointSnapshot : util.mapIdentityFunction();
-    function taskInputFactory() {
-      return __awaiter(this, void 0, void 0, function* () {
-        // Perform another query, then pass the results to the task factory.
-        if (hasReachedEnd) {
-          return null; // issue no more tasks
-        }
+const iterateFirestoreDocumentSnapshotCheckpoints = _async$6(function (config) {
+  const taskInputFactory = _async$6(function () {
+    // Perform another query, then pass the results to the task factory.
+    if (hasReachedEnd) {
+      return null; // issue no more tasks
+    }
 
-        const constraints = constraintsFactory();
-        const startAfterFilter = cursorDocument ? startAfter(cursorDocument) : undefined;
-        if (startAfterFilter) {
-          constraints.push(startAfterFilter);
-        }
-        if (limitPerCheckpoint != null) {
-          const totalPossibleNumberOfItemsLeftToLoad = Math.max(0, totalSnapshotsLimit - totalSnapshotsVisited);
-          const nextLimit = Math.min(limitPerCheckpoint, totalPossibleNumberOfItemsLeftToLoad);
-          if (nextLimit === 0) {
-            // we're at the end
-            cursorDocument = null;
-            hasReachedEnd = true;
-            totalSnapshotsLimitReached = true; // should have already been reached, but flag again just incase
-            return null; // exit immediately
-          } else {
-            constraints.push(limit(nextLimit));
-          }
-        }
-        const query = queryFactory.query(constraints);
-        const docQuerySnapshot = yield query.getDocs();
-        const docSnapshots = docQuerySnapshot.docs;
-        // check for repeat cursor
-        const nextCursorDocument = util.lastValue(docSnapshots);
+    const constraints = constraintsFactory();
+    const startAfterFilter = cursorDocument ? startAfter(cursorDocument) : undefined;
+    if (startAfterFilter) {
+      constraints.push(startAfterFilter);
+    }
+    if (limitPerCheckpoint != null) {
+      const totalPossibleNumberOfItemsLeftToLoad = Math.max(0, totalSnapshotsLimit - totalSnapshotsVisited);
+      const nextLimit = Math.min(limitPerCheckpoint, totalPossibleNumberOfItemsLeftToLoad);
+      if (nextLimit === 0) {
+        // we're at the end
+        cursorDocument = null;
+        hasReachedEnd = true;
+        totalSnapshotsLimitReached = true; // should have already been reached, but flag again just incase
+        return null; // exit immediately
+      } else {
+        constraints.push(limit(nextLimit));
+      }
+    }
+    const query = queryFactory.query(constraints);
+    return _await$6(query.getDocs(), function (docQuerySnapshot) {
+      let _exit = false;
+      const docSnapshots = docQuerySnapshot.docs;
+      // check for repeat cursor
+      const nextCursorDocument = util.lastValue(docSnapshots);
+      return _invoke$2(function () {
         if (nextCursorDocument != null) {
           const cursorPath = readFirestoreModelKeyFromDocumentSnapshot(nextCursorDocument);
-          if (visitedCursorPaths.has(cursorPath)) {
-            const shouldContinue = yield handleRepeatCursor(nextCursorDocument);
-            if (shouldContinue === false) {
-              cursorDocument = null;
-              hasReachedEnd = true;
-              return null; // exit immediately
+          return function () {
+            if (visitedCursorPaths.has(cursorPath)) {
+              return _await$6(handleRepeatCursor(nextCursorDocument), function (shouldContinue) {
+                if (shouldContinue === false) {
+                  cursorDocument = null;
+                  hasReachedEnd = true;
+                  const _temp = null;
+                  _exit = true;
+                  return _temp; // exit immediately
+                }
+              });
+            } else {
+              visitedCursorPaths.add(cursorPath);
             }
-          } else {
-            visitedCursorPaths.add(cursorPath);
-          }
+          }();
         }
+      }, function (_result2) {
+        if (_exit) return _result2;
         cursorDocument = nextCursorDocument; // set the next cursor document
         // update state
+        // increase our current index
         const newSnapshotsVisited = docSnapshots.length;
         totalSnapshotsVisited += newSnapshotsVisited;
         if (!cursorDocument || totalSnapshotsVisited > totalSnapshotsLimit) {
@@ -5128,33 +5102,64 @@ function iterateFirestoreDocumentSnapshotCheckpoints(config) {
         }
 
         const i = currentIndex;
-        currentIndex += 1; // increase our current index
+        currentIndex += 1;
         return {
           i,
           docQuerySnapshot
         };
       });
-    }
-    const performTaskFn = util.performTasksFromFactoryInParallelFunction({
-      maxParallelTasks: maxParallelCheckpoints,
-      waitBetweenTasks: waitBetweenCheckpoints,
-      taskFactory: ({
-        i,
-        docQuerySnapshot
-      }) => __awaiter(this, void 0, void 0, function* () {
-        const docSnapshots = yield filterCheckpointSnapshot(docQuerySnapshot.docs);
-        const results = yield iterateCheckpoint(docSnapshots, docQuerySnapshot);
-        const checkpointResults = {
-          i,
-          cursorDocument,
-          results,
-          docSnapshots,
-          docQuerySnapshot
-        };
-        yield useCheckpointResult === null || useCheckpointResult === void 0 ? void 0 : useCheckpointResult(checkpointResults);
-      })
     });
-    yield performTaskFn(taskInputFactory);
+  });
+  const {
+    iterateCheckpoint,
+    filterCheckpointSnapshots: inputFilterCheckpointSnapshot,
+    handleRepeatCursor: inputHandleRepeatCursor,
+    waitBetweenCheckpoints,
+    useCheckpointResult,
+    constraintsFactory: inputConstraintsFactory,
+    dynamicConstraints: inputDynamicConstraints,
+    queryFactory,
+    maxParallelCheckpoints = 1,
+    limitPerCheckpoint: inputLimitPerCheckpoint,
+    totalSnapshotsLimit: inputTotalSnapshotsLimit
+  } = config;
+  const constraintsInputIsFactory = typeof inputConstraintsFactory === 'function';
+  const constraintsFactory = constraintsInputIsFactory && inputDynamicConstraints !== false ? inputConstraintsFactory : util.asGetter(util.getValueFromGetter(inputConstraintsFactory));
+  /**
+   * Default to the input total snapshots limit if no limit is provided, otherwise there will be no limit.
+   */
+  const limitPerCheckpoint = inputLimitPerCheckpoint != null ? inputLimitPerCheckpoint : inputTotalSnapshotsLimit;
+  const totalSnapshotsLimit = inputTotalSnapshotsLimit != null ? inputTotalSnapshotsLimit : Number.MAX_SAFE_INTEGER;
+  let currentIndex = 0;
+  let hasReachedEnd = false;
+  let totalSnapshotsLimitReached = false;
+  let totalSnapshotsVisited = 0;
+  let cursorDocument;
+  const visitedCursorPaths = new Set();
+  const handleRepeatCursor = typeof inputHandleRepeatCursor === 'function' ? inputHandleRepeatCursor : () => inputHandleRepeatCursor;
+  const filterCheckpointSnapshot = inputFilterCheckpointSnapshot != null ? inputFilterCheckpointSnapshot : util.mapIdentityFunction();
+  const performTaskFn = util.performTasksFromFactoryInParallelFunction({
+    maxParallelTasks: maxParallelCheckpoints,
+    waitBetweenTasks: waitBetweenCheckpoints,
+    taskFactory: _async$6(function ({
+      i,
+      docQuerySnapshot
+    }) {
+      return _await$6(filterCheckpointSnapshot(docQuerySnapshot.docs), function (docSnapshots) {
+        return _await$6(iterateCheckpoint(docSnapshots, docQuerySnapshot), function (results) {
+          const checkpointResults = {
+            i,
+            cursorDocument,
+            results,
+            docSnapshots,
+            docQuerySnapshot
+          };
+          return _awaitIgnored$1(useCheckpointResult == null ? void 0 : useCheckpointResult(checkpointResults));
+        });
+      });
+    })
+  });
+  return _await$6(performTaskFn(taskInputFactory), function () {
     const result = {
       totalCheckpoints: currentIndex,
       totalSnapshotsVisited,
@@ -5162,99 +5167,211 @@ function iterateFirestoreDocumentSnapshotCheckpoints(config) {
     };
     return result;
   });
-}
-// MARK: Utility
-function allowDocumentSnapshotWithPathOnceFilter() {
-  return util.allowValueOnceFilter(readFirestoreModelKeyFromDocumentSnapshot);
-}
-
-function loadAllFirestoreDocumentSnapshotPairs(config) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const {
-      documentAccessor,
-      queryFactory,
-      constraintsFactory,
-      dynamicConstraints,
-      totalSnapshotsLimit,
-      limitPerCheckpoint,
-      handleRepeatCursor,
-      filterCheckpointSnapshots,
-      iterateSnapshotPairsBatch: optionalIterateSnapshotPairsBatch
-    } = config;
-    const allDocumentGroups = [];
-    const {
-      totalCheckpoints,
-      totalSnapshotsVisited,
-      totalSnapshotsLimitReached
-    } = yield iterateFirestoreDocumentSnapshotPairBatches({
-      documentAccessor,
-      queryFactory,
-      constraintsFactory,
-      dynamicConstraints,
-      totalSnapshotsLimit,
-      handleRepeatCursor,
-      filterCheckpointSnapshots,
-      limitPerCheckpoint,
-      maxParallelCheckpoints: 1,
-      iterateSnapshotPairsBatch: (snapshotDataPairs, batchIndex) => __awaiter(this, void 0, void 0, function* () {
-        allDocumentGroups.push(snapshotDataPairs);
-        if (optionalIterateSnapshotPairsBatch) {
-          yield optionalIterateSnapshotPairsBatch(snapshotDataPairs, batchIndex);
-        }
-      })
-    });
-    const snapshotPairs = util.flattenArray(allDocumentGroups);
-    return {
-      snapshotPairs,
-      totalCheckpoints,
-      totalSnapshotsVisited,
-      totalSnapshotsLimitReached
-    };
-  });
-}
+});
 /**
- * Iterates all documents that match the configuration and puts them into an array.
+ * Iterates through the results of a Firestore query by each document snapshot.
+ *
+ * @param config
+ * @returns
+ */
+const iterateFirestoreDocumentSnapshotBatches = _async$6(function (config) {
+  const {
+    iterateSnapshotBatch,
+    batchSizeForSnapshots: inputBatchSizeForSnapshots,
+    performTasksConfig,
+    batchSize: inputBatchSize
+  } = config;
+  const batchSize = inputBatchSize === null ? null : inputBatchSize != null ? inputBatchSize : DEFAULT_ITERATE_FIRESTORE_DOCUMENT_SNAPSHOT_BATCHES_BATCH_SIZE;
+  const batchSizeForSnapshots = inputBatchSizeForSnapshots != null ? inputBatchSizeForSnapshots : () => batchSize;
+  return iterateFirestoreDocumentSnapshotCheckpoints(Object.assign({}, config, {
+    iterateCheckpoint: _async$6(function (docSnapshots) {
+      if (docSnapshots.length > 0) {
+        return _await$6(batchSizeForSnapshots(docSnapshots), function (batchSizeForSnapshotsResult) {
+          const batches = batchSizeForSnapshotsResult === null ? [docSnapshots] : util.batch(docSnapshots, batchSizeForSnapshotsResult);
+          let i = 0;
+          return _await$6(util.performAsyncTasks(batches, x => iterateSnapshotBatch(x, i++), Object.assign({
+            sequential: true
+          }, performTasksConfig)), function (performTasksResult) {
+            return performTasksResult.results.map(([snapshots, result], i) => ({
+              snapshots,
+              result,
+              i
+            }));
+          });
+        });
+      } else {
+        return [];
+      }
+    })
+  }));
+});
+/**
+ * Creates a IterateFirestoreDocumentSnapshotCheckpointsFilterCheckpointSnapshotsFunction that filters out any repeat documents.
+ *
+ * Repeat documents can occur in cases where the document is updated and the query matches it again for a different reason.
+ *
+ * @param readKeyFunction
+ */
+/**
+ * Iterates through the results of a Firestore query by each FirestoreDocumentSnapshotDataPair.
+ *
+ * @param config
+ * @returns
+ */
+const iterateFirestoreDocumentSnapshotPairBatches = _async$6(function (config) {
+  const {
+    iterateSnapshotPairsBatch,
+    documentAccessor
+  } = config;
+  const loadPairForSnapshot = firestoreDocumentSnapshotPairsLoaderInstance(documentAccessor);
+  return iterateFirestoreDocumentSnapshotBatches(Object.assign({}, config, {
+    maxParallelCheckpoints: 1,
+    iterateSnapshotBatch: _async$6(function (snapshots, batchIndex) {
+      const pairs = snapshots.map(loadPairForSnapshot);
+      return iterateSnapshotPairsBatch(pairs, batchIndex);
+    })
+  }));
+});
+/**
+ * Default batch size for iterateFirestoreDocumentSnapshotBatches().
+ *
+ * 25 documents per batch.
+ */
+/**
+ * Iterates through the results of a Firestore query by each document snapshot by itself.
+ *
+ * @param config
+ * @returns
+ */
+const iterateFirestoreDocumentSnapshots = _async$6(function (config) {
+  const {
+    iterateSnapshot,
+    performTasksConfig,
+    snapshotsPerformTasksConfig
+  } = config;
+  return iterateFirestoreDocumentSnapshotBatches(Object.assign({}, config, {
+    maxParallelCheckpoints: 1,
+    iterateSnapshotBatch: _async$6(function (docSnapshots) {
+      return util.performAsyncTasks(docSnapshots, iterateSnapshot, Object.assign({
+        sequential: true
+      }, snapshotsPerformTasksConfig != null ? snapshotsPerformTasksConfig : Object.assign({}, performTasksConfig, {
+        nonConcurrentTaskKeyFactory: undefined,
+        beforeRetry: undefined
+      })));
+    })
+  }));
+});
+const iterateFirestoreDocumentSnapshotPairs = _async$6(function (config) {
+  const {
+    iterateSnapshotPair,
+    documentAccessor
+  } = config;
+  const loadPairForSnapshot = firestoreDocumentSnapshotPairsLoaderInstance(documentAccessor);
+  return iterateFirestoreDocumentSnapshots(Object.assign({}, config, {
+    iterateSnapshot: _async$6(function (snapshot) {
+      const pair = loadPairForSnapshot(snapshot);
+      return iterateSnapshotPair(pair);
+    })
+  }));
+});
+const DEFAULT_ITERATE_FIRESTORE_DOCUMENT_SNAPSHOT_BATCHES_BATCH_SIZE = 25;
+function filterRepeatCheckpointSnapshots(readKeyFunction = x => x.id) {
+  const allowOnceFilter = util.allowValueOnceFilter(readKeyFunction);
+  return _async$6(function (snapshots) {
+    return snapshots.filter(allowOnceFilter);
+  });
+}
+function allowDocumentSnapshotWithPathOnceFilter() {
+  return util.allowValueOnceFilter(readFirestoreModelKeyFromDocumentSnapshot);
+}
+
+/**
+ * Iterates all documents that match the configuration and puts them into an array.
  *
  * @param config
  * @returns
  */
-function loadAllFirestoreDocumentSnapshot(config) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const {
-      queryFactory,
-      constraintsFactory,
-      dynamicConstraints,
-      totalSnapshotsLimit,
-      limitPerCheckpoint,
-      handleRepeatCursor,
-      filterCheckpointSnapshots,
-      iterateSnapshotsForCheckpoint
-    } = config;
-    const allDocumentGroups = [];
-    const {
-      totalCheckpoints,
-      totalSnapshotsVisited,
-      totalSnapshotsLimitReached
-    } = yield iterateFirestoreDocumentSnapshotCheckpoints({
-      queryFactory,
-      constraintsFactory,
-      dynamicConstraints,
-      totalSnapshotsLimit,
-      handleRepeatCursor,
-      filterCheckpointSnapshots,
-      limitPerCheckpoint,
-      maxParallelCheckpoints: 1,
-      iterateCheckpoint: (snapshots, query) => __awaiter(this, void 0, void 0, function* () {
-        if (snapshots.length) {
-          allDocumentGroups.push(snapshots); // add to snapshots array
-          if (iterateSnapshotsForCheckpoint) {
-            yield iterateSnapshotsForCheckpoint(snapshots, query);
-          }
-        }
-        return []; // return nothing
-      })
-    });
 
+function _await$5(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function _async$5(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
+function _empty$1() {}
+function _awaitIgnored(value, direct) {
+  if (!direct) {
+    return value && value.then ? value.then(_empty$1) : Promise.resolve();
+  }
+}
+function _invokeIgnored$1(body) {
+  var result = body();
+  if (result && result.then) {
+    return result.then(_empty$1);
+  }
+}
+function _invoke$1(body, then) {
+  var result = body();
+  if (result && result.then) {
+    return result.then(then);
+  }
+  return then(result);
+}
+const loadAllFirestoreDocumentSnapshot = _async$5(function (config) {
+  const {
+    queryFactory,
+    constraintsFactory,
+    dynamicConstraints,
+    totalSnapshotsLimit,
+    limitPerCheckpoint,
+    handleRepeatCursor,
+    filterCheckpointSnapshots,
+    iterateSnapshotsForCheckpoint
+  } = config;
+  const allDocumentGroups = [];
+  return _await$5(iterateFirestoreDocumentSnapshotCheckpoints({
+    queryFactory,
+    constraintsFactory,
+    dynamicConstraints,
+    totalSnapshotsLimit,
+    handleRepeatCursor,
+    filterCheckpointSnapshots,
+    limitPerCheckpoint,
+    maxParallelCheckpoints: 1,
+    iterateCheckpoint: _async$5(function (snapshots, query) {
+      return _invoke$1(function () {
+        if (snapshots.length) {
+          allDocumentGroups.push(snapshots); // add to snapshots array
+          return _invokeIgnored$1(function () {
+            if (iterateSnapshotsForCheckpoint) {
+              return _awaitIgnored(iterateSnapshotsForCheckpoint(snapshots, query));
+            }
+          });
+        }
+      }, function () {
+        return []; // return nothing
+      });
+    })
+  }), function ({
+    totalCheckpoints,
+    totalSnapshotsVisited,
+    totalSnapshotsLimitReached
+  }) {
     const snapshots = util.flattenArray(allDocumentGroups);
     return {
       snapshots,
@@ -5263,7 +5380,52 @@ function loadAllFirestoreDocumentSnapshot(config) {
       totalSnapshotsLimitReached
     };
   });
-}
+});
+const loadAllFirestoreDocumentSnapshotPairs = _async$5(function (config) {
+  const {
+    documentAccessor,
+    queryFactory,
+    constraintsFactory,
+    dynamicConstraints,
+    totalSnapshotsLimit,
+    limitPerCheckpoint,
+    handleRepeatCursor,
+    filterCheckpointSnapshots,
+    iterateSnapshotPairsBatch: optionalIterateSnapshotPairsBatch
+  } = config;
+  const allDocumentGroups = [];
+  return _await$5(iterateFirestoreDocumentSnapshotPairBatches({
+    documentAccessor,
+    queryFactory,
+    constraintsFactory,
+    dynamicConstraints,
+    totalSnapshotsLimit,
+    handleRepeatCursor,
+    filterCheckpointSnapshots,
+    limitPerCheckpoint,
+    maxParallelCheckpoints: 1,
+    iterateSnapshotPairsBatch: _async$5(function (snapshotDataPairs, batchIndex) {
+      allDocumentGroups.push(snapshotDataPairs);
+      return _invokeIgnored$1(function () {
+        if (optionalIterateSnapshotPairsBatch) {
+          return _awaitIgnored(optionalIterateSnapshotPairsBatch(snapshotDataPairs, batchIndex));
+        }
+      });
+    })
+  }), function ({
+    totalCheckpoints,
+    totalSnapshotsVisited,
+    totalSnapshotsLimitReached
+  }) {
+    const snapshotPairs = util.flattenArray(allDocumentGroups);
+    return {
+      snapshotPairs,
+      totalCheckpoints,
+      totalSnapshotsVisited,
+      totalSnapshotsLimitReached
+    };
+  });
+});
 
 const DEFAULT_QUERY_CHANGE_WATCHER_DELAY = 0;
 function iterationQueryDocChangeWatcher(config) {
@@ -5272,14 +5434,14 @@ function iterationQueryDocChangeWatcher(config) {
     delay: timeUntilActive = DEFAULT_QUERY_CHANGE_WATCHER_DELAY
   } = config;
   const stream$ = instance.snapshotIteration.firstSuccessfulPageResults$.pipe(rxjs.switchMap(first => {
-    var _a;
+    var _beginCheckingAt$expi;
     const {
       time,
       stream
     } = first.value.value;
     const beginCheckingAt = date.toExpires(time, timeUntilActive);
     // don't start streaming until the given moment.
-    return rxjs.timer((_a = beginCheckingAt.expiresAt) !== null && _a !== void 0 ? _a : new Date()).pipe(rxjs.switchMap(() => stream().pipe(rxjs.skip(1) // skip the first value, as it should be equivalent to the query results given.
+    return rxjs.timer((_beginCheckingAt$expi = beginCheckingAt.expiresAt) != null ? _beginCheckingAt$expi : new Date()).pipe(rxjs.switchMap(() => stream().pipe(rxjs.skip(1) // skip the first value, as it should be equivalent to the query results given.
     )));
   }), rxjs.shareReplay(1));
   const event$ = stream$.pipe(rxjs.map(event => {
@@ -5287,12 +5449,12 @@ function iterationQueryDocChangeWatcher(config) {
     const results = util.build({
       base: util.groupValues(changes, x => x.type),
       build: x => {
-        var _a, _b, _c;
+        var _x$added, _x$removed, _x$modified;
         x.time = new Date();
         x.changes = changes;
-        x.added = (_a = x.added) !== null && _a !== void 0 ? _a : [];
-        x.removed = (_b = x.removed) !== null && _b !== void 0 ? _b : [];
-        x.modified = (_c = x.modified) !== null && _c !== void 0 ? _c : [];
+        x.added = (_x$added = x.added) != null ? _x$added : [];
+        x.removed = (_x$removed = x.removed) != null ? _x$removed : [];
+        x.modified = (_x$modified = x.modified) != null ? _x$modified : [];
         x.type = iterationQueryDocChangeWatcherChangeTypeForGroup(x);
       }
     });
@@ -5970,22 +6132,45 @@ $$1({ target: 'Array', proto: true, forced: String(test) === String(test.reverse
   }
 });
 
+function _async$4(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
+function _await$4(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
 function firestoreCollectionQueryFactory(queryFactory, accessorContext) {
   const documentLoader = firestoreDocumentLoader(accessorContext);
   const documentSnapshotPairsLoader = firestoreQueryDocumentSnapshotPairsLoader(accessorContext);
   const wrapQuery = baseQuery => {
     return {
       baseQuery,
-      countDocs: () => __awaiter(this, void 0, void 0, function* () {
+      countDocs: _async$4(function () {
         return baseQuery.countDocs();
       }),
-      getFirstDoc: transaction => __awaiter(this, void 0, void 0, function* () {
-        const result = yield baseQuery.getFirstDoc(transaction);
-        return result ? documentLoader([result.ref])[0] : undefined;
+      getFirstDoc: _async$4(function (transaction) {
+        return _await$4(baseQuery.getFirstDoc(transaction), function (result) {
+          return result ? documentLoader([result.ref])[0] : undefined;
+        });
       }),
-      getFirstDocSnapshotDataPair: transaction => __awaiter(this, void 0, void 0, function* () {
-        const result = yield baseQuery.getFirstDoc(transaction);
-        return result ? documentSnapshotPairsLoader([result])[0] : undefined;
+      getFirstDocSnapshotDataPair: _async$4(function (transaction) {
+        return _await$4(baseQuery.getFirstDoc(transaction), function (result) {
+          return result ? documentSnapshotPairsLoader([result])[0] : undefined;
+        });
       }),
       getDocs: transaction => baseQuery.getDocs(transaction).then(x => documentLoader(documentReferencesFromSnapshot(x), transaction)),
       getDocSnapshotDataPairs: transaction => baseQuery.getDocs(transaction).then(x => documentSnapshotPairsLoader(x.docs, transaction)),
@@ -6001,9 +6186,8 @@ function firestoreCollectionQueryFactory(queryFactory, accessorContext) {
 
 const FIRESTORE_COLLECTION_NAME_SEPARATOR = '/';
 function firestoreModelIdentity(parentOrModelName, collectionNameOrModelName, inputCollectionName) {
-  var _a, _b;
   if (typeof parentOrModelName === 'object') {
-    const collectionName = (_a = inputCollectionName) !== null && _a !== void 0 ? _a : collectionNameOrModelName.toLowerCase();
+    const collectionName = inputCollectionName != null ? inputCollectionName : collectionNameOrModelName.toLowerCase();
     const collectionType = `${parentOrModelName.collectionType}/${collectionName}`;
     return {
       type: 'nested',
@@ -6013,7 +6197,7 @@ function firestoreModelIdentity(parentOrModelName, collectionNameOrModelName, in
       collectionType
     };
   } else {
-    const collectionName = (_b = collectionNameOrModelName) !== null && _b !== void 0 ? _b : parentOrModelName.toLowerCase();
+    const collectionName = collectionNameOrModelName != null ? collectionNameOrModelName : parentOrModelName.toLowerCase();
     const collectionType = collectionName;
     return {
       type: 'root',
@@ -6088,9 +6272,9 @@ function firestoreModelId(input) {
  * @returns
  */
 function firestoreModelIdsFromKey(input) {
-  var _a;
+  var _parts$map;
   const parts = firestoreModelKeyPartPairs(input);
-  return (_a = parts === null || parts === void 0 ? void 0 : parts.map(x => x.id)) !== null && _a !== void 0 ? _a : [];
+  return (_parts$map = parts == null ? void 0 : parts.map(x => x.id)) != null ? _parts$map : [];
 }
 /**
  * Creates a OneWayFlatFirestoreModelKey from the input FirestoreModelKey.
@@ -6255,8 +6439,8 @@ function firestoreModelKeyCollectionType(input) {
   return firestoreModelKeyCollectionTypeArrayName(input, FIRESTORE_COLLECTION_NAME_SEPARATOR);
 }
 function firestoreModelKeyCollectionTypeArrayName(input, separator = FIRESTORE_COLLECTION_NAME_SEPARATOR) {
-  var _a;
-  return (_a = firestoreModelKeyCollectionTypeArray(input)) === null || _a === void 0 ? void 0 : _a.join(separator);
+  var _firestoreModelKeyCol;
+  return (_firestoreModelKeyCol = firestoreModelKeyCollectionTypeArray(input)) == null ? void 0 : _firestoreModelKeyCol.join(separator);
 }
 function firestoreIdentityTypeArrayName(input, separator = FIRESTORE_COLLECTION_NAME_SEPARATOR) {
   return firestoreIdentityTypeArray(input).join(separator);
@@ -6278,7 +6462,7 @@ function firestoreModelKeyCollectionTypeArray(input) {
   const key = readFirestoreModelKey(input);
   let array;
   if (key) {
-    const pieces = key === null || key === void 0 ? void 0 : key.split(FIRESTORE_COLLECTION_NAME_SEPARATOR);
+    const pieces = key == null ? void 0 : key.split(FIRESTORE_COLLECTION_NAME_SEPARATOR);
     if (util.isOddNumber(pieces.length)) {
       throw new Error('input key source was a collection ref or unavailable.');
     }
@@ -6297,8 +6481,8 @@ function firestoreModelKeyCollectionTypeArray(input) {
  * @returns
  */
 function firestoreModelKeyCollectionName(input) {
-  var _a;
-  return (_a = firestoreModelKeyTypePair(input)) === null || _a === void 0 ? void 0 : _a.collectionName;
+  var _firestoreModelKeyTyp;
+  return (_firestoreModelKeyTyp = firestoreModelKeyTypePair(input)) == null ? void 0 : _firestoreModelKeyTyp.collectionName;
 }
 /**
  * Returns the parent model key from up the specified amount of levels.
@@ -6336,7 +6520,7 @@ function firestoreModelKeyPartPairs(input) {
   const key = readFirestoreModelKey(input);
   let pairs;
   if (key) {
-    const pieces = key === null || key === void 0 ? void 0 : key.split(FIRESTORE_COLLECTION_NAME_SEPARATOR);
+    const pieces = key == null ? void 0 : key.split(FIRESTORE_COLLECTION_NAME_SEPARATOR);
     if (util.isOddNumber(pieces.length)) {
       throw new Error('input key source was a collection ref or unavailable.');
     }
@@ -6418,13 +6602,13 @@ function makeFirestoreCollection(inputConfig) {
   const {
     query
   } = queryFactory;
-  return Object.assign(Object.assign({
+  return Object.assign({
     config,
     modelIdentity,
     collection,
     queryLike: collection,
     firestoreContext
-  }, documentAccessorExtension), {
+  }, documentAccessorExtension, {
     firestoreIteration,
     query,
     queryDocument
@@ -6464,12 +6648,12 @@ function makeFirestoreCollectionGroup(config) {
   const {
     query
   } = queryFactory;
-  return Object.assign(Object.assign({
+  return Object.assign({
     config,
     queryLike,
     modelIdentity,
     firestoreContext
-  }, documentAccessorExtension), {
+  }, documentAccessorExtension, {
     firestoreIteration,
     query,
     queryDocument
@@ -6487,7 +6671,7 @@ function makeFirestoreCollectionGroup(config) {
 function makeFirestoreCollectionWithParent(config) {
   const result = makeFirestoreCollection(config);
   result.parent = config.parent;
-  // todo: consider throwing an exception if parent is not provided.
+  // TODO: consider throwing an exception if parent is not provided.
   return result;
 }
 
@@ -6510,10 +6694,10 @@ function makeSingleItemFirestoreCollection(config) {
 function firestoreContextFactory(drivers) {
   return firestore => {
     const makeFirestoreCollectionConfig = config => {
-      var _a, _b;
-      const queryLike = (_a = config.collection) !== null && _a !== void 0 ? _a : config.queryLike;
-      return Object.assign(Object.assign({}, config), {
-        collection: config.converter ? (_b = config.collection) === null || _b === void 0 ? void 0 : _b.withConverter(config.converter) : config.collection,
+      var _config$collection, _config$collection2;
+      const queryLike = (_config$collection = config.collection) != null ? _config$collection : config.queryLike;
+      return Object.assign({}, config, {
+        collection: config.converter ? (_config$collection2 = config.collection) == null ? void 0 : _config$collection2.withConverter(config.converter) : config.collection,
         queryLike: config.converter ? queryLike.withConverter(config.converter) : queryLike,
         firestoreContext: context,
         firestoreDriverIdentifier: drivers.firestoreDriverIdentifier,
@@ -6678,6 +6862,27 @@ var addToUnscopables = addToUnscopables$2;
 // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
 addToUnscopables('flat');
 
+function _await$3(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function _async$3(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
 function firestoreIdBatchVerifierFactory(config) {
   const {
     readKeys
@@ -6685,12 +6890,13 @@ function firestoreIdBatchVerifierFactory(config) {
   const fieldToQuery = config.fieldToQuery;
   const makeQueryConstraints = config.makeQueryConstraints ? config.makeQueryConstraints : fieldToQuery === '_id' ? ids => whereDocumentId('in', ids) : ids => where(fieldToQuery, 'in', ids);
   return collection => {
-    const verify = keys => __awaiter(this, void 0, void 0, function* () {
+    const verify = _async$3(function (keys) {
       const constraints = makeQueryConstraints(keys);
-      const results = yield collection.query(constraints).getDocs();
-      const keysInResults = results.docs.map(x => readKeys(x)).flat();
-      const unusedKeys = util.unique(keys, keysInResults);
-      return unusedKeys;
+      return _await$3(collection.query(constraints).getDocs(), function (results) {
+        const keysInResults = results.docs.map(x => readKeys(x)).flat();
+        const unusedKeys = util.unique(keys, keysInResults);
+        return unusedKeys;
+      });
     });
     const verifier = {
       maxBatchSize: FIRESTORE_MAX_WHERE_IN_FILTER_ARGS_COUNT,
@@ -6721,13 +6927,14 @@ function createWithAccessor(accessor) {
  */
 function firestoreClientIncrementUpdateToUpdateData(input) {
   return util.mapObjectMap(input, incrementValue => {
-    return firestore.increment(incrementValue !== null && incrementValue !== void 0 ? incrementValue : 0);
+    return firestore.increment(incrementValue != null ? incrementValue : 0);
   });
 }
 
 // MARK: Accessor
 class DefaultFirestoreDocumentDataAccessor {
   constructor(documentRef) {
+    this.documentRef = void 0;
     this.documentRef = documentRef;
   }
   stream() {
@@ -6783,6 +6990,7 @@ function defaultFirestoreDocumentContext() {
 class WriteBatchFirestoreDocumentDataAccessor extends DefaultFirestoreDocumentDataAccessor {
   constructor(batch, documentRef) {
     super(documentRef);
+    this.batch = void 0;
     this.batch = batch;
   }
   delete() {
@@ -6813,8 +7021,10 @@ function writeBatchAccessorFactory(writeBatch) {
 // MARK: Context
 class WriteBatchFirestoreDocumentContext {
   constructor(batch) {
-    this.batch = batch;
+    this.batch = void 0;
     this.contextType = exports.FirestoreDocumentContextType.BATCH;
+    this.accessorFactory = void 0;
+    this.batch = batch;
     this.accessorFactory = writeBatchAccessorFactory(this.batch);
   }
 }
@@ -6828,6 +7038,8 @@ function writeBatchDocumentContext(batch) {
  */
 class TransactionFirestoreDocumentDataAccessor {
   constructor(transaction, documentRef) {
+    this.transaction = void 0;
+    this.documentRef = void 0;
     this.transaction = transaction;
     this.documentRef = documentRef;
   }
@@ -6878,8 +7090,10 @@ function transactionAccessorFactory(transaction) {
 // MARK: Context
 class TransactionFirestoreDocumentContext {
   constructor(transaction) {
-    this.transaction = transaction;
+    this.transaction = void 0;
     this.contextType = exports.FirestoreDocumentContextType.TRANSACTION;
+    this.accessorFactory = void 0;
+    this.transaction = transaction;
     this.accessorFactory = transactionAccessorFactory(this.transaction);
   }
 }
@@ -6887,6 +7101,18 @@ function transactionDocumentContext(transaction) {
   return new TransactionFirestoreDocumentContext(transaction);
 }
 
+function _async$2(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
 function firestoreClientAccessorDriver() {
   return {
     doc: firestore.doc,
@@ -6894,8 +7120,8 @@ function firestoreClientAccessorDriver() {
     collectionGroup: firestore.collectionGroup,
     collection: firestore.collection,
     subcollection: firestore.collection,
-    transactionFactoryForFirestore: firestore$1 => fn => __awaiter(this, void 0, void 0, function* () {
-      return yield firestore.runTransaction(firestore$1, fn);
+    transactionFactoryForFirestore: firestore$1 => _async$2(function (fn) {
+      return firestore.runTransaction(firestore$1, fn);
     }),
     writeBatchFactoryForFirestore: firestore$1 => () => firestore.writeBatch(firestore$1),
     defaultContextFactory: defaultFirestoreDocumentContext,
@@ -6940,7 +7166,7 @@ function firebaseFirestoreQueryConstraintFunctionsDriver() {
   });
 }
 function firebaseFirestoreQueryDriver() {
-  return Object.assign(Object.assign({}, firebaseFirestoreQueryConstraintFunctionsDriver()), {
+  return Object.assign({}, firebaseFirestoreQueryConstraintFunctionsDriver(), {
     countDocs(query) {
       return firestore.getCountFromServer(query).then(x => x.data().count);
     },
@@ -6983,6 +7209,7 @@ class FirebaseServerError extends util.ServerErrorResponse {
   }
   constructor(firebaseError, serverError) {
     super(serverError);
+    this.firebaseError = void 0;
     this.firebaseError = firebaseError;
   }
   get _error() {
@@ -6990,27 +7217,62 @@ class FirebaseServerError extends util.ServerErrorResponse {
   }
 }
 
+function _await$2(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function _catch(body, recover) {
+  try {
+    var result = body();
+  } catch (e) {
+    return recover(e);
+  }
+  if (result && result.then) {
+    return result.then(void 0, recover);
+  }
+  return result;
+}
+function _async$1(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
 function mapHttpsCallable(callable, wrap, directData = false) {
   const {
     mapInput = x => x,
     mapOutput = x => x
   } = wrap;
-  return inputData => __awaiter(this, void 0, void 0, function* () {
-    const data = yield mapInput(inputData);
-    try {
-      const result = yield callable(data);
-      const resultData = result.data;
-      const mappedResultData = yield mapOutput(resultData);
-      if (directData) {
-        return mappedResultData;
-      } else {
-        return Object.assign(Object.assign({}, result), {
-          data: mappedResultData
+  return _async$1(function (inputData) {
+    return _await$2(mapInput(inputData), function (data) {
+      return _catch(function () {
+        return _await$2(callable(data), function (result) {
+          const resultData = result.data;
+          return _await$2(mapOutput(resultData), function (mappedResultData) {
+            if (directData) {
+              return mappedResultData;
+            } else {
+              return Object.assign({}, result, {
+                data: mappedResultData
+              });
+            }
+          });
         });
-      }
-    } catch (e) {
-      throw convertHttpsCallableErrorToReadableError(e);
-    }
+      }, function (e) {
+        throw convertHttpsCallableErrorToReadableError(e);
+      });
+    });
   });
 }
 function directDataHttpsCallable(callable) {
@@ -7083,6 +7345,20 @@ function onCallTypedModelParamsFunction(call) {
     return result;
   };
 }
+/**
+ * Creates OnCallTypedModelParams for the input.
+ *
+ * Convenience function for calling onCallTypedModelParamsFunction and executing it with the input.
+ *
+ * @deprecated Move towards using onCallTypedModelParamsFunction directly with the call type instead of using this function. Will not be removed in the future.
+ *
+ * @param modelType
+ * @param data
+ * @returns
+ */
+function onCallTypedModelParams(modelTypeInput, data, specifier, call) {
+  return onCallTypedModelParamsFunction(call)(modelTypeInput, data, specifier);
+}
 /**
  * Pre-configured OnCallTypedModelParamsFunctions for 'create'
  */
@@ -7099,18 +7375,6 @@ const onCallUpdateModelParams = onCallTypedModelParamsFunction('update');
  * Pre-configured OnCallTypedModelParamsFunctions for 'delete'
  */
 const onCallDeleteModelParams = onCallTypedModelParamsFunction('delete');
-/**
- * Creates a OnCallTypedModelParams
- *
- * @deprecated use onCallTypedModelParamsFunction instead.
- *
- * @param modelType
- * @param data
- * @returns
- */
-function onCallTypedModelParams(modelTypeInput, data, specifier, call) {
-  return onCallTypedModelParamsFunction(call)(modelTypeInput, data, specifier);
-}
 /**
  * Key used on the front-end and backend that refers to the call function.
  */
@@ -7123,31 +7387,6 @@ function onCallCreateModelResult(modelKeys) {
     modelKeys: util.asArray(modelKeys)
   };
 }
-// MARK: Compat
-/**
- * Key used on the front-end and backend that refers to a specific function for creating models.
- *
- * @deprecated Replaced by the callModel function.
- */
-const CREATE_MODEL_APP_FUNCTION_KEY = 'createModel';
-/**
- * Key used on the front-end and backend that refers to a specific function for reading models.
- *
- * @deprecated Replaced by the callModel function.
- */
-const READ_MODEL_APP_FUNCTION_KEY = 'readModel';
-/**
- * Key used on the front-end and backend that refers to a specific function for updating models.
- *
- * @deprecated Replaced by the callModel function.
- */
-const UPDATE_MODEL_APP_FUNCTION_KEY = 'updateModel';
-/**
- * Key used on the front-end and backend that refers to a specific function for deleting models.
- *
- * @deprecated Replaced by the callModel function.
- */
-const DELETE_MODEL_APP_FUNCTION_KEY = 'deleteModel';
 
 const MODEL_FUNCTION_FIREBASE_CRUD_FUNCTION_SPECIFIER_DEFAULT = '_';
 const MODEL_FUNCTION_FIREBASE_CRUD_FUNCTION_SPECIFIER_SPLITTER = ',';
@@ -7165,7 +7404,7 @@ function callModelFirebaseFunctionMapFactory(configMap, crudConfigMap) {
     const _callFn = util.cachedGetter(() => functions.httpsCallable(functionsInstance, CALL_MODEL_APP_FUNCTION_KEY));
     function makeCallFunction(call, fn, modelType, specifier) {
       return mapHttpsCallable(fn(), {
-        mapInput: data => onCallTypedModelParams(modelType, data, specifier, call)
+        mapInput: data => onCallTypedModelParamsFunction(call)(modelType, data, specifier)
       }, true);
     }
     function makeCallSpecifiers(call, fn, modelType, specifierKeys) {
@@ -7234,94 +7473,6 @@ function callModelFirebaseFunctionMapFactory(configMap, crudConfigMap) {
     return result;
   };
 }
-// MARK: Compat
-/**
- * @deprecated move to using callModelFirebaseFunctionMapFactory instead and the call configuration in general.
- *
- * This will be removed in the next release.
- *
- * @param configMap
- * @param crudConfigMap
- * @returns
- */
-function modelFirebaseFunctionMapFactory(configMap, crudConfigMap) {
-  const functionFactory = firebaseFunctionMapFactory(configMap);
-  return functionsInstance => {
-    const functionMap = functionFactory(functionsInstance);
-    const _readFn = util.cachedGetter(() => functions.httpsCallable(functionsInstance, READ_MODEL_APP_FUNCTION_KEY));
-    const _createFn = util.cachedGetter(() => functions.httpsCallable(functionsInstance, CREATE_MODEL_APP_FUNCTION_KEY));
-    const _updateFn = util.cachedGetter(() => functions.httpsCallable(functionsInstance, UPDATE_MODEL_APP_FUNCTION_KEY));
-    const _deleteFn = util.cachedGetter(() => functions.httpsCallable(functionsInstance, DELETE_MODEL_APP_FUNCTION_KEY));
-    function makeCrudFunction(fn, modelType, specifier) {
-      return mapHttpsCallable(fn(), {
-        mapInput: data => onCallTypedModelParams(modelType, data, specifier)
-      }, true);
-    }
-    function makeCrudSpecifiers(crud, fn, modelType, specifierKeys) {
-      const modelTypeSuffix = util.capitalizeFirstLetter(modelType);
-      const specifiers = {};
-      specifierKeys.forEach(inputSpecifier => {
-        const specifier = inputSpecifier === MODEL_FUNCTION_FIREBASE_CRUD_FUNCTION_SPECIFIER_DEFAULT ? '' : inputSpecifier;
-        const specifierFn = makeCrudFunction(fn, modelType, inputSpecifier);
-        const fullSpecifierName = `${crud}${modelTypeSuffix}${util.capitalizeFirstLetter(specifier)}`;
-        specifiers[fullSpecifierName] = specifierFn;
-        const shortSpecifierName = util.lowercaseFirstLetter(specifier) || crud;
-        specifiers[shortSpecifierName] = specifierFn;
-      });
-      return specifiers;
-    }
-    const result = util.build({
-      base: functionMap,
-      build: x => {
-        Object.entries(crudConfigMap).forEach(([modelType, config]) => {
-          const modelTypeSuffix = util.capitalizeFirstLetter(modelType);
-          const {
-            included: crudFunctionKeys,
-            excluded: specifiedCrudFunctionKeys
-          } = util.separateValues(config, x => x.indexOf(':') === -1);
-          const crudFunctions = new Set(crudFunctionKeys);
-          const specifiedCrudFunctionTuples = specifiedCrudFunctionKeys.map(x => {
-            const [crud, functionsSplit] = x.split(':', 2);
-            const functions = functionsSplit.split(MODEL_FUNCTION_FIREBASE_CRUD_FUNCTION_SPECIFIER_SPLITTER);
-            return [crud, functions];
-          });
-          // check that there isn't a repeat crud key configured, which disallowed configuration and would cause some functions to be ignored
-          const encounteredCruds = new Set();
-          function assertCrudKeyNotEncountered(crud) {
-            if (encounteredCruds.has(crud)) {
-              throw new Error(`Cannot have multiple declarations of the same crud. Found repeat for crud: ${crud}`);
-            } else {
-              encounteredCruds.add(crud);
-            }
-          }
-          crudFunctions.forEach(assertCrudKeyNotEncountered);
-          specifiedCrudFunctionTuples.forEach(([crud]) => assertCrudKeyNotEncountered(crud));
-          // build and add the functions
-          const specifierFunctions = new Map(specifiedCrudFunctionTuples);
-          function addFunctions(crud, fn, modelType) {
-            let crudFns;
-            if (crudFunctions.has(crud)) {
-              crudFns = makeCrudFunction(fn, modelType);
-            } else if (specifierFunctions.has(crud)) {
-              crudFns = makeCrudSpecifiers(crud, fn, modelType, specifierFunctions.get(crud));
-            }
-            if (crudFns) {
-              modelTypeCruds[`${crud}${modelTypeSuffix}`] = crudFns;
-            }
-          }
-          const modelTypeCruds = {};
-          addFunctions('create', _createFn, modelType);
-          addFunctions('read', _readFn, modelType);
-          addFunctions('update', _updateFn, modelType);
-          addFunctions('delete', _deleteFn, modelType);
-          // tslint:disable-next-line
-          x[modelType] = modelTypeCruds;
-        });
-      }
-    });
-    return result;
-  };
-}
 
 /**
  * Creates an OnCallDevelopmentParams
@@ -7443,8 +7594,8 @@ const FIREBASE_SERVER_AUTH_CLAIMS_RESET_LAST_COM_DATE_KEY = 'resetCommunicationA
 
 const useContextAuth = util.mappedUseFunction(x => x.auth);
 const useContextAuthUid = util.mappedUseFunction(x => {
-  var _a;
-  return (_a = x.auth) === null || _a === void 0 ? void 0 : _a.uid;
+  var _x$auth;
+  return (_x$auth = x.auth) == null ? void 0 : _x$auth.uid;
 });
 
 const FIREBASE_AUTH_USER_NOT_FOUND_ERROR = 'auth/user-not-found';
@@ -7484,15 +7635,58 @@ function firebaseAuthErrorToReadableError(inputError) {
   return error;
 }
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 exports.ScheduledFunctionDevelopmentFunctionTypeEnum = void 0;
 (function (ScheduledFunctionDevelopmentFunctionTypeEnum) {
   ScheduledFunctionDevelopmentFunctionTypeEnum["LIST"] = "list";
   ScheduledFunctionDevelopmentFunctionTypeEnum["RUN"] = "run";
 })(exports.ScheduledFunctionDevelopmentFunctionTypeEnum || (exports.ScheduledFunctionDevelopmentFunctionTypeEnum = {}));
-class ScheduledFunctionDevelopmentFirebaseFunctionParams {}
+class ScheduledFunctionDevelopmentFirebaseFunctionParams {
+  constructor() {
+    this.type = void 0;
+    /**
+     * Name of function to run.
+     */
+    this.run = void 0;
+  }
+}
 __decorate([classTransformer.Expose(), classValidator.IsEnum(exports.ScheduledFunctionDevelopmentFunctionTypeEnum), __metadata("design:type", String)], ScheduledFunctionDevelopmentFirebaseFunctionParams.prototype, "type", void 0);
 __decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.IsOptional(), __metadata("design:type", String)], ScheduledFunctionDevelopmentFirebaseFunctionParams.prototype, "run", void 0);
-class ScheduledFunctionDevelopmentFirebaseFunctionListEntry {}
+class ScheduledFunctionDevelopmentFirebaseFunctionListEntry {
+  constructor() {
+    this.name = void 0;
+  }
+}
 /**
  * Key used on the front-end and backend that refers to the specifier for the scheduled functions access.
  */
@@ -7526,7 +7720,7 @@ function IsFirestoreModelKey(validationOptions) {
       options: validationOptions,
       validator: {
         validate: isFirestoreModelKey,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args === null || args === void 0 ? void 0 : args.value}" is not a FirestoreModelKey.`, validationOptions)
+        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args == null ? void 0 : args.value}" is not a FirestoreModelKey.`, validationOptions)
       }
     });
   };
@@ -7543,7 +7737,7 @@ function IsFirestoreModelId(validationOptions) {
       options: validationOptions,
       validator: {
         validate: isFirestoreModelId,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args === null || args === void 0 ? void 0 : args.value}" is not a FirestoreModelId.`, validationOptions)
+        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args == null ? void 0 : args.value}" is not a FirestoreModelId.`, validationOptions)
       }
     });
   };
@@ -7560,7 +7754,7 @@ function IsFirestoreModelIdOrKey(validationOptions) {
       options: validationOptions,
       validator: {
         validate: isFirestoreModelIdOrKey,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args === null || args === void 0 ? void 0 : args.value}" is not a FirestoreModelId or FirestoreModelKey.`, validationOptions)
+        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args == null ? void 0 : args.value}" is not a FirestoreModelId or FirestoreModelKey.`, validationOptions)
       }
     });
   };
@@ -7569,40 +7763,79 @@ function IsFirestoreModelIdOrKey(validationOptions) {
 /**
  * Simple annotated params that implements FirestoreModelKeyRef.
  */
-class TargetModelParams {}
+class TargetModelParams {
+  constructor() {
+    this.key = void 0;
+  }
+}
 __decorate([classTransformer.Expose(), classValidator.IsNotEmpty(), IsFirestoreModelKey(), __metadata("design:type", String)], TargetModelParams.prototype, "key", void 0);
-class InferredTargetModelParams {}
+class InferredTargetModelParams {
+  constructor() {
+    this.key = void 0;
+  }
+}
 __decorate([classTransformer.Expose(), classValidator.IsOptional(), classValidator.IsNotEmpty(), IsFirestoreModelKey(), __metadata("design:type", String)], InferredTargetModelParams.prototype, "key", void 0);
 /**
  * Simple annotated params that implements FirestoreModelKeyRef but key is a FirestoreModelId.
  */
-class TargetModelIdParams {}
+class TargetModelIdParams {
+  constructor() {
+    this.key = void 0;
+  }
+}
 __decorate([classTransformer.Expose(), classValidator.IsNotEmpty(), IsFirestoreModelId(), __metadata("design:type", String)], TargetModelIdParams.prototype, "key", void 0);
-class InferredTargetModelIdParams {}
+class InferredTargetModelIdParams {
+  constructor() {
+    this.key = void 0;
+  }
+}
 __decorate([classTransformer.Expose(), classValidator.IsOptional(), classValidator.IsNotEmpty(), IsFirestoreModelId(), __metadata("design:type", String)], InferredTargetModelIdParams.prototype, "key", void 0);
 
 /**
  * Abstract AbstractModelPermissionService implementation for FirebaseModelsPermissionService.
  */
+
+function _await$1(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function _call(body, then, direct) {
+  if (direct) {
+    return then ? then(body()) : body();
+  }
+  try {
+    var result = Promise.resolve(body());
+    return then ? result.then(then) : result;
+  } catch (e) {
+    return Promise.reject(e);
+  }
+}
 class FirebaseModelPermissionServiceInstance extends model.AbstractModelPermissionService {
   constructor(delegate) {
     super(delegate);
+    this.delegate = void 0;
     this.delegate = delegate;
   }
   roleMapForModel(output, context, model) {
     return this.delegate.roleMapForModel(output, context, model);
   }
   outputForModel(document) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const snapshot = yield document.accessor.get();
-      const data = snapshot.data();
-      const model = {
-        document,
-        snapshot,
-        data,
-        exists: data != null
-      };
-      return model;
+    return _call(function () {
+      return _await$1(document.accessor.get(), function (snapshot) {
+        const data = snapshot.data();
+        const model = {
+          document,
+          snapshot,
+          data,
+          exists: data != null
+        };
+        return model;
+      });
     });
   }
   isUsableOutputForRoles(output) {
@@ -7615,6 +7848,8 @@ function firebaseModelPermissionService(delegate) {
 
 class ContextGrantedModelRolesReaderInstance {
   constructor(contextGrantedModelRoles) {
+    this.contextGrantedModelRoles = void 0;
+    this._roleReader = void 0;
     this.contextGrantedModelRoles = contextGrantedModelRoles;
     this._roleReader = model.grantedRoleMapReader(contextGrantedModelRoles.roleMap);
   }
@@ -7676,13 +7911,13 @@ class ContextGrantedModelRolesReaderInstance {
     return this;
   }
   throwDoesNotExistError() {
-    var _a, _b, _c;
-    const error = (_c = (_b = (_a = this.contextGrantedModelRoles.context).makeDoesNotExistError) === null || _b === void 0 ? void 0 : _b.call(_a, this.contextGrantedModelRoles)) !== null && _c !== void 0 ? _c : new Error(contextGrantedModelRolesReaderDoesNotExistErrorMessage(this.contextGrantedModelRoles));
+    var _this$contextGrantedM, _this$contextGrantedM2, _this$contextGrantedM3;
+    const error = (_this$contextGrantedM = (_this$contextGrantedM2 = (_this$contextGrantedM3 = this.contextGrantedModelRoles.context).makeDoesNotExistError) == null ? void 0 : _this$contextGrantedM2.call(_this$contextGrantedM3, this.contextGrantedModelRoles)) != null ? _this$contextGrantedM : new Error(contextGrantedModelRolesReaderDoesNotExistErrorMessage(this.contextGrantedModelRoles));
     throw error;
   }
   throwPermissionError(role) {
-    var _a, _b, _c;
-    const error = (_c = (_b = (_a = this.contextGrantedModelRoles.context).makePermissionError) === null || _b === void 0 ? void 0 : _b.call(_a, this.contextGrantedModelRoles, role)) !== null && _c !== void 0 ? _c : new Error(contextGrantedModelRolesReaderPermissionErrorMessage(this.contextGrantedModelRoles, role));
+    var _this$contextGrantedM4, _this$contextGrantedM5, _this$contextGrantedM6;
+    const error = (_this$contextGrantedM4 = (_this$contextGrantedM5 = (_this$contextGrantedM6 = this.contextGrantedModelRoles.context).makePermissionError) == null ? void 0 : _this$contextGrantedM5.call(_this$contextGrantedM6, this.contextGrantedModelRoles, role)) != null ? _this$contextGrantedM4 : new Error(contextGrantedModelRolesReaderPermissionErrorMessage(this.contextGrantedModelRoles, role));
     throw error;
   }
 }
@@ -7700,9 +7935,9 @@ function contextGrantedModelRolesReader(service) {
  * @returns
  */
 function contextGrantedModelRolesReaderPermissionErrorMessage(contextGrantedModelRoles, roles) {
-  var _a, _b;
-  let message = `Permissions Error ("${(_a = contextGrantedModelRoles.data) === null || _a === void 0 ? void 0 : _a.document.modelType}":"${(_b = contextGrantedModelRoles.data) === null || _b === void 0 ? void 0 : _b.document.id}")`;
-  if (roles && (roles === null || roles === void 0 ? void 0 : roles.length)) {
+  var _contextGrantedModelR, _contextGrantedModelR2;
+  let message = `Permissions Error ("${(_contextGrantedModelR = contextGrantedModelRoles.data) == null ? void 0 : _contextGrantedModelR.document.modelType}":"${(_contextGrantedModelR2 = contextGrantedModelRoles.data) == null ? void 0 : _contextGrantedModelR2.document.id}")`;
+  if (roles && roles != null && roles.length) {
     message = `${message}: required role(s) "${roles}"`;
   }
   return message;
@@ -7715,8 +7950,8 @@ function contextGrantedModelRolesReaderPermissionErrorMessage(contextGrantedMode
  * @returns
  */
 function contextGrantedModelRolesReaderDoesNotExistErrorMessage(contextGrantedModelRoles) {
-  var _a, _b;
-  const message = `Does Not Exist ("${(_a = contextGrantedModelRoles.data) === null || _a === void 0 ? void 0 : _a.document.modelType}":"${(_b = contextGrantedModelRoles.data) === null || _b === void 0 ? void 0 : _b.document.id}")`;
+  var _contextGrantedModelR3, _contextGrantedModelR4;
+  const message = `Does Not Exist ("${(_contextGrantedModelR3 = contextGrantedModelRoles.data) == null ? void 0 : _contextGrantedModelR3.document.modelType}":"${(_contextGrantedModelR4 = contextGrantedModelRoles.data) == null ? void 0 : _contextGrantedModelR4.document.id}")`;
   return message;
 }
 
@@ -7727,18 +7962,54 @@ function contextGrantedModelRolesReaderDoesNotExistErrorMessage(contextGrantedMo
  * @param context
  * @returns
  */
+
+function _await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+} /**
+   * Convenience function that checks the input context if the user is an admin or not and grants pre-set admin roles if they are.
+   *
+   * @param context
+   * @param rolesToGrantToAdmin
+   * @param otherwise
+   * @returns
+   */
+
+function _empty() {}
+function _invokeIgnored(body) {
+  var result = body();
+  if (result && result.then) {
+    return result.then(_empty);
+  }
+}
+function _invoke(body, then) {
+  var result = body();
+  if (result && result.then) {
+    return result.then(then);
+  }
+  return then(result);
+}
+function _async(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
 const isAdminInFirebaseModelContext = context => {
-  var _a, _b;
-  return (_b = (_a = context.auth) === null || _a === void 0 ? void 0 : _a.isAdmin()) !== null && _b !== void 0 ? _b : false;
+  var _context$auth$isAdmin, _context$auth;
+  return (_context$auth$isAdmin = (_context$auth = context.auth) == null ? void 0 : _context$auth.isAdmin()) != null ? _context$auth$isAdmin : false;
 };
-/**
- * Convenience function that checks the input context if the user is an admin or not and grants pre-set admin roles if they are.
- *
- * @param context
- * @param rolesToGrantToAdmin
- * @param otherwise
- * @returns
- */
 function grantModelRolesIfAdminFunction(rolesToGrantToAdmin) {
   return grantModelRolesIfFunction(isAdminInFirebaseModelContext, rolesToGrantToAdmin);
 }
@@ -7760,8 +8031,8 @@ function grantModelRolesIfAdmin(context, rolesToGrantToAdmin, otherwise) {
  */
 function grantModelRolesIfHasAuthRolesFunction(authRoles, rolesToGrantToAdmin) {
   return grantModelRolesIfFunction(context => {
-    var _a;
-    const currentAuthRoles = (_a = context.auth) === null || _a === void 0 ? void 0 : _a.getAuthRoles();
+    var _context$auth2;
+    const currentAuthRoles = (_context$auth2 = context.auth) == null ? void 0 : _context$auth2.getAuthRoles();
     if (currentAuthRoles) {
       return util.setContainsAllValues(currentAuthRoles, authRoles);
     } else {
@@ -7781,22 +8052,32 @@ function grantModelRolesIfHasAuthRolesFactory(authRoles) {
  * @param context
  * @returns
  */
-const isOwnerOfUserRelatedModelInFirebaseModelContext = context => __awaiter(void 0, void 0, void 0, function* () {
+const isOwnerOfUserRelatedModelInFirebaseModelContext = _async(function (context) {
   let decision = false;
   const auth = context.context.auth;
-  if (auth != null) {
-    let model = context.model;
-    if (!model) {
-      const document = context.document;
-      if (document) {
-        model = (yield document.accessor.get()).data();
-      }
-    }
-    if (model) {
-      decision = auth.uid === model.uid;
+  return _invoke(function () {
+    if (auth != null) {
+      let model = context.model;
+      return _invoke(function () {
+        if (!model) {
+          const document = context.document;
+          return _invokeIgnored(function () {
+            if (document) {
+              return _await(document.accessor.get(), function (_document$accessor$ge) {
+                model = _document$accessor$ge.data();
+              });
+            }
+          });
+        }
+      }, function () {
+        if (model) {
+          decision = auth.uid === model.uid;
+        }
+      });
     }
-  }
-  return decision;
+  }, function () {
+    return decision;
+  });
 });
 /**
  * Creates a GrantRolesIfFunction that grants roles if the user is related to the model by uid.
@@ -7835,11 +8116,12 @@ function grantModelRolesIfFunction(grantIf, grantedRoles) {
   if (!grantIf) {
     throw new Error('missing grant if');
   }
-  return (context, otherwise = model.noAccessRoleMap) => __awaiter(this, void 0, void 0, function* () {
-    var _a;
-    const decision = yield grantIf(context);
-    const results = decision ? yield util.getValueFromGetter(grantedRoles) : (_a = yield otherwise()) !== null && _a !== void 0 ? _a : model.noAccessRoleMap();
-    return results;
+  return _async(function (context, otherwise = model.noAccessRoleMap) {
+    return _await(grantIf(context), function (decision) {
+      return _await(decision ? util.getValueFromGetter(grantedRoles) : 0, function (_getValueFromGetter) {
+        return _await(decision ? _getValueFromGetter : otherwise(), void 0, decision);
+      }, !decision);
+    });
   });
 }
 
@@ -7916,7 +8198,7 @@ function inContextFirebaseModelServiceFactory(factory) {
 function firebaseModelsService(services) {
   const firebaseModelsServiceFunction = (type, context) => {
     const firebaseModelService = services[type];
-    const contextWithService = Object.assign(Object.assign({}, context), {
+    const contextWithService = Object.assign({}, context, {
       service: firebaseModelsServiceFunction
     });
     const service = inContextFirebaseModelServiceFactory(firebaseModelService)(contextWithService);
@@ -7981,7 +8263,7 @@ const MODEL_STORAGE_FILE_SLASH_PATH_FACTORY = util.slashPathFactory({
 function modelStorageSlashPathFactory(config) {
   const {
     basePath
-  } = config !== null && config !== void 0 ? config : {};
+  } = config != null ? config : {};
   return (input, path) => {
     const key = readFirestoreModelKey(input, true);
     return MODEL_STORAGE_FILE_SLASH_PATH_FACTORY([basePath, key, path]);
@@ -7989,7 +8271,7 @@ function modelStorageSlashPathFactory(config) {
 }
 
 function assertStorageUploadOptionsStringFormat(options) {
-  const stringFormat = options === null || options === void 0 ? void 0 : options.stringFormat;
+  const stringFormat = options == null ? void 0 : options.stringFormat;
   if (!stringFormat) {
     throw noStringFormatInStorageUploadOptionsError();
   }
@@ -8042,12 +8324,11 @@ function storageListFilesResultHasNoNextError() {
  */
 function firebaseStorageContextFactory(drivers) {
   return (firebaseStorage, config) => {
-    var _a, _b;
     const {
       defaultBucketId: inputDefaultBucketId,
       forceBucket = false
-    } = config !== null && config !== void 0 ? config : {};
-    const defaultBucketId = inputDefaultBucketId || ((_b = (_a = drivers.storageAccessorDriver).defaultBucket) === null || _b === void 0 ? void 0 : _b.call(_a, firebaseStorage)) || '';
+    } = config != null ? config : {};
+    const defaultBucketId = inputDefaultBucketId || (drivers.storageAccessorDriver.defaultBucket == null ? void 0 : drivers.storageAccessorDriver.defaultBucket(firebaseStorage)) || '';
     if (!defaultBucketId) {
       throw new Error('Could not resolve a default bucket id for the firebaseStorageContextFactory(). Supply a defaultBucketId.');
     }
@@ -8085,9 +8366,9 @@ function firebaseStorageClientAccessorFile(storage$1, storagePath) {
         metadata
       } = options;
       if (options.contentType || options.metadata) {
-        result = Object.assign(Object.assign({}, contentType ? {
+        result = Object.assign({}, contentType ? {
           contentType
-        } : undefined), metadata);
+        } : undefined, metadata);
       }
     }
     return result;
@@ -8129,7 +8410,7 @@ const firebaseStorageClientListFilesResultFactory = storageListFilesResultFactor
     return result.listResult.nextPageToken != null;
   },
   next(storage, folder, result) {
-    return folder.list(Object.assign(Object.assign({}, result.options), {
+    return folder.list(Object.assign({}, result.options, {
       pageToken: result.listResult.nextPageToken
     }));
   },
@@ -8176,8 +8457,8 @@ function firebaseStorageClientAccessorFolder(storage$1, storagePath) {
 function firebaseStorageClientAccessorDriver() {
   return {
     defaultBucket: storage => {
-      var _a;
-      return (_a = storage.app.options.storageBucket) !== null && _a !== void 0 ? _a : '';
+      var _storage$app$options$;
+      return (_storage$app$options$ = storage.app.options.storageBucket) != null ? _storage$app$options$ : '';
     },
     file: (storage, path) => firebaseStorageClientAccessorFile(storage, path),
     folder: (storage, path) => firebaseStorageClientAccessorFolder(storage, path)
@@ -8246,7 +8527,6 @@ exports.AbstractFirestoreDocumentWithParent = AbstractFirestoreDocumentWithParen
 exports.BASE_MODEL_STORAGE_FILE_PATH = BASE_MODEL_STORAGE_FILE_PATH;
 exports.CALL_MODEL_APP_FUNCTION_KEY = CALL_MODEL_APP_FUNCTION_KEY;
 exports.COPY_USER_RELATED_DATA_ACCESSOR_FACTORY_FUNCTION = COPY_USER_RELATED_DATA_ACCESSOR_FACTORY_FUNCTION;
-exports.CREATE_MODEL_APP_FUNCTION_KEY = CREATE_MODEL_APP_FUNCTION_KEY;
 exports.ContextGrantedModelRolesReaderInstance = ContextGrantedModelRolesReaderInstance;
 exports.DEFAULT_DATE_CELL_RANGE_VALUE = DEFAULT_DATE_CELL_RANGE_VALUE;
 exports.DEFAULT_FIRESTORE_DATE_CELL_SCHEDULE_VALUE = DEFAULT_FIRESTORE_DATE_CELL_SCHEDULE_VALUE;
@@ -8258,7 +8538,6 @@ exports.DEFAULT_ITERATE_FIRESTORE_DOCUMENT_SNAPSHOT_BATCHES_BATCH_SIZE = DEFAULT
 exports.DEFAULT_QUERY_CHANGE_WATCHER_DELAY = DEFAULT_QUERY_CHANGE_WATCHER_DELAY;
 exports.DEFAULT_SINGLE_ITEM_FIRESTORE_COLLECTION_DOCUMENT_IDENTIFIER = DEFAULT_SINGLE_ITEM_FIRESTORE_COLLECTION_DOCUMENT_IDENTIFIER;
 exports.DEFAULT_WEBSITE_LINK = DEFAULT_WEBSITE_LINK;
-exports.DELETE_MODEL_APP_FUNCTION_KEY = DELETE_MODEL_APP_FUNCTION_KEY;
 exports.FIREBASE_AUTH_NETWORK_REQUEST_ERROR = FIREBASE_AUTH_NETWORK_REQUEST_ERROR;
 exports.FIREBASE_AUTH_NETWORK_REQUEST_FAILED = FIREBASE_AUTH_NETWORK_REQUEST_FAILED;
 exports.FIREBASE_AUTH_PASSWORD_MAX_LENGTH = FIREBASE_AUTH_PASSWORD_MAX_LENGTH;
@@ -8309,7 +8588,6 @@ exports.MODEL_FUNCTION_FIREBASE_CRUD_FUNCTION_SPECIFIER_DEFAULT = MODEL_FUNCTION
 exports.MODEL_FUNCTION_FIREBASE_CRUD_FUNCTION_SPECIFIER_SPLITTER = MODEL_FUNCTION_FIREBASE_CRUD_FUNCTION_SPECIFIER_SPLITTER;
 exports.MODEL_STORAGE_FILE_SLASH_PATH_FACTORY = MODEL_STORAGE_FILE_SLASH_PATH_FACTORY;
 exports.ModifyBeforeSetFirestoreDocumentDataAccessorWrapper = ModifyBeforeSetFirestoreDocumentDataAccessorWrapper;
-exports.READ_MODEL_APP_FUNCTION_KEY = READ_MODEL_APP_FUNCTION_KEY;
 exports.RUN_DEV_FUNCTION_APP_FUNCTION_KEY = RUN_DEV_FUNCTION_APP_FUNCTION_KEY;
 exports.SCHEDULED_FUNCTION_DEV_FUNCTION_SPECIFIER = SCHEDULED_FUNCTION_DEV_FUNCTION_SPECIFIER;
 exports.ScheduledFunctionDevelopmentFirebaseFunctionListEntry = ScheduledFunctionDevelopmentFirebaseFunctionListEntry;
@@ -8318,7 +8596,6 @@ exports.SystemStateDocument = SystemStateDocument;
 exports.SystemStateFirestoreCollections = SystemStateFirestoreCollections;
 exports.TargetModelIdParams = TargetModelIdParams;
 exports.TargetModelParams = TargetModelParams;
-exports.UPDATE_MODEL_APP_FUNCTION_KEY = UPDATE_MODEL_APP_FUNCTION_KEY;
 exports.addConstraintToBuilder = addConstraintToBuilder;
 exports.addOrReplaceLimitInConstraints = addOrReplaceLimitInConstraints;
 exports.allChildDocumentsUnderParent = allChildDocumentsUnderParent;
@@ -8551,7 +8828,6 @@ exports.makeRootSingleItemFirestoreCollection = makeRootSingleItemFirestoreColle
 exports.makeSingleItemFirestoreCollection = makeSingleItemFirestoreCollection;
 exports.mapDataFromSnapshot = mapDataFromSnapshot;
 exports.mapHttpsCallable = mapHttpsCallable;
-exports.modelFirebaseFunctionMapFactory = modelFirebaseFunctionMapFactory;
 exports.modelStorageSlashPathFactory = modelStorageSlashPathFactory;
 exports.modifyBeforeSetInterceptAccessorFactoryFunction = modifyBeforeSetInterceptAccessorFactoryFunction;
 exports.newDocuments = newDocuments;