@dereekb/firebase 12.4.4 → 12.5.0

package/index.cjs.js

@@ -10,6 +10,7 @@ var functions = require('firebase/functions');
 var storage = require('firebase/storage');
 var classTransformer = require('class-transformer');
 var classValidator = require('class-validator');
+var fetch = require('@dereekb/util/fetch');
 var dateFns = require('date-fns');
 
 /**
@@ -651,10 +652,11 @@ function firestoreSingleDocumentAccessor(config) {
     singleItemIdentifier,
     accessors
   } = config;
+  const defaultAccessor = accessors.documentAccessor();
   return {
     singleItemIdentifier,
     loadDocument() {
-      return accessors.documentAccessor().loadDocumentForId(singleItemIdentifier);
+      return defaultAccessor.loadDocumentForId(singleItemIdentifier);
     },
     loadDocumentForTransaction(transaction) {
       return accessors.documentAccessorForTransaction(transaction).loadDocumentForId(singleItemIdentifier);
@@ -663,7 +665,7 @@ function firestoreSingleDocumentAccessor(config) {
       return accessors.documentAccessorForWriteBatch(writeBatch).loadDocumentForId(singleItemIdentifier);
     },
     documentRef() {
-      return accessors.documentAccessor().documentRefForId(singleItemIdentifier);
+      return defaultAccessor.documentRefForId(singleItemIdentifier);
     }
   };
 }
@@ -4681,6 +4683,199 @@ $$2({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {
   }
 });
 
+var classofRaw$1 = classofRaw$2;
+var uncurryThis$1 = functionUncurryThis;
+
+var functionUncurryThisClause = function (fn) {
+  // Nashorn bug:
+  //   https://github.com/zloirock/core-js/issues/1128
+  //   https://github.com/zloirock/core-js/issues/1130
+  if (classofRaw$1(fn) === 'Function') return uncurryThis$1(fn);
+};
+
+var uncurryThis = functionUncurryThisClause;
+var aCallable$3 = aCallable$9;
+var NATIVE_BIND = functionBindNative;
+
+var bind$1 = uncurryThis(uncurryThis.bind);
+
+// optional / simple context binding
+var functionBindContext = function (fn, that) {
+  aCallable$3(fn);
+  return that === undefined ? fn : NATIVE_BIND ? bind$1(fn, that) : function (/* ...args */) {
+    return fn.apply(that, arguments);
+  };
+};
+
+var iterators = {};
+
+var wellKnownSymbol$3 = wellKnownSymbol$8;
+var Iterators$1 = iterators;
+
+var ITERATOR$1 = wellKnownSymbol$3('iterator');
+var ArrayPrototype = Array.prototype;
+
+// check on default Array iterator
+var isArrayIteratorMethod$1 = function (it) {
+  return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$1] === it);
+};
+
+var wellKnownSymbol$2 = wellKnownSymbol$8;
+
+var TO_STRING_TAG$1 = wellKnownSymbol$2('toStringTag');
+var test = {};
+
+test[TO_STRING_TAG$1] = 'z';
+
+var toStringTagSupport = String(test) === '[object z]';
+
+var TO_STRING_TAG_SUPPORT = toStringTagSupport;
+var isCallable = isCallable$e;
+var classofRaw = classofRaw$2;
+var wellKnownSymbol$1 = wellKnownSymbol$8;
+
+var TO_STRING_TAG = wellKnownSymbol$1('toStringTag');
+var $Object = Object;
+
+// ES3 wrong here
+var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';
+
+// fallback for IE11 Script Access Denied error
+var tryGet = function (it, key) {
+  try {
+    return it[key];
+  } catch (error) { /* empty */ }
+};
+
+// getting tag from ES6+ `Object.prototype.toString`
+var classof$1 = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
+  var O, tag, result;
+  return it === undefined ? 'Undefined' : it === null ? 'Null'
+    // @@toStringTag case
+    : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
+    // builtinTag case
+    : CORRECT_ARGUMENTS ? classofRaw(O)
+    // ES3 arguments fallback
+    : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;
+};
+
+var classof = classof$1;
+var getMethod = getMethod$4;
+var isNullOrUndefined = isNullOrUndefined$3;
+var Iterators = iterators;
+var wellKnownSymbol = wellKnownSymbol$8;
+
+var ITERATOR = wellKnownSymbol('iterator');
+
+var getIteratorMethod$2 = function (it) {
+  if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
+    || getMethod(it, '@@iterator')
+    || Iterators[classof(it)];
+};
+
+var call$1 = functionCall;
+var aCallable$2 = aCallable$9;
+var anObject$3 = anObject$e;
+var tryToString$1 = tryToString$3;
+var getIteratorMethod$1 = getIteratorMethod$2;
+
+var $TypeError$1 = TypeError;
+
+var getIterator$1 = function (argument, usingIterator) {
+  var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator;
+  if (aCallable$2(iteratorMethod)) return anObject$3(call$1(iteratorMethod, argument));
+  throw new $TypeError$1(tryToString$1(argument) + ' is not iterable');
+};
+
+var bind = functionBindContext;
+var call = functionCall;
+var anObject$2 = anObject$e;
+var tryToString = tryToString$3;
+var isArrayIteratorMethod = isArrayIteratorMethod$1;
+var lengthOfArrayLike = lengthOfArrayLike$3;
+var isPrototypeOf = objectIsPrototypeOf;
+var getIterator = getIterator$1;
+var getIteratorMethod = getIteratorMethod$2;
+var iteratorClose = iteratorClose$5;
+
+var $TypeError = TypeError;
+
+var Result = function (stopped, result) {
+  this.stopped = stopped;
+  this.result = result;
+};
+
+var ResultPrototype = Result.prototype;
+
+var iterate$2 = function (iterable, unboundFunction, options) {
+  var that = options && options.that;
+  var AS_ENTRIES = !!(options && options.AS_ENTRIES);
+  var IS_RECORD = !!(options && options.IS_RECORD);
+  var IS_ITERATOR = !!(options && options.IS_ITERATOR);
+  var INTERRUPTED = !!(options && options.INTERRUPTED);
+  var fn = bind(unboundFunction, that);
+  var iterator, iterFn, index, length, result, next, step;
+
+  var stop = function (condition) {
+    if (iterator) iteratorClose(iterator, 'normal', condition);
+    return new Result(true, condition);
+  };
+
+  var callFn = function (value) {
+    if (AS_ENTRIES) {
+      anObject$2(value);
+      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
+    } return INTERRUPTED ? fn(value, stop) : fn(value);
+  };
+
+  if (IS_RECORD) {
+    iterator = iterable.iterator;
+  } else if (IS_ITERATOR) {
+    iterator = iterable;
+  } else {
+    iterFn = getIteratorMethod(iterable);
+    if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');
+    // optimisation for array iterators
+    if (isArrayIteratorMethod(iterFn)) {
+      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
+        result = callFn(iterable[index]);
+        if (result && isPrototypeOf(ResultPrototype, result)) return result;
+      } return new Result(false);
+    }
+    iterator = getIterator(iterable, iterFn);
+  }
+
+  next = IS_RECORD ? iterable.next : iterator.next;
+  while (!(step = call(next, iterator)).done) {
+    try {
+      result = callFn(step.value);
+    } catch (error) {
+      iteratorClose(iterator, 'throw', error);
+    }
+    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
+  } return new Result(false);
+};
+
+var $$1 = _export;
+var iterate$1 = iterate$2;
+var aCallable$1 = aCallable$9;
+var anObject$1 = anObject$e;
+var getIteratorDirect$1 = getIteratorDirect$5;
+
+// `Iterator.prototype.forEach` method
+// https://github.com/tc39/proposal-iterator-helpers
+$$1({ target: 'Iterator', proto: true, real: true }, {
+  forEach: function forEach(fn) {
+    anObject$1(this);
+    aCallable$1(fn);
+    var record = getIteratorDirect$1(this);
+    var counter = 0;
+    iterate$1(record, function (value) {
+      fn(value, counter++);
+    }, { IS_RECORD: true });
+  }
+});
+
 /**
  * Filters out constraints that should not be directly specified in pagination queries.
  *
@@ -4855,6 +5050,9 @@ const FIRESTORE_ITEM_PAGE_ITERATOR = new rxjs$1.ItemPageIterator(FIRESTORE_ITEM_
  */
 function firestoreItemPageIteration(config) {
   const snapshotIteration = FIRESTORE_ITEM_PAGE_ITERATOR.instance(config);
+  return _firestoreItemPageIterationWithSnapshotIteration(snapshotIteration);
+}
+function _firestoreItemPageIterationWithSnapshotIteration(snapshotIteration) {
   const mappedIteration = rxjs$1.mappedPageItemIteration(snapshotIteration, {
     forwardDestroy: true,
     mapValue: x => x.docs
@@ -4865,6 +5063,128 @@ function firestoreItemPageIteration(config) {
   };
   return result;
 }
+/**
+ * Creates a FirestoreFixedItemPageIterationFactoryFunction.
+ */
+function firestoreFixedItemPageIterationFactory(baseConfig, documentAccessor) {
+  return (items, filter) => {
+    const result = firestoreFixedItemPageIteration({
+      items,
+      documentAccessor,
+      queryLike: baseConfig.queryLike,
+      itemsPerPage: baseConfig.itemsPerPage,
+      firestoreQueryDriver: baseConfig.firestoreQueryDriver,
+      maxPageLoadLimit: filter?.maxPageLoadLimit ?? baseConfig.maxPageLoadLimit,
+      filter
+    });
+    return result;
+  };
+}
+/**
+ * Creates a FirestoreItemPageIterationInstance that iterates over the fixed
+ */
+function firestoreFixedItemPageIteration(config) {
+  const {
+    items,
+    documentAccessor
+  } = config;
+  const idLookupMap = new Map();
+  // used to cache the index for ids that are looked up
+  const indexForId = id => {
+    let index = idLookupMap.get(id);
+    if (index === undefined) {
+      index = items.findIndex(x => x.id === id);
+      idLookupMap.set(id, index);
+    }
+    return index;
+  };
+  const delegate = {
+    loadItemsForPage: request => {
+      const {
+        page,
+        iteratorConfig
+      } = request;
+      const prevQueryResult$ = page > 0 ? request.lastItem$ : rxjs.of(undefined);
+      const {
+        itemsPerPage = DEFAULT_FIRESTORE_ITEM_PAGE_ITERATOR_ITEMS_PER_PAGE,
+        filter
+      } = iteratorConfig;
+      const {
+        limit: filterLimit
+      } = filter ?? {};
+      return prevQueryResult$.pipe(rxjs.exhaustMap(prevResult => {
+        if (prevResult?.snapshot.empty === true) {
+          // TODO(REMOVE): Shouldn't happen. Remove this later.
+          return rxjs.of({
+            end: true
+          });
+        } else {
+          const cursorDocument = prevResult ? util.lastValue(prevResult.docs) : undefined;
+          const startAtIndex = cursorDocument ? indexForId(cursorDocument.id) + 1 : 0;
+          const limitCount = filterLimit ?? itemsPerPage;
+          const time = new Date();
+          const itemsForThisPage = items.slice(startAtIndex, startAtIndex + limitCount);
+          const lastItemForThisPage = util.lastValue(itemsForThisPage);
+          let end = false;
+          if (lastItemForThisPage) {
+            const lastItemForThisPageItemIndex = startAtIndex + (itemsForThisPage.length - 1);
+            idLookupMap.set(lastItemForThisPage.id, lastItemForThisPageItemIndex);
+            end = lastItemForThisPageItemIndex === items.length - 1;
+          } else {
+            end = true;
+          }
+          const documents = loadDocumentsForDocumentReferences(documentAccessor, itemsForThisPage);
+          const _loadFakeQuerySnapshot = () => {
+            return getDocumentSnapshots(documents).then(documentSnapshots => {
+              const documentSnapshotsWithData = documentSnapshots.filter(x => x.data() != null);
+              const docs = documentSnapshotsWithData;
+              const query = {
+                withConverter: () => {
+                  throw new Error('firestoreFixedItemPageIteration(): Not a real query');
+                }
+              }; // TODO: No great way to implement this. Not a great way to
+              const snapshot = {
+                query,
+                docs,
+                size: docs.length,
+                empty: docs.length === 0,
+                docChanges: () => {
+                  return []; // no changes to return in this fake snapshot
+                },
+                forEach: result => {
+                  docs.forEach(result);
+                }
+              };
+              return snapshot;
+            });
+          };
+          const resultPromise = _loadFakeQuerySnapshot().then(snapshot => {
+            const result = {
+              value: {
+                time,
+                docs: snapshot.docs,
+                snapshot,
+                reload() {
+                  return _loadFakeQuerySnapshot();
+                },
+                stream(options) {
+                  // TODO: Count potentially stream to fully implement, but might not be used anyways.
+                  return rxjs.of(snapshot);
+                }
+              },
+              end
+            };
+            return result;
+          });
+          return resultPromise;
+        }
+      }));
+    }
+  };
+  const factory = new rxjs$1.ItemPageIterator(delegate);
+  const snapshotIteration = factory.instance(config);
+  return _firestoreItemPageIterationWithSnapshotIteration(snapshotIteration);
+}
 // MARK: Compat
 /**
  * @deprecated Use filterDisallowedFirestoreItemPageIteratorInputConstraints instead. Mispelling.
@@ -6028,13 +6348,14 @@ function makeFirestoreCollection(inputConfig) {
     firestoreAccessorDriver
   } = config;
   config.queryLike = collection;
-  const firestoreIteration = firestoreItemPageIterationFactory(config);
   const documentAccessor = firestoreDocumentAccessorFactory(config);
-  const queryFactory = firestoreQueryFactory(config);
   const documentAccessorExtension = firestoreDocumentAccessorContextExtension({
     documentAccessor,
     firestoreAccessorDriver
   });
+  const firestoreIteration = firestoreItemPageIterationFactory(config);
+  const firestoreFixedIteration = firestoreFixedItemPageIterationFactory(config, documentAccessorExtension.documentAccessor());
+  const queryFactory = firestoreQueryFactory(config);
   const {
     queryDocument
   } = firestoreCollectionQueryFactory(queryFactory, documentAccessorExtension);
@@ -6049,6 +6370,7 @@ function makeFirestoreCollection(inputConfig) {
     firestoreContext,
     ...documentAccessorExtension,
     firestoreIteration,
+    firestoreFixedIteration,
     query,
     queryDocument
   };
@@ -6100,17 +6422,18 @@ function makeFirestoreCollectionGroup(config) {
     firestoreContext,
     firestoreAccessorDriver
   } = config;
-  // Create the iteration factory for pagination support
-  const firestoreIteration = firestoreItemPageIterationFactory(config);
   // Create the document accessor for loading documents
   const documentAccessor = limitedFirestoreDocumentAccessorFactory(config);
-  // Create the query factory for building Firestore queries
-  const queryFactory = firestoreQueryFactory(config);
   // Create the document accessor extension with context
   const documentAccessorExtension = firestoreDocumentAccessorContextExtension({
     documentAccessor,
     firestoreAccessorDriver
   });
+  // Create the iteration factory for pagination support
+  const firestoreIteration = firestoreItemPageIterationFactory(config);
+  const firestoreFixedIteration = firestoreFixedItemPageIterationFactory(config, documentAccessorExtension.documentAccessor());
+  // Create the query factory for building Firestore queries
+  const queryFactory = firestoreQueryFactory(config);
   // Create the document-aware query factory
   const {
     queryDocument
@@ -6126,6 +6449,7 @@ function makeFirestoreCollectionGroup(config) {
     firestoreContext,
     ...documentAccessorExtension,
     firestoreIteration,
+    firestoreFixedIteration,
     query,
     queryDocument
   };
@@ -6252,199 +6576,6 @@ function firestoreContextFactory(drivers) {
   };
 }
 
-var classofRaw$1 = classofRaw$2;
-var uncurryThis$1 = functionUncurryThis;
-
-var functionUncurryThisClause = function (fn) {
-  // Nashorn bug:
-  //   https://github.com/zloirock/core-js/issues/1128
-  //   https://github.com/zloirock/core-js/issues/1130
-  if (classofRaw$1(fn) === 'Function') return uncurryThis$1(fn);
-};
-
-var uncurryThis = functionUncurryThisClause;
-var aCallable$3 = aCallable$9;
-var NATIVE_BIND = functionBindNative;
-
-var bind$1 = uncurryThis(uncurryThis.bind);
-
-// optional / simple context binding
-var functionBindContext = function (fn, that) {
-  aCallable$3(fn);
-  return that === undefined ? fn : NATIVE_BIND ? bind$1(fn, that) : function (/* ...args */) {
-    return fn.apply(that, arguments);
-  };
-};
-
-var iterators = {};
-
-var wellKnownSymbol$3 = wellKnownSymbol$8;
-var Iterators$1 = iterators;
-
-var ITERATOR$1 = wellKnownSymbol$3('iterator');
-var ArrayPrototype = Array.prototype;
-
-// check on default Array iterator
-var isArrayIteratorMethod$1 = function (it) {
-  return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$1] === it);
-};
-
-var wellKnownSymbol$2 = wellKnownSymbol$8;
-
-var TO_STRING_TAG$1 = wellKnownSymbol$2('toStringTag');
-var test = {};
-
-test[TO_STRING_TAG$1] = 'z';
-
-var toStringTagSupport = String(test) === '[object z]';
-
-var TO_STRING_TAG_SUPPORT = toStringTagSupport;
-var isCallable = isCallable$e;
-var classofRaw = classofRaw$2;
-var wellKnownSymbol$1 = wellKnownSymbol$8;
-
-var TO_STRING_TAG = wellKnownSymbol$1('toStringTag');
-var $Object = Object;
-
-// ES3 wrong here
-var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';
-
-// fallback for IE11 Script Access Denied error
-var tryGet = function (it, key) {
-  try {
-    return it[key];
-  } catch (error) { /* empty */ }
-};
-
-// getting tag from ES6+ `Object.prototype.toString`
-var classof$1 = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
-  var O, tag, result;
-  return it === undefined ? 'Undefined' : it === null ? 'Null'
-    // @@toStringTag case
-    : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
-    // builtinTag case
-    : CORRECT_ARGUMENTS ? classofRaw(O)
-    // ES3 arguments fallback
-    : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;
-};
-
-var classof = classof$1;
-var getMethod = getMethod$4;
-var isNullOrUndefined = isNullOrUndefined$3;
-var Iterators = iterators;
-var wellKnownSymbol = wellKnownSymbol$8;
-
-var ITERATOR = wellKnownSymbol('iterator');
-
-var getIteratorMethod$2 = function (it) {
-  if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
-    || getMethod(it, '@@iterator')
-    || Iterators[classof(it)];
-};
-
-var call$1 = functionCall;
-var aCallable$2 = aCallable$9;
-var anObject$3 = anObject$e;
-var tryToString$1 = tryToString$3;
-var getIteratorMethod$1 = getIteratorMethod$2;
-
-var $TypeError$1 = TypeError;
-
-var getIterator$1 = function (argument, usingIterator) {
-  var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator;
-  if (aCallable$2(iteratorMethod)) return anObject$3(call$1(iteratorMethod, argument));
-  throw new $TypeError$1(tryToString$1(argument) + ' is not iterable');
-};
-
-var bind = functionBindContext;
-var call = functionCall;
-var anObject$2 = anObject$e;
-var tryToString = tryToString$3;
-var isArrayIteratorMethod = isArrayIteratorMethod$1;
-var lengthOfArrayLike = lengthOfArrayLike$3;
-var isPrototypeOf = objectIsPrototypeOf;
-var getIterator = getIterator$1;
-var getIteratorMethod = getIteratorMethod$2;
-var iteratorClose = iteratorClose$5;
-
-var $TypeError = TypeError;
-
-var Result = function (stopped, result) {
-  this.stopped = stopped;
-  this.result = result;
-};
-
-var ResultPrototype = Result.prototype;
-
-var iterate$2 = function (iterable, unboundFunction, options) {
-  var that = options && options.that;
-  var AS_ENTRIES = !!(options && options.AS_ENTRIES);
-  var IS_RECORD = !!(options && options.IS_RECORD);
-  var IS_ITERATOR = !!(options && options.IS_ITERATOR);
-  var INTERRUPTED = !!(options && options.INTERRUPTED);
-  var fn = bind(unboundFunction, that);
-  var iterator, iterFn, index, length, result, next, step;
-
-  var stop = function (condition) {
-    if (iterator) iteratorClose(iterator, 'normal', condition);
-    return new Result(true, condition);
-  };
-
-  var callFn = function (value) {
-    if (AS_ENTRIES) {
-      anObject$2(value);
-      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
-    } return INTERRUPTED ? fn(value, stop) : fn(value);
-  };
-
-  if (IS_RECORD) {
-    iterator = iterable.iterator;
-  } else if (IS_ITERATOR) {
-    iterator = iterable;
-  } else {
-    iterFn = getIteratorMethod(iterable);
-    if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');
-    // optimisation for array iterators
-    if (isArrayIteratorMethod(iterFn)) {
-      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
-        result = callFn(iterable[index]);
-        if (result && isPrototypeOf(ResultPrototype, result)) return result;
-      } return new Result(false);
-    }
-    iterator = getIterator(iterable, iterFn);
-  }
-
-  next = IS_RECORD ? iterable.next : iterator.next;
-  while (!(step = call(next, iterator)).done) {
-    try {
-      result = callFn(step.value);
-    } catch (error) {
-      iteratorClose(iterator, 'throw', error);
-    }
-    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
-  } return new Result(false);
-};
-
-var $$1 = _export;
-var iterate$1 = iterate$2;
-var aCallable$1 = aCallable$9;
-var anObject$1 = anObject$e;
-var getIteratorDirect$1 = getIteratorDirect$5;
-
-// `Iterator.prototype.forEach` method
-// https://github.com/tc39/proposal-iterator-helpers
-$$1({ target: 'Iterator', proto: true, real: true }, {
-  forEach: function forEach(fn) {
-    anObject$1(this);
-    aCallable$1(fn);
-    var record = getIteratorDirect$1(this);
-    var counter = 0;
-    iterate$1(record, function (value) {
-      fn(value, counter++);
-    }, { IS_RECORD: true });
-  }
-});
-
 function makeFirestoreQueryConstraintFunctionsDriver(config) {
   const {
     mapping,
@@ -7124,6 +7255,18 @@ const FIREBASE_DEVELOPMENT_FUNCTIONS_MAP_KEY = 'developmentFunctions';
  */
 class FirebaseDevelopmentFunctions {}
 
+/**
+ * Creates a new StoragePath object with the same bucketId and pathString as the input.
+ *
+ * @param path The StoragePath to copy.
+ * @returns A new StoragePath object.
+ */
+function copyStoragePath(path) {
+  return {
+    bucketId: path.bucketId,
+    pathString: path.pathString
+  };
+}
 /**
  * Creates a StoragePathFactory.
  *
@@ -7809,6 +7952,237 @@ function modelStorageSlashPathFactory(config) {
   };
 }
 
+/**
+ * Creates a new IterateStorageListFilesFactory.
+ *
+ * @param config
+ * @returns
+ */
+function iterateStorageListFilesFactory(config) {
+  const {
+    maxResults: factoryDefaultMaxResults
+  } = config;
+  return fetch.fetchPageFactory({
+    fetch: async input => {
+      const list = await input.folder.list({
+        includeNestedResults: input.includeNestedResults,
+        maxResults: input.maxResults ?? factoryDefaultMaxResults,
+        pageToken: input.pageToken ?? undefined
+      });
+      return list;
+    },
+    readFetchPageResultInfo: result => {
+      const cursor = result.nextPageToken();
+      const info = {
+        hasNext: result.hasNext,
+        cursor: result.options?.pageToken,
+        nextPageCursor: cursor
+      };
+      return info;
+    },
+    buildInputForNextPage: function (pageResult, input, options) {
+      return {
+        ...input,
+        pageToken: pageResult.nextPageCursor ?? undefined
+      };
+    }
+  });
+}
+/**
+ * Convenience function for calling iterateFetchPagesByEachItem() for a storage folder.
+ */
+function iterateStorageListFilesByEachFile(input) {
+  const {
+    folder,
+    includeNestedResults,
+    pageToken
+  } = input;
+  return fetch.iterateFetchPagesByEachItem({
+    ...input,
+    input: {
+      folder,
+      includeNestedResults,
+      pageToken
+    },
+    fetchPageFactory: iterateStorageListFilesFactory({})
+  });
+}
+/**
+ * Convenience function for calling iterateFetchPages() for a storage folder.
+ */
+function iterateStorageListFiles(input) {
+  const {
+    folder,
+    includeNestedResults,
+    pageToken
+  } = input;
+  return fetch.iterateFetchPages({
+    ...input,
+    input: {
+      folder,
+      includeNestedResults,
+      pageToken
+    },
+    fetchPageFactory: iterateStorageListFilesFactory({})
+  });
+}
+
+var makeError = {exports: {}};
+
+(function (module, exports) {
+
+	// ===================================================================
+
+	var construct = typeof Reflect !== "undefined" ? Reflect.construct : undefined;
+	var defineProperty = Object.defineProperty;
+
+	// -------------------------------------------------------------------
+
+	var captureStackTrace = Error.captureStackTrace;
+	if (captureStackTrace === undefined) {
+	  captureStackTrace = function captureStackTrace(error) {
+	    var container = new Error();
+
+	    defineProperty(error, "stack", {
+	      configurable: true,
+	      get: function getStack() {
+	        var stack = container.stack;
+
+	        // Replace property with value for faster future accesses.
+	        defineProperty(this, "stack", {
+	          configurable: true,
+	          value: stack,
+	          writable: true,
+	        });
+
+	        return stack;
+	      },
+	      set: function setStack(stack) {
+	        defineProperty(error, "stack", {
+	          configurable: true,
+	          value: stack,
+	          writable: true,
+	        });
+	      },
+	    });
+	  };
+	}
+
+	// -------------------------------------------------------------------
+
+	function BaseError(message) {
+	  if (message !== undefined) {
+	    defineProperty(this, "message", {
+	      configurable: true,
+	      value: message,
+	      writable: true,
+	    });
+	  }
+
+	  var cname = this.constructor.name;
+	  if (cname !== undefined && cname !== this.name) {
+	    defineProperty(this, "name", {
+	      configurable: true,
+	      value: cname,
+	      writable: true,
+	    });
+	  }
+
+	  captureStackTrace(this, this.constructor);
+	}
+
+	BaseError.prototype = Object.create(Error.prototype, {
+	  // See: https://github.com/JsCommunity/make-error/issues/4
+	  constructor: {
+	    configurable: true,
+	    value: BaseError,
+	    writable: true,
+	  },
+	});
+
+	// -------------------------------------------------------------------
+
+	// Sets the name of a function if possible (depends of the JS engine).
+	var setFunctionName = (function() {
+	  function setFunctionName(fn, name) {
+	    return defineProperty(fn, "name", {
+	      configurable: true,
+	      value: name,
+	    });
+	  }
+	  try {
+	    var f = function() {};
+	    setFunctionName(f, "foo");
+	    if (f.name === "foo") {
+	      return setFunctionName;
+	    }
+	  } catch (_) {}
+	})();
+
+	// -------------------------------------------------------------------
+
+	function makeError(constructor, super_) {
+	  if (super_ == null || super_ === Error) {
+	    super_ = BaseError;
+	  } else if (typeof super_ !== "function") {
+	    throw new TypeError("super_ should be a function");
+	  }
+
+	  var name;
+	  if (typeof constructor === "string") {
+	    name = constructor;
+	    constructor =
+	      construct !== undefined
+	        ? function() {
+	            return construct(super_, arguments, this.constructor);
+	          }
+	        : function() {
+	            super_.apply(this, arguments);
+	          };
+
+	    // If the name can be set, do it once and for all.
+	    if (setFunctionName !== undefined) {
+	      setFunctionName(constructor, name);
+	      name = undefined;
+	    }
+	  } else if (typeof constructor !== "function") {
+	    throw new TypeError("constructor should be either a string or a function");
+	  }
+
+	  // Also register the super constructor also as `constructor.super_` just
+	  // like Node's `util.inherits()`.
+	  //
+	  // eslint-disable-next-line dot-notation
+	  constructor.super_ = constructor["super"] = super_;
+
+	  var properties = {
+	    constructor: {
+	      configurable: true,
+	      value: constructor,
+	      writable: true,
+	    },
+	  };
+
+	  // If the name could not be set on the constructor, set it on the
+	  // prototype.
+	  if (name !== undefined) {
+	    properties.name = {
+	      configurable: true,
+	      value: name,
+	      writable: true,
+	    };
+	  }
+	  constructor.prototype = Object.create(super_.prototype, properties);
+
+	  return constructor;
+	}
+	exports = module.exports = makeError;
+	exports.BaseError = BaseError; 
+} (makeError, makeError.exports));
+
+var makeErrorExports = makeError.exports;
+
+// MARK: Upload Options
 function assertStorageUploadOptionsStringFormat(options) {
   const stringFormat = options?.stringFormat;
   if (!stringFormat) {
@@ -7819,6 +8193,36 @@ function assertStorageUploadOptionsStringFormat(options) {
 function noStringFormatInStorageUploadOptionsError() {
   return new Error('stringFormat was missing a value in the StorageUploadOptions.');
 }
+// MARK: Stream Error
+class StorageFileUploadStreamUnsupportedError extends makeErrorExports.BaseError {
+  constructor() {
+    super('Failed to upload file using a stream. The file does not support upload streams.');
+  }
+}
+
+/**
+ * Uploads a file using a Readable, using the uploadStream() method on the FirebaseStorageAccessorFile.
+ *
+ * If uploadStream is not supported, a StorageFileUploadStreamUnsupportedError will be thrown.
+ *
+ * @param file The file to upload to.
+ * @param readableStream The stream to upload.
+ * @param options The upload options.
+ * @returns A promise that resolves when the upload is complete.
+ */
+async function uploadFileWithStream(file, readableStream, options) {
+  if (!file.uploadStream) {
+    throw new StorageFileUploadStreamUnsupportedError();
+  }
+  const uploadStream = file.uploadStream(options);
+  readableStream.pipe(uploadStream, {
+    end: true
+  });
+  return new Promise((resolve, reject) => {
+    uploadStream.on('finish', resolve);
+    uploadStream.on('error', reject);
+  });
+}
 
 function storageListFilesResultFactory(delegate) {
   return (storage, folder, options, result) => {
@@ -7835,10 +8239,11 @@ function storageListFilesResultFactory(delegate) {
       if (!hasNext) {
         throw storageListFilesResultHasNoNextError();
       }
-      return delegate.next(storage, folder, result);
+      return delegate.next(storage, options, folder, result);
     });
     const files = util.cachedGetter(() => delegate.filesFromResult(result, folder).map(fileResult));
     const folders = util.cachedGetter(() => delegate.foldersFromResult(result, folder).map(folderResult));
+    const nextPageToken = util.cachedGetter(() => delegate.nextPageTokenFromResult(result));
     const filesResult = {
       raw: result,
       options,
@@ -7846,7 +8251,8 @@ function storageListFilesResultFactory(delegate) {
       hasItems: () => delegate.hasItems(result),
       next,
       files,
-      folders
+      folders,
+      nextPageToken
     };
     return filesResult;
   };
@@ -7867,7 +8273,7 @@ function firebaseStorageContextFactory(drivers) {
       defaultBucketId: inputDefaultBucketId,
       forceBucket = false
     } = config ?? {};
-    const defaultBucketId = inputDefaultBucketId || drivers.storageAccessorDriver.defaultBucket?.(firebaseStorage) || '';
+    const defaultBucketId = inputDefaultBucketId || drivers.storageAccessorDriver.getDefaultBucket?.(firebaseStorage) || '';
     if (!defaultBucketId) {
       throw new Error('Could not resolve a default bucket id for the firebaseStorageContextFactory(). Supply a defaultBucketId.');
     }
@@ -7897,33 +8303,47 @@ function firebaseStorageFileExists(ref) {
 }
 function firebaseStorageClientAccessorFile(storage$1, storagePath) {
   const ref = firebaseStorageRefForStorageFilePath(storage$1, storagePath);
-  function asUploadMetadata(options) {
-    let result;
+  function _configureMetadata(options) {
+    return util.filterUndefinedValues({
+      cacheControl: options.metadata?.cacheControl,
+      contentDisposition: options.metadata?.contentDisposition,
+      contentEncoding: options.metadata?.contentEncoding,
+      contentLanguage: options.metadata?.contentLanguage,
+      contentType: options.metadata?.contentType,
+      customMetadata: util.filterUndefinedValues({
+        ...options.metadata?.customMetadata,
+        ...options?.customMetadata
+      })
+    });
+  }
+  function uploadMetadataFromStorageUploadOptions(options) {
+    let result;
     if (options != null) {
-      const {
-        contentType,
-        metadata
-      } = options;
-      if (options.contentType || options.metadata) {
-        result = {
-          ...(contentType ? {
-            contentType
-          } : undefined),
-          ...metadata
-        };
-      }
+      result = _configureMetadata({
+        metadata: {
+          ...options.metadata,
+          contentType: options.contentType ?? options.metadata?.contentType
+        },
+        customMetadata: options.customMetadata
+      });
     }
     return result;
   }
-  return {
+  function asSettableMetadata(metadata) {
+    return _configureMetadata({
+      metadata
+    });
+  }
+  const clientFile = {
     reference: ref,
     storagePath,
     exists: () => firebaseStorageFileExists(ref),
     getDownloadUrl: () => storage.getDownloadURL(ref),
     getMetadata: () => storage.getMetadata(ref),
+    setMetadata: metadata => storage.updateMetadata(ref, asSettableMetadata(metadata)),
     upload: (input, options) => {
       const inputType = typeof input === 'string';
-      const metadataOption = asUploadMetadata(options);
+      const metadataOption = uploadMetadataFromStorageUploadOptions(options);
       if (inputType) {
         const stringFormat = assertStorageUploadOptionsStringFormat(options);
         return storage.uploadString(ref, input, stringFormat, metadataOption);
@@ -7934,8 +8354,35 @@ function firebaseStorageClientAccessorFile(storage$1, storagePath) {
     getBytes: maxDownloadSizeBytes => storage.getBytes(ref, maxDownloadSizeBytes),
     getBlob: maxDownloadSizeBytes => storage.getBlob(ref, maxDownloadSizeBytes),
     uploadResumable: (input, options) => {
-      const metadataOption = asUploadMetadata(options);
-      return storage.uploadBytesResumable(ref, input, metadataOption);
+      const metadataOption = uploadMetadataFromStorageUploadOptions(options);
+      const uploadBytesTask = storage.uploadBytesResumable(ref, input, metadataOption);
+      function wrapSnapshot(currentSnapshot) {
+        const snapshot = {
+          bytesTransferred: currentSnapshot.bytesTransferred,
+          totalBytes: currentSnapshot.totalBytes,
+          metadata: currentSnapshot.metadata,
+          state: currentSnapshot.state,
+          uploadTask
+        };
+        return snapshot;
+      }
+      const uploadTask = {
+        taskRef: uploadBytesTask,
+        cancel: () => uploadBytesTask.cancel(),
+        pause: () => uploadBytesTask.pause(),
+        resume: () => uploadBytesTask.resume(),
+        getSnapshot: () => wrapSnapshot(uploadBytesTask.snapshot),
+        streamSnapshotEvents: util.cachedGetter(() => {
+          const internalSnapshotObs = new rxjs.Observable(x => uploadBytesTask.on('state_changed', {
+            next: y => x.next(y),
+            error: e => x.error(e),
+            complete: () => x.complete()
+          }));
+          const snapshotEvents = internalSnapshotObs.pipe(rxjs.map(x => wrapSnapshot(x)), rxjs.shareReplay(1));
+          return snapshotEvents;
+        })
+      };
+      return uploadTask;
     },
     delete: options => storage.deleteObject(ref).catch(x => {
       if (!options.ignoreNotFound || !isFirebaseStorageObjectNotFoundError(x)) {
@@ -7943,6 +8390,7 @@ function firebaseStorageClientAccessorFile(storage$1, storagePath) {
       }
     })
   };
+  return clientFile;
 }
 const firebaseStorageClientListFilesResultFactory = storageListFilesResultFactory({
   hasItems: result => {
@@ -7951,8 +8399,12 @@ const firebaseStorageClientListFilesResultFactory = storageListFilesResultFactor
   hasNext: result => {
     return result.listResult.nextPageToken != null;
   },
-  next(storage, folder, result) {
+  nextPageTokenFromResult(result) {
+    return result.listResult.nextPageToken;
+  },
+  next(storage, options, folder, result) {
     return folder.list({
+      ...options,
       ...result.options,
       pageToken: result.listResult.nextPageToken
     });
@@ -7990,16 +8442,37 @@ function firebaseStorageClientAccessorFolder(storage$1, storagePath) {
     exists: () => folder.list({
       maxResults: 1
     }).then(x => x.hasItems()),
-    list: options => storage.list(ref, options).then(listResult => firebaseStorageClientListFilesResultFactory(storage$1, folder, options, {
-      options,
-      listResult
-    }))
+    list: async options => {
+      const rootResults = await storage.list(ref, options).then(listResult => firebaseStorageClientListFilesResultFactory(storage$1, folder, options, {
+        options,
+        listResult
+      }));
+      let result;
+      if (options?.includeNestedResults) {
+        const allImmediateFiles = rootResults.files();
+        const allImmediateFolders = rootResults.folders();
+        const allNestedFolderFileResults = await Promise.all(allImmediateFolders.map(x => x.folder().list({
+          includeNestedResults: true
+        }).then(x => x.files())));
+        const allNestedFiles = allNestedFolderFileResults.flat();
+        const allFiles = [...allImmediateFiles, ...allNestedFiles];
+        result = {
+          ...rootResults,
+          files: () => allFiles,
+          folders: () => [] // no folders
+        };
+      } else {
+        result = rootResults;
+      }
+      return result;
+    }
   };
   return folder;
 }
 function firebaseStorageClientAccessorDriver() {
   return {
-    defaultBucket: storage => storage.app.options.storageBucket ?? '',
+    type: 'client',
+    getDefaultBucket: storage => storage.app.options.storageBucket ?? '',
     file: (storage, path) => firebaseStorageClientAccessorFile(storage, path),
     folder: (storage, path) => firebaseStorageClientAccessorFolder(storage, path)
   };
@@ -9338,13 +9811,22 @@ function createNotificationDocumentPair(input) {
   const isNotificationTask = st === exports.NotificationSendType.TASK_NOTIFICATION;
   if (isNotificationTask && inputUnique) {
     let uniqueId;
+    /**
+     * Defaults to the notification box id if no target model is provided.
+     */
+    const targetModelId = n.m;
     if (typeof inputUnique === 'string') {
       uniqueId = inputUnique;
       if (!isFirestoreModelId(uniqueId)) {
         throw new Error('Input "unique" notification task id is not a valid firestore model id.');
       }
+    } else if (targetModelId) {
+      uniqueId = notificationTaskUniqueId(targetModelId, n.t);
     } else {
-      uniqueId = notificationTaskUniqueId(notificationModel, n.t);
+      // Without a target model, the generated id ends up being a type-global unique notification task id, or if
+      // the notification task global default model type is used, being unique across the whole system, which is
+      // generally unintended behavor. When it is desired, the inputUnique can be a string.
+      throw new Error('Must provide a target model when using unique=true for a notification task. The default result otherwise would be an unintended type-global unique notification task id.');
     }
     notificationDocument = accessor.loadDocumentForId(uniqueId);
   } else {
@@ -9445,9 +9927,10 @@ async function createNotificationDocumentIfSending(input) {
  * @returns
  */
 function createNotificationTaskTemplate(input) {
-  return createNotificationTemplate({
+  const notificationModel = input.notificationModel ?? DEFAULT_NOTIFICATION_TASK_NOTIFICATION_MODEL_KEY;
+  const result = createNotificationTemplate({
     ...input,
-    notificationModel: input.notificationModel ?? DEFAULT_NOTIFICATION_TASK_NOTIFICATION_MODEL_KEY,
+    notificationModel,
     tpr: input.completedCheckpoints ?? input.tpr,
     sendType: exports.NotificationSendType.TASK_NOTIFICATION,
     st: undefined,
@@ -9455,6 +9938,10 @@ function createNotificationTaskTemplate(input) {
     recipients: undefined,
     r: undefined
   });
+  if (!input.notificationModel && !result.n.m && input.unique === true) {
+    throw new Error('Must provide a target model when using unique=true for a notification task template. The default result otherwise would be an unintended type-global unique notification task id.');
+  }
+  return result;
 }
 
 /**
@@ -9730,6 +10217,22 @@ function notificationTaskFailed(updateMetadata, removeFromCompletedCheckpoints)
     removeFromCompletedCheckpoints
   };
 }
+/**
+ * Wraps an existing NotificationTaskServiceHandleNotificationTaskResult<D> and sets canRunNextCheckpoint to true if it is undefined.
+ *
+ * @param result The result to use as a template.
+ * @param force If true, then canRunNextCheckpoint will be set to true even if it is already defined.
+ * @returns A new result.
+ */
+function notificationTaskCanRunNextCheckpoint(result, force) {
+  if (force || result.canRunNextCheckpoint == null) {
+    result = {
+      ...result,
+      canRunNextCheckpoint: true
+    };
+  }
+  return result;
+}
 
 var $ = _export;
 var iterate = iterate$2;
@@ -9987,6 +10490,727 @@ function loadNotificationBoxDocumentForReferencePair(input, accessor) {
   return notificationBoxDocument;
 }
 
+/**
+ * Thrown if the target uploaded file does not exist.
+ */
+const UPLOADED_FILE_DOES_NOT_EXIST_ERROR_CODE = 'UPLOADED_FILE_DOES_NOT_EXIST';
+/**
+ * Thrown if the target uploaded file is not allowed to be initialized.
+ */
+const UPLOADED_FILE_NOT_ALLOWED_TO_BE_INITIALIZED_ERROR_CODE = 'UPLOADED_FILE_NOT_ALLOWED_TO_BE_INITIALIZED';
+/**
+ * Thrown if the target uploaded file initialization failed.
+ */
+const UPLOADED_FILE_INITIALIZATION_FAILED_ERROR_CODE = 'UPLOADED_FILE_INITIALIZATION_FAILED';
+/**
+ * Thrown if the target uploaded file initialization was successful, but produced no new StorageFileDocument.
+ */
+const UPLOADED_FILE_INITIALIZATION_DISCARDED_ERROR_CODE = 'UPLOADED_FILE_INITIALIZATION_DISCARDED';
+/**
+ * Thrown if the target StorageFileDocument is not queued for processing and is called to be processed.
+ */
+const STORAGE_FILE_PROCESSING_NOT_QUEUED_FOR_PROCESSING_ERROR_CODE = 'STORAGE_FILE_PROCESSING_NOT_QUEUED_FOR_PROCESSING';
+/**
+ * Thrown if:
+ * - the target StorageFileDocument was marked as queued for processing but isn't actually a processable-type.
+ * - the target StorageFileDocument is marked as init but has no purpose set, meaning it can't be processed.
+ */
+const STORAGE_FILE_PROCESSING_NOT_AVAILABLE_FOR_TYPE_ERROR_CODE = 'STORAGE_FILE_PROCESSING_NOT_AVAILABLE_FOR_TYPE';
+/**
+ * Thrown if the StorageFile is not in an OK state.
+ */
+const STORAGE_FILE_PROCESSING_NOT_ALLOWED_FOR_INVALID_STATE_ERROR_CODE = 'STORAGE_FILE_PROCESSING_NOT_ALLOWED_FOR_INVALID_STATE';
+/**
+ * Thrown if the target StorageFileDocument already finished processing.
+ */
+const STORAGE_FILE_ALREADY_PROCESSED_ERROR_CODE = 'STORAGE_FILE_ALREADY_PROCESSED';
+/**
+ * Thrown if the target StorageFileDocument is not flagged for deletion but attempts to be deleted.
+ */
+const STORAGE_FILE_NOT_FLAGGED_FOR_DELETION_ERROR_CODE = 'STORAGE_FILE_NOT_FLAGGED_FOR_DELETION';
+/**
+ * Thrown if the target StorageFileDocument is flagged for deletion, but has not reached the time to be deleted yet.
+ */
+const STORAGE_FILE_CANNOT_BE_DELETED_YET_ERROR_CODE = 'STORAGE_FILE_CANNOT_BE_DELETED_YET';
+
+/**
+ * Used for directly create a new StorageFile.
+ */
+class CreateStorageFileParams {}
+/**
+ * Initializes all StorageFiles in the uploads folder.
+ */
+class InitializeAllStorageFilesFromUploadsParams {
+  constructor() {
+    /**
+     * The maximum number of files to initialize at once.
+     */
+    this.maxFilesToInitialize = void 0;
+    /**
+     * The specific folder under the uploads folder to search for files and initialize
+     */
+    this.folderPath = void 0;
+    /**
+     * Overrides the default uploads folder path.
+     */
+    this.overrideUploadsFolderPath = void 0;
+  }
+}
+__decorate([classTransformer.Expose(), classValidator.IsNumber(), classValidator.IsOptional(), __metadata("design:type", Object)], InitializeAllStorageFilesFromUploadsParams.prototype, "maxFilesToInitialize", void 0);
+__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.IsOptional(), __metadata("design:type", Object)], InitializeAllStorageFilesFromUploadsParams.prototype, "folderPath", void 0);
+__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.IsOptional(), __metadata("design:type", Object)], InitializeAllStorageFilesFromUploadsParams.prototype, "overrideUploadsFolderPath", void 0);
+/**
+ * Initializes a StorageFile from the document at the given path.
+ */
+class InitializeStorageFileFromUploadParams {
+  constructor() {
+    /**
+     * Specific bucketId to use.
+     *
+     * If not defined, the default bucket will be used.
+     */
+    this.bucketId = void 0;
+    this.pathString = void 0;
+  }
+}
+__decorate([classTransformer.Expose(), classValidator.IsOptional(), classValidator.IsString(), __metadata("design:type", Object)], InitializeStorageFileFromUploadParams.prototype, "bucketId", void 0);
+__decorate([classTransformer.Expose(), classValidator.IsString(), __metadata("design:type", String)], InitializeStorageFileFromUploadParams.prototype, "pathString", void 0);
+class ProcessStorageFileParams extends TargetModelParams {
+  constructor(...args) {
+    super(...args);
+    /**
+     * If set, will start/run the processing immediately instead of waiting for the next scheduled run.
+     */
+    this.runImmediately = void 0;
+    /**
+     * If set, will check and retry processing if the StorageFile is in a failed processing state.
+     */
+    this.checkRetryProcessing = void 0;
+    /**
+     * Used with retryProcessing.
+     *
+     * If set, will forcibly create a new processing task even if the existing processing task appears to be ok.
+     */
+    this.forceRestartProcessing = void 0;
+  }
+}
+__decorate([classTransformer.Expose(), classValidator.IsBoolean(), classValidator.IsOptional(), __metadata("design:type", Object)], ProcessStorageFileParams.prototype, "runImmediately", void 0);
+__decorate([classTransformer.Expose(), classValidator.IsBoolean(), classValidator.IsOptional(), __metadata("design:type", Object)], ProcessStorageFileParams.prototype, "checkRetryProcessing", void 0);
+__decorate([classTransformer.Expose(), classValidator.IsBoolean(), classValidator.IsOptional(), __metadata("design:type", Object)], ProcessStorageFileParams.prototype, "forceRestartProcessing", void 0);
+/**
+ * Processes all StorageFiles that are queued for processing.
+ */
+class ProcessAllQueuedStorageFilesParams {}
+class UpdateStorageFileParams extends TargetModelParams {
+  constructor(...args) {
+    super(...args);
+    /**
+     * Sets the delete at time for the given StorageFileDocument, and queues the file for deletion.
+     */
+    this.sdat = void 0;
+  }
+}
+__decorate([classTransformer.Expose(), classValidator.IsDate(), classValidator.IsOptional(), classTransformer.Type(() => Date), __metadata("design:type", Object)], UpdateStorageFileParams.prototype, "sdat", void 0);
+class DeleteStorageFileParams extends TargetModelParams {
+  constructor(...args) {
+    super(...args);
+    /**
+     * If true, will force the deletion of the StorageFile even if it is not queued for deletion.
+     */
+    this.force = void 0;
+  }
+}
+__decorate([classTransformer.Expose(), classValidator.IsBoolean(), classValidator.IsOptional(), __metadata("design:type", Object)], DeleteStorageFileParams.prototype, "force", void 0);
+/**
+ * Processes all StorageFiles that are queued for processing.
+ */
+class DeleteAllQueuedStorageFilesParams {}
+const storageFileFunctionTypeConfigMap = {};
+const storageFileModelCrudFunctionsConfig = {
+  storageFile: ['create:_,fromUpload,allFromUpload', 'update:_,process', 'delete:_']
+};
+class StorageFileFunctions {}
+const storageFileFunctionMap = callModelFirebaseFunctionMapFactory(storageFileFunctionTypeConfigMap, storageFileModelCrudFunctionsConfig);
+
+class StorageFileFirestoreCollections {}
+// MARK: StorageFile
+const storageFileIdentity = firestoreModelIdentity('storageFile', 'sf');
+/**
+ * The current file state.
+ */
+exports.StorageFileCreationType = void 0;
+(function (StorageFileCreationType) {
+  /**
+   * No info about how this file was created.
+   */
+  StorageFileCreationType[StorageFileCreationType["NONE"] = 0] = "NONE";
+  /**
+   * The StorageFile was directly created.
+   */
+  StorageFileCreationType[StorageFileCreationType["DIRECTLY_CREATED"] = 1] = "DIRECTLY_CREATED";
+  /**
+   * The StorageFile was initialized from an uploaded file.
+   */
+  StorageFileCreationType[StorageFileCreationType["INIT_FROM_UPLOAD"] = 2] = "INIT_FROM_UPLOAD";
+})(exports.StorageFileCreationType || (exports.StorageFileCreationType = {}));
+/**
+ * The current file state.
+ */
+exports.StorageFileState = void 0;
+(function (StorageFileState) {
+  /**
+   * The StorageFile has no state, or is just being initialized.
+   */
+  StorageFileState[StorageFileState["INIT"] = 0] = "INIT";
+  /**
+   * The StorageFile failed to initialize properly and is considered invalid.
+   *
+   * StorageFiles that are marked invalid are deleted after a period of time.
+   *
+   * Files that are invalid cannot be processed.
+   */
+  StorageFileState[StorageFileState["INVALID"] = 1] = "INVALID";
+  /**
+   * The StorageFile has been initialized and is ok.
+   */
+  StorageFileState[StorageFileState["OK"] = 2] = "OK";
+  /**
+   * A previously OK file that is now queued for deletion.
+   */
+  StorageFileState[StorageFileState["QUEUED_FOR_DELETE"] = 3] = "QUEUED_FOR_DELETE";
+})(exports.StorageFileState || (exports.StorageFileState = {}));
+/**
+ * The current processing state of the file.
+ */
+exports.StorageFileProcessingState = void 0;
+(function (StorageFileProcessingState) {
+  /**
+   * The StorageFile has no processing state or is just being initialized.
+   */
+  StorageFileProcessingState[StorageFileProcessingState["INIT_OR_NONE"] = 0] = "INIT_OR_NONE";
+  /**
+   * The StorageFile is flagged for processing, which will create a NotificationTask for it.
+   */
+  StorageFileProcessingState[StorageFileProcessingState["QUEUED_FOR_PROCESSING"] = 1] = "QUEUED_FOR_PROCESSING";
+  /**
+   * The StorageFile has an associated NotificationTask for it.
+   */
+  StorageFileProcessingState[StorageFileProcessingState["PROCESSING"] = 2] = "PROCESSING";
+  /**
+   * The StorageFile has encountered an error during processing.
+   */
+  StorageFileProcessingState[StorageFileProcessingState["FAILED"] = 3] = "FAILED";
+  /**
+   * The StorageFile has been processed or required no processing and is done.
+   */
+  StorageFileProcessingState[StorageFileProcessingState["SUCCESS"] = 4] = "SUCCESS";
+  /**
+   * The StorageFile has been archived. It should not be processed.
+   */
+  StorageFileProcessingState[StorageFileProcessingState["ARCHIVED"] = 5] = "ARCHIVED";
+  /**
+   * The StorageFile shouldn't be processed.
+   */
+  StorageFileProcessingState[StorageFileProcessingState["DO_NOT_PROCESS"] = 6] = "DO_NOT_PROCESS";
+})(exports.StorageFileProcessingState || (exports.StorageFileProcessingState = {}));
+/**
+ * After 3 hours of being in the PROCESSING state, we can check for retring processing.
+ */
+const STORAGE_FILE_PROCESSING_STUCK_THROTTLE_CHECK_MS = util.MS_IN_HOUR * 3;
+class StorageFileDocument extends AbstractFirestoreDocument {
+  get modelIdentity() {
+    return storageFileIdentity;
+  }
+}
+const storageFileConverter = snapshotConverterFunctions({
+  fields: {
+    bucketId: firestoreString(),
+    pathString: firestoreString(),
+    cat: firestoreDate(),
+    ct: optionalFirestoreEnum({
+      defaultReadValue: exports.StorageFileCreationType.NONE,
+      dontStoreDefaultReadValue: true
+    }),
+    fs: firestoreEnum({
+      default: exports.StorageFileState.INIT
+    }),
+    ps: firestoreEnum({
+      default: exports.StorageFileProcessingState.INIT_OR_NONE
+    }),
+    pn: optionalFirestoreString(),
+    pat: optionalFirestoreDate(),
+    pcat: optionalFirestoreDate(),
+    u: optionalFirestoreString(),
+    uby: optionalFirestoreString(),
+    o: optionalFirestoreString(),
+    p: optionalFirestoreString(),
+    d: firestorePassThroughField(),
+    sdat: optionalFirestoreDate()
+  }
+});
+function storageFileCollectionReference(context) {
+  return context.collection(storageFileIdentity.collectionName);
+}
+function storageFileFirestoreCollection(firestoreContext) {
+  return firestoreContext.firestoreCollection({
+    modelIdentity: storageFileIdentity,
+    converter: storageFileConverter,
+    collection: storageFileCollectionReference(firestoreContext),
+    makeDocument: (accessor, documentAccessor) => new StorageFileDocument(accessor, documentAccessor),
+    firestoreContext
+  });
+}
+
+/**
+ * Creates a CreateStorageFileDocumentPairFactory.
+ *
+ * @param config
+ * @returns
+ */
+function createStorageFileDocumentPairFactory(config = {}) {
+  const {
+    defaultCreationType: inputDefaultCreationType,
+    defaultShouldBeProcessed: inputDefaultShouldBeProcessed
+  } = config;
+  const defaultCreationType = inputDefaultCreationType ?? exports.StorageFileCreationType.DIRECTLY_CREATED;
+  const defaultShouldBeProcessed = inputDefaultShouldBeProcessed ?? false;
+  return async input => {
+    const {
+      template: inputTemplate,
+      accessor: inputAccessor,
+      transaction,
+      context,
+      now: inputNow,
+      uploadedBy,
+      user,
+      purpose,
+      metadata,
+      shouldBeProcessed
+    } = input;
+    const now = inputNow ?? new Date();
+    let accessor = inputAccessor;
+    if (!accessor && context) {
+      const {
+        storageFileCollection
+      } = context;
+      accessor = storageFileCollection.documentAccessorForTransaction(transaction);
+    }
+    if (!accessor) {
+      throw new Error('createStorageFileDocumentPair() failed as neither an accessor nor a context was provided.');
+    }
+    const storagePath = input.file?.storagePath ?? input.storagePathRef?.storagePath ?? input.storagePath;
+    if (!storagePath) {
+      throw new Error('createStorageFileDocumentPair() failed as neither a file, storagePathRef, or storagePath was provided.');
+    }
+    const storageFileDocument = accessor.newDocument();
+    const template = {
+      ...inputTemplate,
+      cat: now,
+      u: user ?? inputTemplate?.u,
+      uby: uploadedBy ?? inputTemplate?.uby,
+      p: purpose ?? inputTemplate?.p,
+      d: metadata ?? inputTemplate?.d,
+      fs: inputTemplate?.fs ?? exports.StorageFileState.OK,
+      ps: shouldBeProcessed ?? defaultShouldBeProcessed ? exports.StorageFileProcessingState.QUEUED_FOR_PROCESSING : exports.StorageFileProcessingState.DO_NOT_PROCESS,
+      ct: inputTemplate?.ct ?? defaultCreationType,
+      bucketId: storagePath.bucketId,
+      pathString: storagePath.pathString
+    };
+    // create the StorageFileDocument
+    await storageFileDocument.create(template);
+    return {
+      storageFileDocument,
+      storageFile: template
+    };
+  };
+}
+/**
+ * Convenience function for creating a StorageFileDocumentPair.
+ *
+ * Calls createStorageFileDocumentPairFactory() with no arguments, then passes the input to the factory and returns the result.
+ */
+async function createStorageFileDocumentPair(input) {
+  return createStorageFileDocumentPairFactory()(input);
+}
+
+// MARK: StorageFile
+/**
+ * Returns a query constraint for StorageFiles that are queued for processing.
+ */
+function storageFilesQueuedForProcessingQuery() {
+  return [where('ps', '==', exports.StorageFileProcessingState.QUEUED_FOR_PROCESSING)];
+}
+/**
+ * Returns a query constraint for StorageFiles that are queued for deletion and are past their scheduled delete date.
+ */
+function storageFilesQueuedForDeleteQuery(now) {
+  return [whereDateIsBefore('sdat', now ?? new Date())];
+}
+function storageFilePurposeAndUserQuery(input) {
+  return [where('p', '==', input.purpose), where('u', '==', input.user)];
+}
+
+// MARK: Storage File Processing Notification
+const STORAGE_FILE_PROCESSING_NOTIFICATION_TASK_TYPE = 'SFP';
+/**
+ * The maximum number of times to delay the cleanup step of a StorageFileProcessingNotificationTask.
+ */
+const DEFAULT_MAX_STORAGE_FILE_PROCESSING_CLEANUP_RETRY_ATTEMPTS = 4;
+/**
+ * The default amount of time to delay the cleanup step of a StorageFileProcessingNotificationTask that failed to cleanup successfully.
+ */
+const DEFAULT_STORAGE_FILE_PROCESSING_CLEANUP_RETRY_DELAY = util.MS_IN_HOUR;
+function storageFileProcessingNotificationTaskTemplate(input) {
+  const {
+    storageFileDocument,
+    overrideExistingTask
+  } = input;
+  return createNotificationTaskTemplate({
+    type: STORAGE_FILE_PROCESSING_NOTIFICATION_TASK_TYPE,
+    targetModel: storageFileDocument,
+    data: {
+      storageFile: storageFileDocument.id,
+      d: input.sd
+    },
+    /**
+     * The task is unique to the StorageFile.
+     */
+    unique: true,
+    overrideExistingTask
+  });
+}
+// MARK: All Tasks
+const ALL_STORAGE_FILE_NOTIFICATION_TASK_TYPES = [STORAGE_FILE_PROCESSING_NOTIFICATION_TASK_TYPE];
+
+/**
+ * Creates a StoredFileReaderFactory.
+ *
+ * Should generally only be used on the server-side, as copy may not be available on the client-side.
+ */
+function storedFileReaderFactory() {
+  return file => {
+    const getPathDetails = util.cachedGetter(() => util.slashPathDetails(file.storagePath.pathString));
+    const details = {
+      ...file.storagePath
+    };
+    const loadFileMetadata = util.cachedGetter(() => file.getMetadata());
+    const loadCustomMetadata = () => {
+      return loadFileMetadata().then(x => x.customMetadata);
+    };
+    const accessor = {
+      input: details,
+      getPathDetails,
+      loadFileBytes: file.getBytes,
+      // do not cache the file data accessors
+      loadFileStream: file.getStream,
+      loadFileMetadata,
+      loadCustomMetadata,
+      copy: file.copy // copy is always available on the server-side
+    };
+    return accessor;
+  };
+}
+
+/**
+ * The base path for all uploaded files.
+ *
+ * The uploads folder is a transient folder that is cleared/processed often of files that are uploaded to it.
+ */
+const UPLOADS_FOLDER_PATH = 'uploads';
+/**
+ * The folder name that contains the uploads for each user "u".
+ */
+const ALL_USER_UPLOADS_FOLDER_NAME = `u`;
+/**
+ * All users uploads folder path.
+ *
+ * For example, user 12345 will upload their files to folder "uploads/u/12345/".
+ */
+const ALL_USER_UPLOADS_FOLDER_PATH = `${UPLOADS_FOLDER_PATH}/${ALL_USER_UPLOADS_FOLDER_NAME}`;
+function userUploadsFolderSlashPathFactory(inputBasePath) {
+  const basePath = util.toAbsoluteSlashPathStartType(inputBasePath ?? ALL_USER_UPLOADS_FOLDER_PATH);
+  return userId => `${basePath}/${userId}`;
+}
+function userUploadsFolderStoragePathFactory({
+  bucketId,
+  basePath: inputBasePath
+}) {
+  const userUploadsFolderSlashPath = userUploadsFolderSlashPathFactory(inputBasePath);
+  return userId => ({
+    pathString: userUploadsFolderSlashPath(userId),
+    bucketId
+  });
+}
+
+/**
+ * The role used for uploading files.
+ */
+const STORAGE_FILE_UPLOAD_USER_ROLE = 'uploads';
+/**
+ * AuthRoleClaimsFactoryConfigEntrySimpleOptions configuration for adding the "uploads" role to the user when the disable uploads claim is not present.
+ */
+const storageFileUploadUserSimpleClaimsConfiguration = {
+  roles: STORAGE_FILE_UPLOAD_USER_ROLE,
+  inverse: true
+};
+
+/**
+ * Lower determination level.
+ */
+const LOW_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL = 1;
+/**
+ * Default determination level.
+ */
+const DEFAULT_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL = 2;
+/**
+ * High determination level.
+ */
+const HIGH_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL = 3;
+/**
+ * Exact match determination level.
+ *
+ * The default highest determination level.
+ */
+const EXACT_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL = 10;
+/**
+ * Creates an UploadedFileTypeDeterminer that determines the upload type based on the file name.
+ *
+ * @param config The configuration for the determiner.
+ * @returns The determiner.
+ */
+function determineByFileName(config) {
+  const {
+    fileType,
+    match,
+    exactMatchDeterminationLevel: inputExactMatchDeterminationLevel,
+    nameMatchDeterminationLevel: inputNameMatchDeterminationLevel
+  } = config;
+  const mustMatchExactly = match.includes(util.SLASH_PATH_FILE_TYPE_SEPARATOR);
+  const exactMatchDeterminationLevel = inputExactMatchDeterminationLevel ?? EXACT_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL;
+  const nameMatchDeterminationLevel = inputNameMatchDeterminationLevel ?? HIGH_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL;
+  const testFileName = mustMatchExactly ? fileName => fileName === match ? exactMatchDeterminationLevel : undefined // exact match
+  : fileName => fileName.startsWith(match) ? nameMatchDeterminationLevel : undefined; // name match
+  return {
+    determine: input => {
+      let result;
+      const pathDetails = input.getPathDetails();
+      if (pathDetails.file) {
+        const matchLevel = testFileName(pathDetails.file);
+        if (matchLevel != null) {
+          result = {
+            input,
+            type: fileType,
+            level: matchLevel
+          };
+        }
+      }
+      return result;
+    },
+    getPossibleFileTypes: () => [fileType]
+  };
+}
+/**
+ * Creates an UploadedFileTypeDeterminer that determines the upload type based on the folder name.
+ *
+ * @param config The configuration for the determiner.
+ * @returns The determiner.
+ */
+function determineByFolderName(config) {
+  const {
+    fileType,
+    match
+  } = config;
+  return {
+    determine: input => {
+      const pathDetails = input.getPathDetails();
+      const folderPath = pathDetails.folderPath;
+      let result;
+      if (folderPath === match) {
+        result = {
+          input,
+          type: fileType,
+          level: EXACT_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL
+        };
+      }
+      return result;
+    },
+    getPossibleFileTypes: () => [fileType]
+  };
+}
+/**
+ * Creates an UploadedFileTypeDeterminer that determines the upload type based on the file name.
+ *
+ * @param config The configuration for the determiner.
+ * @returns The determiner.
+ */
+function determineByFilePath(config) {
+  const {
+    fileType,
+    match,
+    matchDeterminationLevel: inputMatchDeterminationLevel,
+    matchBucket: inputMatchBucket,
+    matchFileDetails: inputMatchFile
+  } = config;
+  const pathMatcher = util.slashPathPathMatcher(match);
+  const matchBucket = typeof inputMatchBucket === 'function' ? inputMatchBucket : util.decisionFunction(true);
+  const matchFileDetails = typeof inputMatchFile === 'function' ? inputMatchFile : util.decisionFunction(true);
+  const matchDeterminationLevel = inputMatchDeterminationLevel ?? HIGH_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL;
+  return {
+    determine: input => {
+      let result;
+      const {
+        bucketId,
+        pathString
+      } = input.input;
+      if (matchBucket(bucketId)) {
+        const {
+          matchesTargetPath
+        } = pathMatcher(pathString);
+        if (matchesTargetPath && matchFileDetails(input)) {
+          result = {
+            input,
+            type: fileType,
+            level: matchDeterminationLevel
+          };
+        }
+      }
+      return result;
+    },
+    getPossibleFileTypes: () => [fileType]
+  };
+}
+/**
+ * Wraps a separate UploadedFileTypeDeterminer and adds user determination based on folder path structure.
+ *
+ * @param config Configuration.
+ */
+function determineUserByFolderWrapperFunction(config) {
+  const {
+    rootFolder,
+    userFolderPrefix,
+    requireUser = false,
+    allowSubPaths: inputAllowSubPaths = true
+  } = config;
+  const allowSubPaths = inputAllowSubPaths ?? true;
+  const subPathMatcherConfig = config.matchSubPath ?? {
+    basePath: util.mergeSlashPaths([rootFolder, userFolderPrefix])
+  };
+  const pathMatcher = util.slashPathSubPathMatcher(subPathMatcherConfig);
+  return determiner => {
+    return {
+      determine: async input => {
+        const determinerResult = await determiner.determine(input);
+        let result;
+        if (determinerResult) {
+          if (determinerResult.user) {
+            result = determinerResult;
+          } else {
+            const pathDetails = input.getPathDetails();
+            const pathRootFolder = pathDetails.parts[0];
+            if (pathRootFolder === rootFolder) {
+              // root folder matches, continue
+              const {
+                matchesBasePath,
+                subPathParts
+              } = pathMatcher(pathDetails.path);
+              if (matchesBasePath && (allowSubPaths ? subPathParts.length >= 2 : subPathParts.length === 2)) {
+                // must have two parts: the user folder and the file
+                const user = subPathParts[0];
+                result = {
+                  ...determinerResult,
+                  user
+                };
+              }
+            }
+          }
+          // If requireUser is true and no user was detected, return null.
+          if (requireUser && !result?.user) {
+            result = null;
+          }
+        }
+        return result;
+      },
+      getPossibleFileTypes: () => determiner.getPossibleFileTypes()
+    };
+  };
+}
+function determineUserByUserUploadsFolderWrapperFunction(config) {
+  return determineUserByFolderWrapperFunction({
+    ...config,
+    rootFolder: UPLOADS_FOLDER_PATH,
+    userFolderPrefix: ALL_USER_UPLOADS_FOLDER_NAME
+  });
+}
+/**
+ * Convenience function for using determineUserByFolderWrapperFunction directly on a pre-set determiner.
+ *
+ * @param config Configuration.
+ * @returns The wrapped UploadedFileTypeDeterminer.
+ */
+function determineUserByFolder(config) {
+  return determineUserByFolderWrapperFunction(config)(config.determiner);
+}
+/**
+ * Wraps an UploadedFileTypeDeterminer to only allow respond to certain file types.
+ *
+ * @param determiner The determiner to wrap.
+ * @param types The file types to allow.
+ */
+function limitUploadFileTypeDeterminer(determiner, types) {
+  const allowedTypes = util.asArray(types);
+  const allowedTypeSet = new Set(allowedTypes);
+  return {
+    determine: async input => {
+      const result = await determiner.determine(input);
+      // if the result's type is not in the allowed types, return null.
+      return result && allowedTypeSet.has(result.type) ? result : null;
+    },
+    getPossibleFileTypes: () => allowedTypes
+  };
+}
+/**
+ * Combines multiple UploadedFileTypeDeterminer instances into a single determiner.
+ *
+ * If a single determiner is provided, it will be returned and not wrapped.
+ *
+ * @param determiners The determiners to combine.
+ * @returns The combined determiner.
+ */
+function combineUploadFileTypeDeterminers(config) {
+  const {
+    determiners,
+    completeSearchAtLevel: inputCompleteSearchAtLevel,
+    completeSearchOnFirstMatch: inputCompleteSearchOnFirstMatch
+  } = config;
+  let result;
+  if (determiners.length === 1) {
+    result = determiners[0];
+  } else {
+    const possibleFileTypes = util.unique(determiners.map(d => d.getPossibleFileTypes()).flat());
+    const completeSearchOnFirstMatch = Boolean(inputCompleteSearchOnFirstMatch);
+    const completeSearchAtLevel = completeSearchOnFirstMatch ? LOW_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL : inputCompleteSearchAtLevel ?? EXACT_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL;
+    result = {
+      determine: async input => {
+        let result;
+        for (const determiner of determiners) {
+          const stepResult = await determiner.determine(input);
+          if (stepResult) {
+            if (stepResult.level >= completeSearchAtLevel) {
+              result = stepResult;
+              break;
+            } else if (!result || stepResult.level > result.level) {
+              result = stepResult; // update result to the higher level match
+            }
+          }
+        }
+        return result;
+      },
+      getPossibleFileTypes: () => possibleFileTypes
+    };
+  }
+  return result;
+}
+
 // MARK: Collection
 class SystemStateFirestoreCollections {}
 // MARK: Mock Item
@@ -10030,6 +11254,9 @@ function systemStateFirestoreCollection(firestoreContext, converters) {
   });
 }
 
+exports.ALL_STORAGE_FILE_NOTIFICATION_TASK_TYPES = ALL_STORAGE_FILE_NOTIFICATION_TASK_TYPES;
+exports.ALL_USER_UPLOADS_FOLDER_NAME = ALL_USER_UPLOADS_FOLDER_NAME;
+exports.ALL_USER_UPLOADS_FOLDER_PATH = ALL_USER_UPLOADS_FOLDER_PATH;
 exports.AbstractFirestoreDocument = AbstractFirestoreDocument;
 exports.AbstractFirestoreDocumentDataAccessorWrapper = AbstractFirestoreDocumentDataAccessorWrapper;
 exports.AbstractFirestoreDocumentWithParent = AbstractFirestoreDocumentWithParent;
@@ -10045,6 +11272,7 @@ exports.ContextGrantedModelRolesReaderInstance = ContextGrantedModelRolesReaderI
 exports.CreateNotificationBoxParams = CreateNotificationBoxParams;
 exports.CreateNotificationSummaryParams = CreateNotificationSummaryParams;
 exports.CreateNotificationUserParams = CreateNotificationUserParams;
+exports.CreateStorageFileParams = CreateStorageFileParams;
 exports.DBX_FIREBASE_SERVER_NO_AUTH_ERROR_CODE = DBX_FIREBASE_SERVER_NO_AUTH_ERROR_CODE;
 exports.DBX_FIREBASE_SERVER_NO_UID_ERROR_CODE = DBX_FIREBASE_SERVER_NO_UID_ERROR_CODE;
 exports.DEFAULT_DATE_CELL_RANGE_VALUE = DEFAULT_DATE_CELL_RANGE_VALUE;
@@ -10054,11 +11282,17 @@ exports.DEFAULT_FIRESTORE_STRING_FIELD_VALUE = DEFAULT_FIRESTORE_STRING_FIELD_VA
 exports.DEFAULT_FIRESTORE_UNITED_STATES_ADDRESS_VALUE = DEFAULT_FIRESTORE_UNITED_STATES_ADDRESS_VALUE;
 exports.DEFAULT_FIRESTORE_WEBSITE_FILE_LINK_VALUE = DEFAULT_FIRESTORE_WEBSITE_FILE_LINK_VALUE;
 exports.DEFAULT_ITERATE_FIRESTORE_DOCUMENT_SNAPSHOT_BATCHES_BATCH_SIZE = DEFAULT_ITERATE_FIRESTORE_DOCUMENT_SNAPSHOT_BATCHES_BATCH_SIZE;
+exports.DEFAULT_MAX_STORAGE_FILE_PROCESSING_CLEANUP_RETRY_ATTEMPTS = DEFAULT_MAX_STORAGE_FILE_PROCESSING_CLEANUP_RETRY_ATTEMPTS;
 exports.DEFAULT_NOTIFICATION_TASK_NOTIFICATION_MODEL_KEY = DEFAULT_NOTIFICATION_TASK_NOTIFICATION_MODEL_KEY;
 exports.DEFAULT_NOTIFICATION_TEMPLATE_TYPE = DEFAULT_NOTIFICATION_TEMPLATE_TYPE;
 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_STORAGE_FILE_PROCESSING_CLEANUP_RETRY_DELAY = DEFAULT_STORAGE_FILE_PROCESSING_CLEANUP_RETRY_DELAY;
+exports.DEFAULT_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL = DEFAULT_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL;
 exports.DEFAULT_WEBSITE_LINK = DEFAULT_WEBSITE_LINK;
+exports.DeleteAllQueuedStorageFilesParams = DeleteAllQueuedStorageFilesParams;
+exports.DeleteStorageFileParams = DeleteStorageFileParams;
+exports.EXACT_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL = EXACT_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL;
 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;
@@ -10098,14 +11332,18 @@ exports.FIRESTORE_WHERE_QUERY_CONSTRAINT_TYPE = FIRESTORE_WHERE_QUERY_CONSTRAINT
 exports.FirebaseDevelopmentFunctions = FirebaseDevelopmentFunctions;
 exports.FirebaseModelPermissionServiceInstance = FirebaseModelPermissionServiceInstance;
 exports.FirebaseServerError = FirebaseServerError;
+exports.HIGH_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL = HIGH_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL;
 exports.InferredTargetModelIdParams = InferredTargetModelIdParams;
 exports.InferredTargetModelParams = InferredTargetModelParams;
 exports.InitializeAllApplicableNotificationBoxesParams = InitializeAllApplicableNotificationBoxesParams;
 exports.InitializeAllApplicableNotificationSummariesParams = InitializeAllApplicableNotificationSummariesParams;
+exports.InitializeAllStorageFilesFromUploadsParams = InitializeAllStorageFilesFromUploadsParams;
 exports.InitializeNotificationModelParams = InitializeNotificationModelParams;
+exports.InitializeStorageFileFromUploadParams = InitializeStorageFileFromUploadParams;
 exports.IsFirestoreModelId = IsFirestoreModelId;
 exports.IsFirestoreModelIdOrKey = IsFirestoreModelIdOrKey;
 exports.IsFirestoreModelKey = IsFirestoreModelKey;
+exports.LOW_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL = LOW_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL;
 exports.MAX_FIRESTORE_MAP_ZOOM_LEVEL_VALUE = MAX_FIRESTORE_MAP_ZOOM_LEVEL_VALUE;
 exports.MIN_FIRESTORE_MAP_ZOOM_LEVEL_VALUE = MIN_FIRESTORE_MAP_ZOOM_LEVEL_VALUE;
 exports.MODEL_FUNCTION_FIREBASE_CRUD_FUNCTION_SPECIFIER_DEFAULT = MODEL_FUNCTION_FIREBASE_CRUD_FUNCTION_SPECIFIER_DEFAULT;
@@ -10139,18 +11377,38 @@ exports.NotificationRecipientParams = NotificationRecipientParams;
 exports.NotificationSummaryDocument = NotificationSummaryDocument;
 exports.NotificationUserDocument = NotificationUserDocument;
 exports.NotificationWeekDocument = NotificationWeekDocument;
+exports.ProcessAllQueuedStorageFilesParams = ProcessAllQueuedStorageFilesParams;
+exports.ProcessStorageFileParams = ProcessStorageFileParams;
 exports.RUN_DEV_FUNCTION_APP_FUNCTION_KEY = RUN_DEV_FUNCTION_APP_FUNCTION_KEY;
 exports.ResyncAllNotificationUserParams = ResyncAllNotificationUserParams;
 exports.ResyncNotificationUserParams = ResyncNotificationUserParams;
 exports.SCHEDULED_FUNCTION_DEV_FUNCTION_SPECIFIER = SCHEDULED_FUNCTION_DEV_FUNCTION_SPECIFIER;
+exports.STORAGE_FILE_ALREADY_PROCESSED_ERROR_CODE = STORAGE_FILE_ALREADY_PROCESSED_ERROR_CODE;
+exports.STORAGE_FILE_CANNOT_BE_DELETED_YET_ERROR_CODE = STORAGE_FILE_CANNOT_BE_DELETED_YET_ERROR_CODE;
+exports.STORAGE_FILE_NOT_FLAGGED_FOR_DELETION_ERROR_CODE = STORAGE_FILE_NOT_FLAGGED_FOR_DELETION_ERROR_CODE;
+exports.STORAGE_FILE_PROCESSING_NOTIFICATION_TASK_TYPE = STORAGE_FILE_PROCESSING_NOTIFICATION_TASK_TYPE;
+exports.STORAGE_FILE_PROCESSING_NOT_ALLOWED_FOR_INVALID_STATE_ERROR_CODE = STORAGE_FILE_PROCESSING_NOT_ALLOWED_FOR_INVALID_STATE_ERROR_CODE;
+exports.STORAGE_FILE_PROCESSING_NOT_AVAILABLE_FOR_TYPE_ERROR_CODE = STORAGE_FILE_PROCESSING_NOT_AVAILABLE_FOR_TYPE_ERROR_CODE;
+exports.STORAGE_FILE_PROCESSING_NOT_QUEUED_FOR_PROCESSING_ERROR_CODE = STORAGE_FILE_PROCESSING_NOT_QUEUED_FOR_PROCESSING_ERROR_CODE;
+exports.STORAGE_FILE_PROCESSING_STUCK_THROTTLE_CHECK_MS = STORAGE_FILE_PROCESSING_STUCK_THROTTLE_CHECK_MS;
+exports.STORAGE_FILE_UPLOAD_USER_ROLE = STORAGE_FILE_UPLOAD_USER_ROLE;
 exports.ScheduledFunctionDevelopmentFirebaseFunctionListEntry = ScheduledFunctionDevelopmentFirebaseFunctionListEntry;
 exports.ScheduledFunctionDevelopmentFirebaseFunctionParams = ScheduledFunctionDevelopmentFirebaseFunctionParams;
 exports.SendNotificationParams = SendNotificationParams;
 exports.SendQueuedNotificationsParams = SendQueuedNotificationsParams;
+exports.StorageFileDocument = StorageFileDocument;
+exports.StorageFileFirestoreCollections = StorageFileFirestoreCollections;
+exports.StorageFileFunctions = StorageFileFunctions;
+exports.StorageFileUploadStreamUnsupportedError = StorageFileUploadStreamUnsupportedError;
 exports.SystemStateDocument = SystemStateDocument;
 exports.SystemStateFirestoreCollections = SystemStateFirestoreCollections;
 exports.TargetModelIdParams = TargetModelIdParams;
 exports.TargetModelParams = TargetModelParams;
+exports.UPLOADED_FILE_DOES_NOT_EXIST_ERROR_CODE = UPLOADED_FILE_DOES_NOT_EXIST_ERROR_CODE;
+exports.UPLOADED_FILE_INITIALIZATION_DISCARDED_ERROR_CODE = UPLOADED_FILE_INITIALIZATION_DISCARDED_ERROR_CODE;
+exports.UPLOADED_FILE_INITIALIZATION_FAILED_ERROR_CODE = UPLOADED_FILE_INITIALIZATION_FAILED_ERROR_CODE;
+exports.UPLOADED_FILE_NOT_ALLOWED_TO_BE_INITIALIZED_ERROR_CODE = UPLOADED_FILE_NOT_ALLOWED_TO_BE_INITIALIZED_ERROR_CODE;
+exports.UPLOADS_FOLDER_PATH = UPLOADS_FOLDER_PATH;
 exports.UpdateNotificationBoxParams = UpdateNotificationBoxParams;
 exports.UpdateNotificationBoxRecipientLikeParams = UpdateNotificationBoxRecipientLikeParams;
 exports.UpdateNotificationBoxRecipientParams = UpdateNotificationBoxRecipientParams;
@@ -10158,6 +11416,7 @@ exports.UpdateNotificationSummaryParams = UpdateNotificationSummaryParams;
 exports.UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams = UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams;
 exports.UpdateNotificationUserNotificationBoxRecipientParams = UpdateNotificationUserNotificationBoxRecipientParams;
 exports.UpdateNotificationUserParams = UpdateNotificationUserParams;
+exports.UpdateStorageFileParams = UpdateStorageFileParams;
 exports.addConstraintToBuilder = addConstraintToBuilder;
 exports.addOrReplaceLimitInConstraints = addOrReplaceLimitInConstraints;
 exports.allChildDocumentsUnderParent = allChildDocumentsUnderParent;
@@ -10185,12 +11444,14 @@ exports.childFirestoreModelKeyPath = childFirestoreModelKeyPath;
 exports.childFirestoreModelKeys = childFirestoreModelKeys;
 exports.clientFirebaseFirestoreContextFactory = clientFirebaseFirestoreContextFactory;
 exports.clientFirebaseStorageContextFactory = clientFirebaseStorageContextFactory;
+exports.combineUploadFileTypeDeterminers = combineUploadFileTypeDeterminers;
 exports.contextGrantedModelRolesReader = contextGrantedModelRolesReader;
 exports.contextGrantedModelRolesReaderDoesNotExistErrorMessage = contextGrantedModelRolesReaderDoesNotExistErrorMessage;
 exports.contextGrantedModelRolesReaderPermissionErrorMessage = contextGrantedModelRolesReaderPermissionErrorMessage;
 exports.convertHttpsCallableErrorToReadableError = convertHttpsCallableErrorToReadableError;
 exports.copyDocumentIdForUserRelatedModifierFunction = copyDocumentIdForUserRelatedModifierFunction;
 exports.copyDocumentIdToFieldModifierFunction = copyDocumentIdToFieldModifierFunction;
+exports.copyStoragePath = copyStoragePath;
 exports.copyUserRelatedDataAccessorFactoryFunction = copyUserRelatedDataAccessorFactoryFunction;
 exports.copyUserRelatedDataModifierConfig = copyUserRelatedDataModifierConfig;
 exports.createNotificationDocument = createNotificationDocument;
@@ -10198,9 +11459,17 @@ exports.createNotificationDocumentIfSending = createNotificationDocumentIfSendin
 exports.createNotificationDocumentPair = createNotificationDocumentPair;
 exports.createNotificationTaskTemplate = createNotificationTaskTemplate;
 exports.createNotificationTemplate = createNotificationTemplate;
+exports.createStorageFileDocumentPair = createStorageFileDocumentPair;
+exports.createStorageFileDocumentPairFactory = createStorageFileDocumentPairFactory;
 exports.dataFromDocumentSnapshots = dataFromDocumentSnapshots;
 exports.dataFromSnapshotStream = dataFromSnapshotStream;
 exports.delayCompletion = delayCompletion;
+exports.determineByFileName = determineByFileName;
+exports.determineByFilePath = determineByFilePath;
+exports.determineByFolderName = determineByFolderName;
+exports.determineUserByFolder = determineUserByFolder;
+exports.determineUserByFolderWrapperFunction = determineUserByFolderWrapperFunction;
+exports.determineUserByUserUploadsFolderWrapperFunction = determineUserByUserUploadsFolderWrapperFunction;
 exports.developmentFirebaseFunctionMapFactory = developmentFirebaseFunctionMapFactory;
 exports.directDataHttpsCallable = directDataHttpsCallable;
 exports.documentData = documentData;
@@ -10274,6 +11543,8 @@ exports.firestoreEnum = firestoreEnum;
 exports.firestoreEnumArray = firestoreEnumArray;
 exports.firestoreField = firestoreField;
 exports.firestoreFieldConfigToModelMapFunctionsRef = firestoreFieldConfigToModelMapFunctionsRef;
+exports.firestoreFixedItemPageIteration = firestoreFixedItemPageIteration;
+exports.firestoreFixedItemPageIterationFactory = firestoreFixedItemPageIterationFactory;
 exports.firestoreIdBatchVerifierFactory = firestoreIdBatchVerifierFactory;
 exports.firestoreIdentityTypeArray = firestoreIdentityTypeArray;
 exports.firestoreIdentityTypeArrayName = firestoreIdentityTypeArrayName;
@@ -10387,6 +11658,9 @@ exports.iterateFirestoreDocumentSnapshotCheckpoints = iterateFirestoreDocumentSn
 exports.iterateFirestoreDocumentSnapshotPairBatches = iterateFirestoreDocumentSnapshotPairBatches;
 exports.iterateFirestoreDocumentSnapshotPairs = iterateFirestoreDocumentSnapshotPairs;
 exports.iterateFirestoreDocumentSnapshots = iterateFirestoreDocumentSnapshots;
+exports.iterateStorageListFiles = iterateStorageListFiles;
+exports.iterateStorageListFilesByEachFile = iterateStorageListFilesByEachFile;
+exports.iterateStorageListFilesFactory = iterateStorageListFilesFactory;
 exports.iterationQueryDocChangeWatcher = iterationQueryDocChangeWatcher;
 exports.iterationQueryDocChangeWatcherChangeTypeForGroup = iterationQueryDocChangeWatcherChangeTypeForGroup;
 exports.latestDataFromDocuments = latestDataFromDocuments;
@@ -10394,6 +11668,7 @@ exports.latestSnapshotsFromDocuments = latestSnapshotsFromDocuments;
 exports.lazyFirebaseFunctionsFactory = lazyFirebaseFunctionsFactory;
 exports.limit = limit;
 exports.limitToLast = limitToLast;
+exports.limitUploadFileTypeDeterminer = limitUploadFileTypeDeterminer;
 exports.limitedFirestoreDocumentAccessorFactory = limitedFirestoreDocumentAccessorFactory;
 exports.loadAllFirestoreDocumentSnapshot = loadAllFirestoreDocumentSnapshot;
 exports.loadAllFirestoreDocumentSnapshotPairs = loadAllFirestoreDocumentSnapshotPairs;
@@ -10456,6 +11731,7 @@ exports.notificationSummaryFirestoreCollection = notificationSummaryFirestoreCol
 exports.notificationSummaryIdForModel = notificationSummaryIdForModel;
 exports.notificationSummaryIdForUidFunctionForRootFirestoreModelIdentity = notificationSummaryIdForUidFunctionForRootFirestoreModelIdentity;
 exports.notificationSummaryIdentity = notificationSummaryIdentity;
+exports.notificationTaskCanRunNextCheckpoint = notificationTaskCanRunNextCheckpoint;
 exports.notificationTaskComplete = notificationTaskComplete;
 exports.notificationTaskDelayRetry = notificationTaskDelayRetry;
 exports.notificationTaskFailed = notificationTaskFailed;
@@ -10514,9 +11790,22 @@ exports.sortNotificationItemsFunction = sortNotificationItemsFunction;
 exports.startAfter = startAfter;
 exports.startAt = startAt;
 exports.startAtValue = startAtValue;
+exports.storageFileCollectionReference = storageFileCollectionReference;
+exports.storageFileConverter = storageFileConverter;
+exports.storageFileFirestoreCollection = storageFileFirestoreCollection;
+exports.storageFileFunctionMap = storageFileFunctionMap;
+exports.storageFileFunctionTypeConfigMap = storageFileFunctionTypeConfigMap;
+exports.storageFileIdentity = storageFileIdentity;
+exports.storageFileModelCrudFunctionsConfig = storageFileModelCrudFunctionsConfig;
+exports.storageFileProcessingNotificationTaskTemplate = storageFileProcessingNotificationTaskTemplate;
+exports.storageFilePurposeAndUserQuery = storageFilePurposeAndUserQuery;
+exports.storageFileUploadUserSimpleClaimsConfiguration = storageFileUploadUserSimpleClaimsConfiguration;
+exports.storageFilesQueuedForDeleteQuery = storageFilesQueuedForDeleteQuery;
+exports.storageFilesQueuedForProcessingQuery = storageFilesQueuedForProcessingQuery;
 exports.storageListFilesResultFactory = storageListFilesResultFactory;
 exports.storageListFilesResultHasNoNextError = storageListFilesResultHasNoNextError;
 exports.storagePathFactory = storagePathFactory;
+exports.storedFileReaderFactory = storedFileReaderFactory;
 exports.streamFromOnSnapshot = streamFromOnSnapshot;
 exports.systemStateCollectionReference = systemStateCollectionReference;
 exports.systemStateConverter = systemStateConverter;
@@ -10532,11 +11821,14 @@ exports.updateNotificationUserNotificationBoxRecipientConfigIfChanged = updateNo
 exports.updateNotificationUserNotificationBoxRecipientConfigs = updateNotificationUserNotificationBoxRecipientConfigs;
 exports.updateNotificationUserNotificationSendExclusions = updateNotificationUserNotificationSendExclusions;
 exports.updateWithAccessorUpdateAndConverterFunction = updateWithAccessorUpdateAndConverterFunction;
+exports.uploadFileWithStream = uploadFileWithStream;
 exports.useContextAuth = useContextAuth;
 exports.useContextAuthUid = useContextAuthUid;
 exports.useDocumentSnapshot = useDocumentSnapshot;
 exports.useDocumentSnapshotData = useDocumentSnapshotData;
 exports.useFirebaseModelsService = useFirebaseModelsService;
+exports.userUploadsFolderSlashPathFactory = userUploadsFolderSlashPathFactory;
+exports.userUploadsFolderStoragePathFactory = userUploadsFolderStoragePathFactory;
 exports.where = where;
 exports.whereDateIsAfter = whereDateIsAfter;
 exports.whereDateIsAfterWithSort = whereDateIsAfterWithSort;