@dereekb/firebase-server 12.7.0 → 13.0.1

package/model/index.cjs.js

@@ -0,0 +1,4767 @@
+'use strict';
+
+var util = require('@dereekb/util');
+var date = require('@dereekb/date');
+var firebase = require('@dereekb/firebase');
+var firebaseServer = require('@dereekb/firebase-server');
+var dateFns = require('date-fns');
+var common = require('@nestjs/common');
+var config = require('@nestjs/config');
+var makeError = require('make-error');
+var archiver = require('archiver');
+
+const MAILGUN_NOTIFICATION_EMAIL_SEND_SERVICE_DEFAULT_MAX_BATCH_SIZE_PER_REQUEST = 50;
+function mailgunNotificationEmailSendService(config) {
+    const { mailgunService, defaultSendTemplateName, maxBatchSizePerRequest: inputMaxBatchSizePerRequest, messageBuilders: inputMessageBuilders } = config;
+    const lowercaseKeysMessageBuilders = util.mapObjectKeysToLowercase(inputMessageBuilders);
+    const maxBatchSizePerRequest = inputMaxBatchSizePerRequest ?? MAILGUN_NOTIFICATION_EMAIL_SEND_SERVICE_DEFAULT_MAX_BATCH_SIZE_PER_REQUEST;
+    const sendService = {
+        async buildSendInstanceForEmailNotificationMessages(notificationMessages) {
+            const templateMap = util.multiValueMapBuilder();
+            // group by templates
+            notificationMessages.forEach((x) => {
+                const sendTemplateName = x.emailContent?.sendTemplateName ?? x.content.sendTemplateName ?? defaultSendTemplateName;
+                if (sendTemplateName == null) {
+                    throw new Error(`mailgunNotificationEmailSendService(): A sendTemplateName for a message was not available and no default was provided. Consider configuring a default send template.`);
+                }
+                templateMap.add(sendTemplateName, x);
+            });
+            // build send batches
+            const messageSendBatches = templateMap.entries().flatMap(([templateType, messages]) => {
+                return util.batch(messages, maxBatchSizePerRequest).map((x) => [templateType, x]);
+            });
+            // create the template requests
+            const templateRequestArrays = await Promise.all(messageSendBatches.map(async ([sendTemplateName, messages]) => {
+                const sendTemplateNameToLowercase = sendTemplateName.toLowerCase();
+                const builderForKey = lowercaseKeysMessageBuilders[sendTemplateNameToLowercase];
+                if (!builderForKey) {
+                    throw new Error(`mailgunNotificationEmailSendService(): A template builder was not available for template type "${sendTemplateName}".`);
+                }
+                else {
+                    const input = { mailgunService, sendTemplateName, messages };
+                    return builderForKey(input);
+                }
+            }));
+            const templateRequests = templateRequestArrays.flat();
+            const sendFn = async () => {
+                const success = [];
+                const failed = [];
+                // send the template emails
+                await util.runAsyncTasksForValues(templateRequests, (x) => {
+                    const recipients = util.asArray(x.to).map((z) => z.email);
+                    return mailgunService
+                        .sendTemplateEmail(x)
+                        .then(() => {
+                        util.pushArrayItemsIntoArray(success, recipients);
+                    })
+                        .catch((e) => {
+                        util.pushArrayItemsIntoArray(failed, recipients);
+                        console.error('mailgunNotificationEmailSendService(): failed sending template emails', e);
+                        // suppress error
+                    });
+                }, { maxParallelTasks: 3 });
+                const result = {
+                    success,
+                    failed,
+                    ignored: []
+                };
+                return result;
+            };
+            return sendFn;
+        }
+    };
+    return sendService;
+}
+
+function createNotificationIdRequiredError() {
+    return firebaseServer.preconditionConflictError({
+        message: `The required id was not present when attempting to create a Notification.`,
+        code: firebase.CREATE_NOTIFICATION_ID_REQUIRED_ERROR_CODE
+    });
+}
+function notificationModelAlreadyInitializedError() {
+    return firebaseServer.preconditionConflictError({
+        message: `This model has already been initialized.`,
+        code: firebase.NOTIFICATION_MODEL_ALREADY_INITIALIZED_ERROR_CODE
+    });
+}
+function notificationBoxUnregistredModelTypeInitializationError(key) {
+    return firebaseServer.preconditionConflictError({
+        message: `This NotificationBox is associated with an unregistered model type.`,
+        code: firebase.NOTIFICATION_MODEL_ALREADY_INITIALIZED_ERROR_CODE,
+        data: {
+            key
+        }
+    });
+}
+function notificationBoxDoesNotExist() {
+    return firebaseServer.preconditionConflictError({
+        message: `A NotificationBox does not exist for this model.`,
+        code: firebase.NOTIFICATION_BOX_DOES_NOT_EXIST_ERROR_CODE
+    });
+}
+function notificationBoxExclusionTargetInvalidError() {
+    return firebaseServer.preconditionConflictError({
+        message: `The target for exclusion is invalid. The target recipient on the NotificationBox must be exist on the NotificationBox and have a uid to be excluded.`,
+        code: firebase.NOTIFICATION_BOX_EXCLUSION_TARGET_INVALID_ERROR_CODE
+    });
+}
+function notificationBoxExistsForModelError() {
+    return firebaseServer.preconditionConflictError({
+        message: `A NotificationBox already exists for this model.`,
+        code: firebase.NOTIFICATION_BOX_EXISTS_FOR_MODEL_ERROR_CODE
+    });
+}
+function notificationBoxRecipientDoesNotExistsError() {
+    return firebaseServer.preconditionConflictError({
+        message: `An existing NotificationBox recipient for the target does not exist. You must pass insert=true to create a new recipient.`,
+        code: firebase.NOTIFICATION_BOX_RECIPIENT_DOES_NOT_EXIST_ERROR_CODE
+    });
+}
+function notificationUserInvalidUidForCreateError(uid) {
+    return firebaseServer.preconditionConflictError({
+        message: `The user with the uid '${uid}' does not exist. Cannot create a NotificationUser for them.`,
+        code: firebase.NOTIFICATION_USER_INVALID_UID_FOR_CREATE_ERROR_CODE,
+        data: {
+            uid
+        }
+    });
+}
+function notificationUserBlockedFromBeingAddedToRecipientsError(uid) {
+    return firebaseServer.preconditionConflictError({
+        message: `The user with the uid '${uid}' has blocked themselves from from being added recipients.`,
+        code: firebase.NOTIFICATION_USER_BLOCKED_FROM_BEING_ADD_TO_RECIPIENTS_ERROR_CODE,
+        data: {
+            uid
+        }
+    });
+}
+function notificationUserLockedConfigFromBeingUpdatedError(uid) {
+    return firebaseServer.preconditionConflictError({
+        message: `The user with the uid '${uid}' has locked their config from being updated.`,
+        code: firebase.NOTIFICATION_USER_LOCKED_CONFIG_FROM_BEING_UPDATED_ERROR_CODE,
+        data: {
+            uid
+        }
+    });
+}
+
+// MARK: Create NotificationSummary
+function makeNewNotificationSummaryTemplate(model) {
+    return {
+        cat: new Date(),
+        m: model,
+        o: firebase.firestoreDummyKey(),
+        s: true,
+        n: []
+    };
+}
+/**
+ * "Expands" the input into recipients for emails, texts, etc.
+ *
+ * Recipients may come from the NotificationBox, Notification or from the global recipients.
+ *
+ * Recipients are each configurable and may be defined with as little info as a single contact info, or have multiple contact info pieces associated with them.
+ *
+ * @param input
+ * @returns
+ */
+async function expandNotificationRecipients(input) {
+    const { notificationUserAccessor, authService, notification, notificationBox, globalRecipients: inputGlobalRecipients, recipientFlagOverride, notificationSummaryIdForUid: inputNotificationSummaryIdForUid, onlySendToExplicitlyEnabledRecipients: inputOnlySendToExplicitlyEnabledRecipients, onlyTextExplicitlyEnabledRecipients: inputOnlyTextExplicitlyEnabledRecipients } = input;
+    const notificationBoxId = notificationBox?.id;
+    const notificationSummaryIdForUid = inputNotificationSummaryIdForUid ?? (() => undefined);
+    const notificationTemplateType = notification.n.t || firebase.DEFAULT_NOTIFICATION_TEMPLATE_TYPE;
+    const recipientFlag = recipientFlagOverride ?? notification.rf ?? firebase.NotificationRecipientSendFlag.NORMAL;
+    const onlyTextExplicitlyEnabledRecipients = inputOnlyTextExplicitlyEnabledRecipients !== false; // defaults to true
+    const onlySendToExplicitlyEnabledRecipients = inputOnlySendToExplicitlyEnabledRecipients === true; // defaults to false
+    const onlyEmailExplicitlyEnabledRecipients = onlySendToExplicitlyEnabledRecipients;
+    const onlySendNotificationSummaryExplicitlyEnabledRecipients = onlySendToExplicitlyEnabledRecipients;
+    const { canSendToGlobalRecipients, canSendToBoxRecipients, canSendToExplicitRecipients } = firebase.allowedNotificationRecipients(recipientFlag);
+    const initialExplicitRecipients = canSendToExplicitRecipients ? notification.r : [];
+    const initialGlobalRecipients = canSendToGlobalRecipients && inputGlobalRecipients ? inputGlobalRecipients : [];
+    const explicitRecipients = initialExplicitRecipients.map((x) => ({
+        ...x,
+        ...firebase.effectiveNotificationBoxRecipientTemplateConfig(x)
+    }));
+    const globalRecipients = initialGlobalRecipients.map((x) => ({
+        ...x,
+        ...firebase.effectiveNotificationBoxRecipientTemplateConfig(x)
+    }));
+    const explicitAndGlobalRecipients = [...explicitRecipients, ...globalRecipients];
+    const allBoxRecipientConfigs = canSendToBoxRecipients && notificationBox ? notificationBox.r : [];
+    const recipientUids = new Set();
+    const relevantBoxRecipientConfigs = [];
+    // find all recipients in the NotificationBox with the target template type flagged for them.
+    allBoxRecipientConfigs.forEach((x) => {
+        // ignore opt-out flagged recipients and excluded recipients
+        if (!x.f && !x.x) {
+            const relevantConfig = x.c[notificationTemplateType];
+            const effectiveTemplateConfig = relevantConfig ? firebase.effectiveNotificationBoxRecipientTemplateConfig(relevantConfig) : undefined;
+            if (!effectiveTemplateConfig || effectiveTemplateConfig.st || effectiveTemplateConfig.se || effectiveTemplateConfig.sp || effectiveTemplateConfig.st) {
+                relevantBoxRecipientConfigs.push({
+                    recipient: x,
+                    effectiveTemplateConfig
+                });
+                if (x.uid) {
+                    recipientUids.add(x.uid);
+                }
+            }
+        }
+    });
+    // add other recipients to the map
+    const nonNotificationBoxUidRecipientConfigs = new Map();
+    explicitAndGlobalRecipients.forEach((x) => {
+        const { uid } = x;
+        if (uid && !recipientUids.has(uid)) {
+            // if already in recipientUids then they are a box recipient and we don't have to try and load them.
+            nonNotificationBoxUidRecipientConfigs.set(uid, x);
+        }
+    });
+    const otherNotificationUserUidOptOuts = new Set();
+    const otherNotificationUserUidSendExclusions = new Set();
+    const notificationUserRecipientConfigs = new Map();
+    if (nonNotificationBoxUidRecipientConfigs.size > 0) {
+        const nonNotificationBoxRecipientUids = Array.from(nonNotificationBoxUidRecipientConfigs.keys());
+        const notificationUserDocuments = firebase.loadDocumentsForIds(notificationUserAccessor, nonNotificationBoxRecipientUids);
+        // Attempt to load the NotificationUser for each uid.
+        // Not guranteed to exist, but those that do we want to their configurations to decide opt-in/opt-out, as well as override the input recipient configuration for the Notification.
+        const notificationUsers = await firebase.getDocumentSnapshotDataPairsWithData(notificationUserDocuments);
+        notificationUsers.forEach((x) => {
+            const { data: notificationUser } = x;
+            const { x: exclusions, dc, gc } = notificationUser;
+            const canSendNotification = firebase.notificationSendExclusionCanSendFunction(exclusions);
+            const effectiveConfig = firebase.mergeNotificationUserDefaultNotificationBoxRecipientConfig(dc, gc);
+            const uid = x.document.id;
+            notificationUserRecipientConfigs.set(uid, effectiveConfig);
+            // check if flagged for opt out on the global/default config
+            if (effectiveConfig.f) {
+                // if flagged for opt out, add to set
+                otherNotificationUserUidOptOuts.add(uid);
+            }
+            const isAllowedToSend = notificationBoxId ? canSendNotification(notificationBoxId) : true;
+            if (!isAllowedToSend) {
+                otherNotificationUserUidSendExclusions.add(uid);
+            }
+        });
+    }
+    /**
+     * Other NotificationRecipientWithConfig
+     */
+    const otherRecipientConfigs = new Map();
+    const explicitOtherRecipientEmailAddresses = new Map();
+    const explicitOtherRecipientTextNumbers = new Map();
+    const explicitOtherRecipientNotificationSummaryIds = new Map();
+    explicitAndGlobalRecipients.forEach((x) => {
+        const uid = x.uid;
+        if (uid) {
+            if (otherNotificationUserUidOptOuts.has(uid) || otherNotificationUserUidSendExclusions.has(uid)) {
+                return; // do not add to the recipients at all, user has opted out or send is excluded
+            }
+            const notificationUserRecipientConfig = notificationUserRecipientConfigs.get(uid);
+            if (notificationUserRecipientConfig != null) {
+                const userTemplateTypeConfig = notificationUserRecipientConfig.c[notificationTemplateType] ?? {};
+                const templateConfig = firebase.mergeNotificationBoxRecipientTemplateConfigs(firebase.effectiveNotificationBoxRecipientTemplateConfig(userTemplateTypeConfig), x);
+                // replace the input NotificationRecipientWithConfig with the user's config
+                x = {
+                    ...notificationUserRecipientConfig,
+                    ...firebase.effectiveNotificationBoxRecipientTemplateConfig(templateConfig),
+                    uid
+                };
+            }
+            recipientUids.add(uid);
+            otherRecipientConfigs.set(uid, x);
+        }
+        if (x.e) {
+            explicitOtherRecipientEmailAddresses.set(x.e.toLowerCase(), x);
+        }
+        if (x.t) {
+            explicitOtherRecipientTextNumbers.set(x.t, x);
+        }
+        if (x.s) {
+            explicitOtherRecipientNotificationSummaryIds.set(x.s, x);
+        }
+    });
+    // load user details from auth service
+    const allUserDetails = await Promise.all(Array.from(recipientUids).map((uid) => authService
+        .userContext(uid)
+        .loadDetails()
+        .then((details) => [uid, details])
+        .catch(() => [uid, undefined])));
+    const userDetailsMap = new Map(allUserDetails);
+    const _internal = {
+        userDetailsMap,
+        explicitRecipients,
+        globalRecipients,
+        allBoxRecipientConfigs,
+        relevantBoxRecipientConfigs,
+        recipientUids,
+        otherRecipientConfigs,
+        explicitOtherRecipientEmailAddresses,
+        explicitOtherRecipientTextNumbers,
+        explicitOtherRecipientNotificationSummaryIds,
+        otherNotificationUserUidOptOuts,
+        otherNotificationUserUidSendExclusions,
+        nonNotificationBoxUidRecipientConfigs,
+        notificationUserRecipientConfigs
+    };
+    // make all email recipients
+    const emails = [];
+    const emailUidsSet = new Set();
+    function checkShouldSendEmail(sendEmailEnabled) {
+        return (!onlyEmailExplicitlyEnabledRecipients && sendEmailEnabled !== false) || (onlyEmailExplicitlyEnabledRecipients && sendEmailEnabled === true);
+    }
+    // start with all box recipients
+    relevantBoxRecipientConfigs.forEach((x) => {
+        const { recipient } = x;
+        const { uid, e: overrideRecipientEmail, n: overrideRecipientName } = recipient;
+        const userDetails = uid ? userDetailsMap.get(uid) : undefined;
+        const otherRecipientForUser = uid ? otherRecipientConfigs.get(uid) : undefined;
+        const sendEmailEnabled = x.effectiveTemplateConfig?.se;
+        const shouldSendEmail = checkShouldSendEmail(sendEmailEnabled);
+        if (shouldSendEmail && !emailUidsSet.has(uid ?? '')) {
+            const e = overrideRecipientEmail ?? userDetails?.email; // use override email or the default email
+            if (e) {
+                const n = overrideRecipientName ?? userDetails?.displayName;
+                const emailAddress = e.toLowerCase();
+                explicitOtherRecipientEmailAddresses.delete(emailAddress); // don't double-send to the same email
+                const emailRecipient = {
+                    emailAddress,
+                    name: n,
+                    boxRecipient: x,
+                    otherRecipient: otherRecipientForUser
+                };
+                emails.push(emailRecipient);
+                if (uid) {
+                    emailUidsSet.add(uid);
+                }
+            }
+        }
+    });
+    otherRecipientConfigs.forEach((x, uid) => {
+        // add users who existing in the system at this step, then other recipients in the next step
+        const userDetails = userDetailsMap.get(uid);
+        if (userDetails) {
+            const { email: userEmailAddress, displayName } = userDetails;
+            const sendEmailEnabled = x.se;
+            const shouldSendEmail = checkShouldSendEmail(sendEmailEnabled);
+            if (userEmailAddress && shouldSendEmail && !emailUidsSet.has(uid)) {
+                const emailAddress = userEmailAddress.toLowerCase();
+                const name = displayName || x.n;
+                const emailRecipient = {
+                    emailAddress,
+                    name,
+                    otherRecipient: x
+                };
+                emails.push(emailRecipient);
+                emailUidsSet.add(uid);
+                explicitOtherRecipientEmailAddresses.delete(emailAddress);
+            }
+        }
+    });
+    explicitOtherRecipientEmailAddresses.forEach((x, emailAddress) => {
+        const sendEmailEnabled = x.se;
+        const shouldSendEmail = checkShouldSendEmail(sendEmailEnabled);
+        if (shouldSendEmail) {
+            const emailRecipient = {
+                emailAddress: emailAddress,
+                name: x.n,
+                otherRecipient: x
+            };
+            emails.push(emailRecipient);
+        }
+    });
+    // make all text recipients
+    // text recipients should be explicitly enabled, or marked true
+    const texts = [];
+    const textUidsSet = new Set();
+    function checkShouldSendText(sendTextEnabled) {
+        return (onlyTextExplicitlyEnabledRecipients && sendTextEnabled === true) || (!onlyTextExplicitlyEnabledRecipients && sendTextEnabled !== false);
+    }
+    relevantBoxRecipientConfigs.forEach((x) => {
+        const { recipient } = x;
+        const { uid } = recipient;
+        const userDetails = uid ? userDetailsMap.get(uid) : undefined;
+        const otherRecipientForUser = uid ? otherRecipientConfigs.get(uid) : undefined;
+        // only send a text if explicitly enabled
+        const sendTextEnabled = x.effectiveTemplateConfig?.st;
+        const shouldSendText = checkShouldSendText(sendTextEnabled);
+        if (shouldSendText && !textUidsSet.has(uid ?? '')) {
+            const t = x.recipient.t ?? userDetails?.phoneNumber; // use override phoneNumber or the default phone
+            if (t) {
+                const name = userDetails?.displayName ?? x.recipient.n;
+                const phoneNumber = t;
+                explicitOtherRecipientTextNumbers.delete(phoneNumber); // don't double-send to the same text phone number
+                const textRecipient = {
+                    phoneNumber,
+                    name,
+                    boxRecipient: x,
+                    otherRecipient: otherRecipientForUser
+                };
+                texts.push(textRecipient);
+                if (uid) {
+                    textUidsSet.add(uid);
+                }
+            }
+        }
+    });
+    otherRecipientConfigs.forEach((x, uid) => {
+        // add users who existing in the system at this step, then other recipients in the next step
+        const userDetails = userDetailsMap.get(uid);
+        if (userDetails) {
+            const { phoneNumber, displayName } = userDetails;
+            const sendTextEnabled = x.st;
+            const sendText = checkShouldSendText(sendTextEnabled);
+            if (phoneNumber != null && sendText && !textUidsSet.has(uid)) {
+                const name = displayName || x.n;
+                const textRecipient = {
+                    phoneNumber: phoneNumber,
+                    name,
+                    otherRecipient: x
+                };
+                texts.push(textRecipient);
+                textUidsSet.add(uid);
+                explicitOtherRecipientTextNumbers.delete(phoneNumber); // don't double-send to the same text phone number
+            }
+        }
+    });
+    explicitOtherRecipientTextNumbers.forEach((x, t) => {
+        const sendTextEnabled = x.st;
+        const shouldSendText = checkShouldSendText(sendTextEnabled);
+        if (shouldSendText) {
+            const textRecipient = {
+                phoneNumber: t,
+                name: x.n,
+                otherRecipient: x
+            };
+            texts.push(textRecipient);
+        }
+    });
+    // TODO: Add push notification details...
+    // make all notification summary recipients
+    const notificationSummaries = [];
+    const notificationSummaryKeysSet = new Set();
+    const notificationSummaryUidsSet = new Set();
+    function checkShouldSendNotificationSummary(sendNotificationSummaryEnabled) {
+        return (!onlySendNotificationSummaryExplicitlyEnabledRecipients && sendNotificationSummaryEnabled !== false) || (onlySendNotificationSummaryExplicitlyEnabledRecipients && sendNotificationSummaryEnabled === true);
+    }
+    relevantBoxRecipientConfigs.forEach((x) => {
+        const { recipient } = x;
+        const { uid } = recipient;
+        const userDetails = uid ? userDetailsMap.get(uid) : undefined;
+        const otherRecipientForUser = uid ? otherRecipientConfigs.get(uid) : undefined;
+        const sendNotificationSummaryEnabled = x.effectiveTemplateConfig?.sn;
+        const shouldSendNotificationSummary = checkShouldSendNotificationSummary(sendNotificationSummaryEnabled);
+        if (shouldSendNotificationSummary) {
+            let notificationSummaryId;
+            if (uid) {
+                // only use the uid (and ignore recipient config) if uid is defined
+                notificationSummaryId = notificationSummaryIdForUid(uid);
+                notificationSummaryUidsSet.add(uid);
+            }
+            else if (x.recipient.s) {
+                notificationSummaryId = x.recipient.s;
+            }
+            if (notificationSummaryId) {
+                const name = userDetails?.displayName ?? x.recipient.n;
+                notificationSummaries.push({
+                    notificationSummaryId,
+                    boxRecipient: x,
+                    otherRecipient: otherRecipientForUser,
+                    name
+                });
+                explicitOtherRecipientNotificationSummaryIds.delete(notificationSummaryId); // don't double send
+            }
+        }
+    });
+    otherRecipientConfigs.forEach((x, uid) => {
+        const userDetails = userDetailsMap.get(uid);
+        if (userDetails) {
+            const { displayName } = userDetails;
+            const sendNotificationSummaryEnabled = x.sn;
+            const shouldSendNotificationSummary = checkShouldSendNotificationSummary(sendNotificationSummaryEnabled);
+            if (shouldSendNotificationSummary && !notificationSummaryUidsSet.has(uid ?? '')) {
+                let notificationSummaryId;
+                if (uid) {
+                    notificationSummaryId = notificationSummaryIdForUid(uid);
+                    notificationSummaryUidsSet.add(uid);
+                }
+                else if (x.s) {
+                    notificationSummaryId = x.s;
+                }
+                if (notificationSummaryId) {
+                    if (!notificationSummaryKeysSet.has(notificationSummaryId)) {
+                        const name = displayName || x.n;
+                        const notificationSummary = {
+                            notificationSummaryId,
+                            otherRecipient: x,
+                            name
+                        };
+                        notificationSummaries.push(notificationSummary);
+                        explicitOtherRecipientNotificationSummaryIds.delete(notificationSummaryId);
+                    }
+                }
+            }
+        }
+    });
+    explicitOtherRecipientNotificationSummaryIds.forEach((x, notificationSummaryId) => {
+        const sendNotificationSummaryEnabled = x.sn;
+        const shouldSendNotificationSummary = checkShouldSendNotificationSummary(sendNotificationSummaryEnabled);
+        if (shouldSendNotificationSummary) {
+            const notificationSummary = {
+                notificationSummaryId,
+                otherRecipient: x,
+                name: x.n
+            };
+            notificationSummaries.push(notificationSummary);
+        }
+    });
+    // results
+    const result = {
+        _internal,
+        emails,
+        texts,
+        notificationSummaries
+    };
+    return result;
+}
+function updateNotificationUserNotificationBoxRecipientConfig(input) {
+    const { notificationBoxId, notificationUserId, notificationUser, insertingRecipientIntoNotificationBox, removeRecipientFromNotificationBox, notificationBoxRecipient } = input;
+    const currentNotificationUserBoxIndex = notificationUser.bc.findIndex((x) => x.nb === notificationBoxId);
+    const currentNotificationUserBoxIndexExists = currentNotificationUserBoxIndex !== -1;
+    const currentNotificationUserBoxGlobalConfig = notificationUser.gc;
+    const currentNotificationUserBoxConfig = notificationUser.bc[currentNotificationUserBoxIndex] ?? {};
+    /**
+     * If bc is updated then the user should be updated too
+     */
+    let updatedBc;
+    let updatedNotificationBoxRecipient;
+    if (removeRecipientFromNotificationBox) {
+        // flag as removed in the NotificationUser details if not already flagged as such
+        if (currentNotificationUserBoxIndexExists && currentNotificationUserBoxConfig.rm !== true) {
+            updatedBc = [...notificationUser.bc];
+            updatedBc[currentNotificationUserBoxIndex] = {
+                ...currentNotificationUserBoxConfig,
+                nb: notificationBoxId, // set the NotificationBox id
+                c: currentNotificationUserBoxConfig.c ?? {},
+                i: util.UNSET_INDEX_NUMBER, // index should be cleared and set to -1
+                ns: false, // sync'd
+                rm: true
+            };
+        }
+    }
+    else if (notificationBoxRecipient != null) {
+        const { ns: currentConfigNeedsSync, lk: lockedFromChanges, bk: blockedFromAdd } = {
+            ns: currentNotificationUserBoxConfig.ns,
+            lk: currentNotificationUserBoxGlobalConfig.lk ?? currentNotificationUserBoxConfig.lk,
+            bk: currentNotificationUserBoxGlobalConfig.bk ?? currentNotificationUserBoxConfig.bk
+        };
+        // if we're re-inserting, then take the prevous config and restore as it was and remove the rm tag
+        let updateWithNotificationBoxRecipient;
+        if (insertingRecipientIntoNotificationBox) {
+            // does not exist in the NotificationBox currently
+            if (blockedFromAdd) {
+                throw notificationUserBlockedFromBeingAddedToRecipientsError(notificationUserId);
+            }
+            else if (lockedFromChanges) {
+                // ignored the notificationBoxRecipient's updates
+                updateWithNotificationBoxRecipient = currentNotificationUserBoxConfig;
+            }
+            else {
+                updateWithNotificationBoxRecipient = firebase.mergeNotificationBoxRecipients(notificationBoxRecipient, currentNotificationUserBoxConfig);
+            }
+        }
+        else {
+            // if locked from changes, throw error
+            if (lockedFromChanges) {
+                throw notificationUserLockedConfigFromBeingUpdatedError(notificationUserId);
+            }
+            else if (currentConfigNeedsSync) {
+                // if needs sync, then merge changes from the config into the notificationBoxRecipient
+                updateWithNotificationBoxRecipient = firebase.mergeNotificationBoxRecipients(notificationBoxRecipient, currentNotificationUserBoxConfig);
+            }
+            else {
+                // use as-is
+                updateWithNotificationBoxRecipient = notificationBoxRecipient;
+            }
+        }
+        const updatedNotificationUserBoxEntry = firebase.mergeNotificationUserNotificationBoxRecipientConfigs({
+            ...currentNotificationUserBoxConfig,
+            i: notificationBoxRecipient.i,
+            c: currentNotificationUserBoxConfig.c ?? {},
+            nb: notificationBoxId, // set the NotificationBox id
+            rm: false // remove/clear the removed flag
+        }, updateWithNotificationBoxRecipient);
+        updatedBc = [...notificationUser.bc];
+        if (currentNotificationUserBoxIndexExists) {
+            updatedBc[currentNotificationUserBoxIndex] = updatedNotificationUserBoxEntry;
+        }
+        else {
+            updatedBc.push(updatedNotificationUserBoxEntry);
+        }
+        // re-apply exclusions to the updated config(s)
+        const withExclusions = firebase.applyExclusionsToNotificationUserNotificationBoxRecipientConfigs({
+            notificationUser,
+            bc: updatedBc,
+            recalculateNs: false
+        });
+        updatedBc = withExclusions.bc;
+        // sync index with input NotificationBoxRecipient
+        updatedNotificationUserBoxEntry.i = notificationBoxRecipient.i;
+        updatedNotificationBoxRecipient = updatedNotificationUserBoxEntry;
+    }
+    return {
+        updatedBc,
+        updatedNotificationBoxRecipient
+    };
+}
+
+/**
+ * Removes the completed checkpoints from the inputCompletions array based on the handleTaskResult.
+ *
+ * @param inputCompletions
+ * @param handleTaskResult
+ * @returns
+ */
+function removeFromCompletionsArrayWithTaskResult(inputCompletions, handleTaskResult) {
+    const { removeAllCompletedCheckpoints, removeFromCompletedCheckpoints } = handleTaskResult;
+    let result;
+    if (removeAllCompletedCheckpoints) {
+        result = [];
+    }
+    else if (removeFromCompletedCheckpoints != null) {
+        const removeFromCompletionsSet = new Set(util.asArray(removeFromCompletedCheckpoints));
+        result = inputCompletions.filter((x) => !removeFromCompletionsSet.has(x));
+    }
+    else {
+        result = inputCompletions;
+    }
+    return result;
+}
+
+/**
+ * Injection token for the BaseNotificationServerActionsContext
+ */
+const BASE_NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN = 'BASE_NOTIFICATION_SERVER_ACTION_CONTEXT';
+/**
+ * Injection token for the NotificationServerActionsContext
+ */
+const NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN = 'NOTIFICATION_SERVER_ACTION_CONTEXT';
+class NotificationServerActions {
+}
+function notificationServerActions(context) {
+    return {
+        createNotificationUser: createNotificationUserFactory(context),
+        updateNotificationUser: updateNotificationUserFactory(context),
+        resyncNotificationUser: resyncNotificationUserFactory(context),
+        resyncAllNotificationUsers: resyncAllNotificationUsersFactory(context),
+        createNotificationSummary: createNotificationSummaryFactory(context),
+        updateNotificationSummary: updateNotificationSummaryFactory(context),
+        createNotificationBox: createNotificationBoxFactory(context),
+        updateNotificationBox: updateNotificationBoxFactory(context),
+        updateNotificationBoxRecipient: updateNotificationBoxRecipientFactory(context),
+        sendNotification: sendNotificationFactory(context),
+        sendQueuedNotifications: sendQueuedNotificationsFactory(context),
+        cleanupSentNotifications: cleanupSentNotificationsFactory(context)
+    };
+}
+// MARK: Actions
+function createNotificationUserFactory(context) {
+    const { firebaseServerActionTransformFunctionFactory, notificationUserCollection, authService } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase.CreateNotificationUserParams, async (params) => {
+        const { uid } = params;
+        return async () => {
+            // assert they exist in the auth system
+            const userContext = authService.userContext(uid);
+            const userExistsInAuth = await userContext.exists();
+            if (!userExistsInAuth) {
+                throw notificationUserInvalidUidForCreateError(uid);
+            }
+            const notificationUserDocument = notificationUserCollection.documentAccessor().loadDocumentForId(uid);
+            const newUserTemplate = {
+                uid,
+                x: [],
+                bc: [],
+                b: [],
+                dc: {
+                    c: {}
+                },
+                gc: {
+                    c: {}
+                }
+            };
+            await notificationUserDocument.create(newUserTemplate);
+            return notificationUserDocument;
+        };
+    });
+}
+function updateNotificationUserFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory, notificationUserCollection, appNotificationTemplateTypeInfoRecordService } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase.UpdateNotificationUserParams, async (params) => {
+        const { gc: inputGc, dc: inputDc, bc: inputBc } = params;
+        return async (notificationUserDocument) => {
+            await firestoreContext.runTransaction(async (transaction) => {
+                const notificationUserDocumentInTransaction = notificationUserCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(notificationUserDocument);
+                const notificationUser = await firebaseServer.assertSnapshotData(notificationUserDocumentInTransaction);
+                const updateTemplate = {};
+                const allKnownNotificationTypes = appNotificationTemplateTypeInfoRecordService.getAllKnownTemplateTypes();
+                if (inputDc != null) {
+                    updateTemplate.dc = firebase.updateNotificationUserDefaultNotificationBoxRecipientConfig(notificationUser.dc, inputDc, allKnownNotificationTypes);
+                }
+                if (inputGc != null) {
+                    const nextGc = firebase.updateNotificationUserDefaultNotificationBoxRecipientConfig(notificationUser.gc, inputGc, allKnownNotificationTypes);
+                    if (!util.areEqualPOJOValues(notificationUser.gc, nextGc)) {
+                        updateTemplate.gc = nextGc;
+                        // iterate and update any box config that has the effective recipient change
+                        updateTemplate.bc = notificationUser.bc.map((currentConfig) => {
+                            // check item isn't already marked for sync or marked as removed
+                            if (currentConfig.ns === true || currentConfig.rm === true) {
+                                return currentConfig;
+                            }
+                            const currentEffectiveRecipient = firebase.effectiveNotificationBoxRecipientConfig({
+                                uid: notificationUser.uid,
+                                appNotificationTemplateTypeInfoRecordService,
+                                gc: notificationUser.gc,
+                                boxConfig: currentConfig
+                            });
+                            const nextEffectiveRecipient = firebase.effectiveNotificationBoxRecipientConfig({
+                                uid: notificationUser.uid,
+                                appNotificationTemplateTypeInfoRecordService,
+                                gc: nextGc,
+                                boxConfig: currentConfig
+                            });
+                            const effectiveConfigChanged = !util.areEqualPOJOValues(currentEffectiveRecipient, nextEffectiveRecipient);
+                            return effectiveConfigChanged ? { ...currentConfig, ns: true } : currentConfig;
+                        });
+                    }
+                }
+                if (inputBc != null) {
+                    const updateTemplateBc = firebase.updateNotificationUserNotificationBoxRecipientConfigs(updateTemplate.bc ?? notificationUser.bc, inputBc, appNotificationTemplateTypeInfoRecordService);
+                    if (updateTemplateBc != null) {
+                        // re-apply exclusions to the updated configs
+                        const withExclusions = firebase.applyExclusionsToNotificationUserNotificationBoxRecipientConfigs({
+                            notificationUser,
+                            bc: updateTemplateBc,
+                            recalculateNs: false
+                        });
+                        updateTemplate.bc = withExclusions.bc;
+                        updateTemplate.b = updateTemplateBc.map((x) => x.nb);
+                    }
+                }
+                // if bc is being updated, then also update ns
+                if (updateTemplate.bc != null) {
+                    updateTemplate.ns = firebase.calculateNsForNotificationUserNotificationBoxRecipientConfigs(updateTemplate.bc);
+                }
+                await notificationUserDocumentInTransaction.update(updateTemplate);
+            });
+            return notificationUserDocument;
+        };
+    });
+}
+const MAX_NOTIFICATION_BOXES_TO_UPDATE_PER_BATCH = 50;
+function resyncNotificationUserFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory, notificationBoxCollection, notificationUserCollection, appNotificationTemplateTypeInfoRecordService } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase.ResyncNotificationUserParams, async () => {
+        return async (notificationUserDocument) => {
+            // run updates in batches
+            let notificationBoxesUpdated = 0;
+            let hasMoreNotificationBoxesToSync = true;
+            while (hasMoreNotificationBoxesToSync) {
+                const batchResult = await firestoreContext.runTransaction(async (transaction) => {
+                    const notificationUserDocumentInTransaction = notificationUserCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(notificationUserDocument);
+                    const notificationUser = await firebaseServer.assertSnapshotData(notificationUserDocumentInTransaction);
+                    const { gc } = notificationUser;
+                    const notificationBoxConfigsToSync = notificationUser.bc.filter((x) => x.ns);
+                    const notificationBoxConfigsToSyncInThisBatch = util.takeFront(notificationBoxConfigsToSync, MAX_NOTIFICATION_BOXES_TO_UPDATE_PER_BATCH);
+                    /**
+                     * These are the actual number of NotificationBox values that had recipients updated.
+                     */
+                    let notificationBoxesUpdatedInBatch = 0;
+                    let hasUnsyncedNotificationBoxConfigs = false;
+                    if (notificationBoxConfigsToSyncInThisBatch.length > 0) {
+                        const notificationBoxConfigsToSyncInThisBatchMap = util.makeModelMap(notificationBoxConfigsToSyncInThisBatch, (x) => x.nb);
+                        const notificationBoxIdsToSyncInThisBatch = Array.from(notificationBoxConfigsToSyncInThisBatchMap.keys());
+                        const notificationBoxDocuments = firebase.loadDocumentsForIds(notificationBoxCollection.documentAccessorForTransaction(transaction), notificationBoxIdsToSyncInThisBatch);
+                        const notificationBoxDocumentSnapshotDataPairs = await firebase.getDocumentSnapshotDataPairs(notificationBoxDocuments);
+                        const notificationBoxConfigsToRemoveFromNotificationUser = new Set();
+                        const notificationUserNotificationBoxConfigsToMarkAsRemoved = new Set();
+                        const nextRecipientsMap = new Map();
+                        // update each NotificationBoxDocument
+                        await util.performAsyncTasks(notificationBoxDocumentSnapshotDataPairs, async (notificationBoxDocumentSnapshotDataPair) => {
+                            const { data: notificationBox, document } = notificationBoxDocumentSnapshotDataPair;
+                            const nb = document.id;
+                            const notificationUserNotificationBoxConfig = notificationBoxConfigsToSyncInThisBatchMap.get(nb); // always exists
+                            if (!notificationBox) {
+                                // if the entire NotificationBox no longer exists, flag to remove it from the user as a cleanup measure
+                                notificationBoxConfigsToRemoveFromNotificationUser.add(nb);
+                            }
+                            else {
+                                // update in the NotificationBox
+                                const recipientIndex = notificationBox.r.findIndex((x) => x.uid === notificationUser.uid);
+                                let r;
+                                if (recipientIndex === -1) {
+                                    // if they are not in the NotificationBox, then mark them as removed on the user
+                                    notificationUserNotificationBoxConfigsToMarkAsRemoved.add(nb);
+                                }
+                                else if (notificationUserNotificationBoxConfig.rm) {
+                                    // remove from the notification box if it is flagged
+                                    r = util.removeValuesAtIndexesFromArrayCopy(notificationBox.r, recipientIndex);
+                                }
+                                else {
+                                    const { m } = notificationBox;
+                                    const recipient = notificationBox.r[recipientIndex];
+                                    const nextRecipient = firebase.effectiveNotificationBoxRecipientConfig({
+                                        uid: notificationUser.uid,
+                                        m,
+                                        appNotificationTemplateTypeInfoRecordService,
+                                        gc,
+                                        boxConfig: notificationUserNotificationBoxConfig,
+                                        recipient
+                                    });
+                                    const recipientHasChange = !util.areEqualPOJOValues(nextRecipient, recipient);
+                                    // only update recipients if the next/new recipient is not equal to the existing one
+                                    if (recipientHasChange) {
+                                        r = [...notificationBox.r];
+                                        r[recipientIndex] = nextRecipient;
+                                        nextRecipientsMap.set(nb, nextRecipient);
+                                    }
+                                    else {
+                                        nextRecipientsMap.set(nb, recipient);
+                                    }
+                                }
+                                // update recipients if needed
+                                if (r != null) {
+                                    await document.update({ r });
+                                    notificationBoxesUpdatedInBatch += 1;
+                                }
+                            }
+                        });
+                        // Update the NotificationUser
+                        const notificationBoxIdsSynced = new Set(notificationBoxIdsToSyncInThisBatch);
+                        // start nextConfigs off as a new array with none of the sync'd ids
+                        const nextConfigs = notificationBoxConfigsToSyncInThisBatch.filter((x) => !notificationBoxIdsSynced.has(x.nb));
+                        notificationBoxIdsToSyncInThisBatch.forEach((nb) => {
+                            let nextConfig;
+                            if (notificationBoxConfigsToRemoveFromNotificationUser.has(nb)) ;
+                            else {
+                                const existingConfig = notificationBoxConfigsToSyncInThisBatchMap.get(nb);
+                                if (notificationUserNotificationBoxConfigsToMarkAsRemoved.has(nb) || existingConfig.rm) {
+                                    // if the recipient was being removed or is marked as removed, then update the config to confirm removal
+                                    nextConfig = {
+                                        ...existingConfig,
+                                        nb,
+                                        rm: true,
+                                        i: util.UNSET_INDEX_NUMBER
+                                    };
+                                }
+                                else {
+                                    // else, use the updated recipient and keep/copy the
+                                    const updatedRecipient = nextRecipientsMap.get(nb);
+                                    nextConfig = {
+                                        ...existingConfig,
+                                        nb,
+                                        rm: false, // mark as not removed
+                                        i: updatedRecipient.i ?? util.UNSET_INDEX_NUMBER
+                                    };
+                                }
+                            }
+                            if (nextConfig != null) {
+                                nextConfig.ns = false; // mark as synced
+                                nextConfigs.push(nextConfig);
+                            }
+                        });
+                        const ns = nextConfigs.some((x) => x.ns);
+                        await notificationUserDocumentInTransaction.update({ bc: nextConfigs, ns });
+                        hasUnsyncedNotificationBoxConfigs = ns;
+                    }
+                    const batchResult = {
+                        hasMoreNotificationBoxesToSync: hasUnsyncedNotificationBoxConfigs,
+                        notificationBoxesUpdatedInBatch
+                    };
+                    return batchResult;
+                });
+                hasMoreNotificationBoxesToSync = batchResult.hasMoreNotificationBoxesToSync;
+                notificationBoxesUpdated += batchResult.notificationBoxesUpdatedInBatch;
+            }
+            const result = {
+                notificationBoxesUpdated
+            };
+            return result;
+        };
+    });
+}
+function resyncAllNotificationUsersFactory(context) {
+    const { notificationUserCollection } = context;
+    const resyncNotificationUser = resyncNotificationUserFactory(context);
+    return async () => {
+        let notificationBoxesUpdated = 0;
+        const resyncNotificationUserParams = { key: firebase.firestoreDummyKey() };
+        const resyncNotificationUserInstance = await resyncNotificationUser(resyncNotificationUserParams);
+        const iterateResult = await firebase.iterateFirestoreDocumentSnapshotPairs({
+            documentAccessor: notificationUserCollection.documentAccessor(),
+            iterateSnapshotPair: async (snapshotPair) => {
+                const { document: notificationUserDocument } = snapshotPair;
+                const result = await resyncNotificationUserInstance(notificationUserDocument);
+                notificationBoxesUpdated += result.notificationBoxesUpdated;
+            },
+            constraintsFactory: () => firebase.notificationUsersFlaggedForNeedsSyncQuery(),
+            snapshotsPerformTasksConfig: {
+                // prevent NotificationUsers with the same NotificationBoxes from being updated/sync'd at the same time
+                nonConcurrentTaskKeyFactory: (x) => {
+                    const notificationBoxIdsToSync = x
+                        .data()
+                        .bc.filter((x) => x.ns)
+                        .map((x) => x.nb);
+                    return notificationBoxIdsToSync;
+                }
+            },
+            queryFactory: notificationUserCollection,
+            batchSize: undefined,
+            performTasksConfig: {
+                maxParallelTasks: 10
+            }
+        });
+        const result = {
+            notificationUsersResynced: iterateResult.totalSnapshotsVisited,
+            notificationBoxesUpdated
+        };
+        return result;
+    };
+}
+function createNotificationSummaryFactory(context) {
+    const { firebaseServerActionTransformFunctionFactory, notificationSummaryCollection } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase.CreateNotificationSummaryParams, async (params) => {
+        const { model } = params;
+        return async () => {
+            const notificationSummaryId = firebase.notificationSummaryIdForModel(model);
+            const notificationSummaryDocument = notificationSummaryCollection.documentAccessor().loadDocumentForId(notificationSummaryId);
+            const newSummaryTemplate = makeNewNotificationSummaryTemplate(model);
+            await notificationSummaryDocument.create(newSummaryTemplate);
+            return notificationSummaryDocument;
+        };
+    });
+}
+function updateNotificationSummaryFactory(context) {
+    const { firebaseServerActionTransformFunctionFactory } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase.UpdateNotificationSummaryParams, async (params) => {
+        const { setReadAtTime, flagAllRead } = params;
+        return async (notificationSummaryDocument) => {
+            let updateTemplate;
+            if (setReadAtTime != null) {
+                updateTemplate = { rat: setReadAtTime };
+            }
+            else if (flagAllRead === true) {
+                updateTemplate = { rat: new Date() };
+            }
+            if (updateTemplate != null) {
+                await notificationSummaryDocument.update(updateTemplate);
+            }
+            return notificationSummaryDocument;
+        };
+    });
+}
+function createNotificationBoxInTransactionFactory(context) {
+    const { notificationBoxCollection } = context;
+    return async (params, transaction) => {
+        const { now: inputNow, skipCreate } = params;
+        const now = inputNow ?? new Date();
+        const notificationBoxDocument = firebase.loadNotificationBoxDocumentForReferencePair(params, notificationBoxCollection.documentAccessorForTransaction(transaction));
+        const notificationBoxTemplate = {
+            m: notificationBoxDocument.notificationBoxRelatedModelKey,
+            o: firebase.firestoreDummyKey(), // set during initialization
+            r: [],
+            cat: now,
+            w: date.yearWeekCode(now),
+            s: true // requires initialization
+        };
+        if (!skipCreate) {
+            await notificationBoxDocument.create(notificationBoxTemplate);
+        }
+        return {
+            notificationBoxTemplate,
+            notificationBoxDocument
+        };
+    };
+}
+function createNotificationBoxFactory(context) {
+    const { firestoreContext, notificationBoxCollection, firebaseServerActionTransformFunctionFactory } = context;
+    const createNotificationBoxInTransaction = createNotificationBoxInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.CreateNotificationBoxParams, async (params) => {
+        const { model } = params;
+        return async () => {
+            const result = await firestoreContext.runTransaction(async (transaction) => {
+                const { notificationBoxDocument } = await createNotificationBoxInTransaction({ notificationBoxRelatedModelKey: model }, transaction);
+                return notificationBoxDocument;
+            });
+            return notificationBoxCollection.documentAccessor().loadDocumentFrom(result);
+        };
+    });
+}
+function updateNotificationBoxFactory({ firebaseServerActionTransformFunctionFactory }) {
+    return firebaseServerActionTransformFunctionFactory(firebase.UpdateNotificationBoxParams, async () => {
+        return async (notificationBoxDocument) => {
+            // does nothing currently.
+            return notificationBoxDocument;
+        };
+    });
+}
+function updateNotificationBoxRecipientExclusionInTransactionFactory(context) {
+    const { notificationBoxCollection, notificationUserCollection } = context;
+    return async (input, transaction) => {
+        const { params } = input;
+        const { uid: inputUid, i, setExclusion } = params;
+        const notificationBoxDocument = firebase.loadNotificationBoxDocumentForReferencePair(input, notificationBoxCollection.documentAccessorForTransaction(transaction));
+        let targetUid = inputUid;
+        let result = undefined;
+        if (setExclusion == null) {
+            throw new Error('setExclusion was undefined. Maybe you wanted to call updateNotificationBoxRecipientInTransactionFactory() instead?');
+        }
+        else if (!inputUid && i != null) {
+            // only load the notification box if targeting a recipient by index
+            const notificationBox = await notificationBoxDocument.snapshotData();
+            if (!notificationBox) {
+                throw notificationBoxExclusionTargetInvalidError();
+            }
+            const targetRecipient = notificationBox.r.find((x) => x.i === i);
+            if (!targetRecipient || !targetRecipient.uid) {
+                throw notificationBoxExclusionTargetInvalidError();
+            }
+            else {
+                targetUid = targetRecipient.uid;
+            }
+        }
+        if (!targetUid) {
+            throw notificationBoxExclusionTargetInvalidError();
+        }
+        const notificationUserDocument = await notificationUserCollection.documentAccessorForTransaction(transaction).loadDocumentForId(targetUid);
+        const notificationUser = await notificationUserDocument.snapshotData();
+        if (notificationUser) {
+            // only update if the user exists
+            const targetExclusions = [notificationBoxDocument.id];
+            const { update: notificationUserUpdate } = firebase.updateNotificationUserNotificationSendExclusions({
+                notificationUser,
+                addExclusions: setExclusion ? targetExclusions : undefined,
+                removeExclusions: setExclusion ? undefined : targetExclusions
+            });
+            await notificationUserDocument.update(notificationUserUpdate);
+            result = {
+                notificationUserUpdate
+            };
+        }
+        return result;
+    };
+}
+function updateNotificationBoxRecipientInTransactionFactory(context) {
+    const { authService, notificationBoxCollection, notificationUserCollection } = context;
+    const createNotificationBoxInTransaction = createNotificationBoxInTransactionFactory(context);
+    return async (input, transaction) => {
+        const { params, allowCreateNotificationBoxIfItDoesNotExist, throwErrorIfNotificationBoxDoesNotExist } = input;
+        const { uid, i, insert, remove, configs: inputC, setExclusion } = params;
+        const findRecipientFn = (x) => (uid != null && x.uid === uid) || (i != null && x.i === i);
+        if (setExclusion != null) {
+            throw new Error('exclusion update must be processed by updateNotificationBoxRecipientExclusionInTransactionFactory() function.');
+        }
+        const notificationBoxDocument = firebase.loadNotificationBoxDocumentForReferencePair(input, notificationBoxCollection.documentAccessorForTransaction(transaction));
+        let notificationBox = await notificationBoxDocument.snapshotData();
+        let createNotificationBox = false;
+        let result = undefined;
+        if (!notificationBox) {
+            if (allowCreateNotificationBoxIfItDoesNotExist) {
+                const { notificationBoxTemplate } = await createNotificationBoxInTransaction({
+                    notificationBoxDocument,
+                    skipCreate: true // don't create since we still need to read things for the transaction
+                }, transaction);
+                notificationBox = notificationBoxTemplate;
+                createNotificationBox = true;
+            }
+            else if (throwErrorIfNotificationBoxDoesNotExist) {
+                throw notificationBoxDoesNotExist();
+            }
+        }
+        if (notificationBox) {
+            const { m } = notificationBox;
+            let r;
+            let targetRecipientIndex = notificationBox.r.findIndex(findRecipientFn);
+            const targetRecipient = notificationBox.r[targetRecipientIndex];
+            let nextRecipient;
+            if (remove) {
+                if (targetRecipientIndex != null) {
+                    r = [...notificationBox.r]; // remove if they exist.
+                    delete r[targetRecipientIndex];
+                }
+            }
+            else {
+                if (!targetRecipient && !insert) {
+                    throw notificationBoxRecipientDoesNotExistsError();
+                }
+                const c = (inputC != null ? firebase.notificationBoxRecipientTemplateConfigArrayToRecord(inputC) : targetRecipient?.c) ?? {};
+                nextRecipient = {
+                    uid,
+                    i: targetRecipient?.i ?? util.UNSET_INDEX_NUMBER,
+                    c,
+                    ...firebase.updateNotificationRecipient(targetRecipient ?? {}, params)
+                };
+                r = [...notificationBox.r];
+                if (targetRecipient) {
+                    nextRecipient.i = targetRecipient.i;
+                    nextRecipient = firebase.mergeNotificationBoxRecipients(targetRecipient, nextRecipient);
+                    r[targetRecipientIndex] = nextRecipient; // override in the array
+                }
+                else {
+                    const nextI = util.computeNextFreeIndexOnSortedValuesFunction(util.readIndexNumber)(notificationBox.r); // r is sorted by index in ascending order, so the last value is the largest i
+                    nextRecipient.i = nextI;
+                    // should have the greatest i value, push to end
+                    r.push(nextRecipient);
+                    targetRecipientIndex = r.length - 1;
+                }
+            }
+            // save changes to r if it has changed
+            if (r != null) {
+                const notificationUserId = targetRecipient?.uid ?? nextRecipient?.uid;
+                // sync with the notification user's document, if it exists
+                if (notificationUserId != null) {
+                    const notificationBoxId = notificationBoxDocument.id;
+                    const notificationUserDocument = await notificationUserCollection.documentAccessorForTransaction(transaction).loadDocumentForId(notificationUserId);
+                    let notificationUser = await notificationUserDocument.snapshotData();
+                    const createNotificationUser = !notificationUser && !remove && insert;
+                    if (createNotificationUser) {
+                        // assert they exist in the auth system
+                        const userContext = authService.userContext(notificationUserId);
+                        const userExistsInAuth = await userContext.exists();
+                        if (!userExistsInAuth) {
+                            throw notificationUserInvalidUidForCreateError(notificationUserId);
+                        }
+                        const notificationUserTemplate = {
+                            uid: notificationUserId,
+                            b: [],
+                            x: [],
+                            bc: [],
+                            ns: false,
+                            dc: {
+                                c: {}
+                            },
+                            gc: {
+                                c: {}
+                            }
+                        };
+                        notificationUser = notificationUserTemplate;
+                    }
+                    // if the user is being inserted or exists, then make updates
+                    if (notificationUser != null) {
+                        const { updatedBc, updatedNotificationBoxRecipient } = updateNotificationUserNotificationBoxRecipientConfig({
+                            notificationBoxId,
+                            notificationUserId,
+                            notificationUser,
+                            insertingRecipientIntoNotificationBox: insert,
+                            removeRecipientFromNotificationBox: remove,
+                            notificationBoxRecipient: nextRecipient
+                        });
+                        const updatedB = updatedBc ? updatedBc.map((x) => x.nb) : undefined;
+                        if (createNotificationUser) {
+                            const newUserTemplate = {
+                                ...notificationUser,
+                                bc: updatedBc ?? [],
+                                b: updatedB ?? []
+                            };
+                            await notificationUserDocument.create(newUserTemplate);
+                        }
+                        else if (updatedBc != null) {
+                            await notificationUserDocument.update({ bc: updatedBc, b: updatedB });
+                        }
+                        // Set if nextRecipient is updated/influence from existing configuration
+                        if (targetRecipientIndex != null && updatedNotificationBoxRecipient && !remove) {
+                            r[targetRecipientIndex] = updatedNotificationBoxRecipient; // set the updated value in r
+                        }
+                    }
+                    // else, if removing and they don't exist, nothing to update
+                }
+                const updatedNotificationBox = { ...notificationBox, r };
+                let notificationBoxWasCreated = false;
+                if (createNotificationBox) {
+                    await notificationBoxDocument.create(updatedNotificationBox);
+                    notificationBoxWasCreated = true;
+                }
+                else {
+                    await notificationBoxDocument.update({ r });
+                }
+                result = {
+                    updatedNotificationBox,
+                    notificationBoxWasCreated,
+                    notificationBoxDocument
+                };
+            }
+        }
+        return result;
+    };
+}
+function updateNotificationBoxRecipientFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory } = context;
+    const updateNotificationBoxRecipientInTransaction = updateNotificationBoxRecipientInTransactionFactory(context);
+    const updateNotificationBoxRecipientExclusionInTransaction = updateNotificationBoxRecipientExclusionInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.UpdateNotificationBoxRecipientParams, async (params) => {
+        return async (notificationBoxDocument) => {
+            await firestoreContext.runTransaction(async (transaction) => {
+                if (params.setExclusion != null) {
+                    await updateNotificationBoxRecipientExclusionInTransaction({
+                        params,
+                        notificationBoxDocument
+                    }, transaction);
+                }
+                else {
+                    await updateNotificationBoxRecipientInTransaction({
+                        params,
+                        throwErrorIfNotificationBoxDoesNotExist: true,
+                        notificationBoxDocument
+                    }, transaction);
+                }
+            });
+            return notificationBoxDocument;
+        };
+    });
+}
+const UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY = 8;
+const UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS = 1;
+const UNKNOWN_NOTIFICATION_TASK_TYPE_HOURS_DELAY = 8;
+const UNKNOWN_NOTIFICATION_TASK_TYPE_DELETE_AFTER_RETRY_ATTEMPTS = 1;
+const KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY = UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY;
+const KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS = 5;
+const NOTIFICATION_MAX_SEND_ATTEMPTS = 5;
+const NOTIFICATION_BOX_NOT_INITIALIZED_DELAY_MINUTES = 8;
+/**
+ * Minimum time in minutes that a notification task can be attempted again
+ */
+const NOTIFICATION_TASK_MINIMUM_SET_AT_THROTTLE_TIME_MINUTES = 1;
+const NOTIFICATION_TASK_TYPE_MAX_SEND_ATTEMPTS = 5;
+const NOTIFICATION_TASK_TYPE_FAILURE_DELAY_HOURS = 3;
+const NOTIFICATION_TASK_TYPE_FAILURE_DELAY_MS = dateFns.hoursToMilliseconds(NOTIFICATION_TASK_TYPE_FAILURE_DELAY_HOURS);
+function sendNotificationFactory(context) {
+    const { appNotificationTemplateTypeInfoRecordService, notificationSendService, notificationTaskService, notificationTemplateService, authService, notificationBoxCollection, notificationCollectionGroup, notificationUserCollection, firestoreContext, firebaseServerActionTransformFunctionFactory } = context;
+    const createNotificationBoxInTransaction = createNotificationBoxInTransactionFactory(context);
+    const notificationUserAccessor = notificationUserCollection.documentAccessor();
+    return firebaseServerActionTransformFunctionFactory(firebase.SendNotificationParams, async (params) => {
+        const { ignoreSendAtThrottle } = params;
+        return async (inputNotificationDocument) => {
+            const now = new Date();
+            // Load the notification document outside of any potential context (transaction, etc.)
+            const notificationDocument = notificationCollectionGroup.documentAccessor().loadDocumentFrom(inputNotificationDocument);
+            const { nextSat, throttled, tryRun, isNotificationTask, notificationTaskHandler, notification, createdBox, notificationBoxNeedsInitialization, notificationBox, notificationBoxModelKey, deletedNotification, templateInstance, isConfiguredTemplateType, isKnownTemplateType, onlySendToExplicitlyEnabledRecipients, onlyTextExplicitlyEnabledRecipients } = await firestoreContext.runTransaction(async (transaction) => {
+                const notificationBoxDocument = notificationBoxCollection.documentAccessorForTransaction(transaction).loadDocument(notificationDocument.parent);
+                const notificationDocumentInTransaction = notificationCollectionGroup.documentAccessorForTransaction(transaction).loadDocumentFrom(notificationDocument);
+                let [notificationBox, notification] = await Promise.all([firebase.getDocumentSnapshotData(notificationBoxDocument), firebase.getDocumentSnapshotData(notificationDocumentInTransaction)]);
+                const model = firebase.inferKeyFromTwoWayFlatFirestoreModelKey(notificationBoxDocument.id);
+                const isNotificationTask = notification?.st === firebase.NotificationSendType.TASK_NOTIFICATION;
+                let tryRun = true;
+                let throttled = false;
+                let nextSat;
+                if (!notification) {
+                    tryRun = false;
+                }
+                else if (!ignoreSendAtThrottle) {
+                    tryRun = !dateFns.isFuture(notification.sat);
+                    if (!tryRun) {
+                        throttled = true;
+                    }
+                }
+                // always set nextSat if tryRun is true
+                if (tryRun) {
+                    if (isNotificationTask) {
+                        // can try to run the task again in 1 minute
+                        nextSat = dateFns.addMinutes(now, NOTIFICATION_TASK_MINIMUM_SET_AT_THROTTLE_TIME_MINUTES);
+                    }
+                    else {
+                        // update the next send type of non-tasks to try being sent again in 10 minutes, if they fail
+                        nextSat = dateFns.addMinutes(now, 10);
+                    }
+                }
+                let createdBox = false;
+                let deletedNotification = false;
+                let notificationBoxNeedsInitialization = false;
+                let isKnownTemplateType;
+                let isConfiguredTemplateType;
+                let onlySendToExplicitlyEnabledRecipients;
+                let onlyTextExplicitlyEnabledRecipients;
+                let templateInstance;
+                let notificationTaskHandler;
+                async function deleteNotification() {
+                    tryRun = false;
+                    await notificationDocumentInTransaction.accessor.delete();
+                    deletedNotification = true;
+                }
+                // create/init the notification box if necessary/configured.
+                if (notification && tryRun) {
+                    // if we're still trying to run, check the template is ok. If not, cancel the run.
+                    const { t // notification task/template type
+                     } = notification.n;
+                    if (isNotificationTask) {
+                        notificationTaskHandler = notificationTaskService.taskHandlerForNotificationTaskType(t);
+                        if (notificationTaskHandler) {
+                            if (notification.a >= NOTIFICATION_TASK_TYPE_MAX_SEND_ATTEMPTS) {
+                                tryRun = false;
+                                console.warn(`Configured notification task of type "${t}" has reached the delete threshhold after being attempted ${notification.a} times. Deleting notification task.`);
+                                await deleteNotification();
+                            }
+                        }
+                        else {
+                            tryRun = false;
+                            const delay = UNKNOWN_NOTIFICATION_TASK_TYPE_HOURS_DELAY;
+                            if (notification.a < UNKNOWN_NOTIFICATION_TASK_TYPE_DELETE_AFTER_RETRY_ATTEMPTS) {
+                                console.warn(`Notification task type of "${t}" was found in a Notification but has no handler. Action is being delayed by ${delay} hours.`);
+                                nextSat = dateFns.addHours(now, delay);
+                            }
+                            else {
+                                console.warn(`Notification task type of "${t}" was found in a Notification but has no handler. Action is being deleted.`);
+                                // delete the notification
+                                await deleteNotification();
+                            }
+                        }
+                    }
+                    else {
+                        templateInstance = notificationTemplateService.templateInstanceForType(t);
+                        isConfiguredTemplateType = templateInstance.isConfiguredType;
+                        const templateTypeInfo = appNotificationTemplateTypeInfoRecordService.appNotificationTemplateTypeInfoRecord[t];
+                        isKnownTemplateType = templateTypeInfo != null;
+                        onlySendToExplicitlyEnabledRecipients = notification.ois ?? templateTypeInfo?.onlySendToExplicitlyEnabledRecipients;
+                        onlyTextExplicitlyEnabledRecipients = notification.ots ?? templateTypeInfo?.onlyTextExplicitlyEnabledRecipients;
+                        if (!isConfiguredTemplateType) {
+                            // log the issue that an notification with an unconfigured type was queued
+                            const retryAttempts = isKnownTemplateType ? KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS : UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS;
+                            const delay = isKnownTemplateType ? KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY : UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY;
+                            if (notification.a < retryAttempts) {
+                                if (isKnownTemplateType) {
+                                    console.warn(`Unconfigured but known template type of "${t}" (${templateTypeInfo.name}) was found in a Notification. Send is being delayed by ${delay} hours.`);
+                                }
+                                else {
+                                    console.warn(`Unknown template type of "${t}" was found in a Notification. Send is being delayed by ${delay} hours.`);
+                                }
+                                // delay send for 12 hours, for a max of 24 hours incase it is an issue.
+                                nextSat = dateFns.addHours(now, delay);
+                                tryRun = false;
+                            }
+                            else {
+                                console.warn(`Unconfigured template type of "${t}" was found in a Notification. The Notification has reached the delete threshhold after failing to send due to misconfiguration multiple times and is being deleted.`);
+                                // after attempting to send 3 times, delete it.
+                                await deleteNotification();
+                            }
+                        }
+                        // handle the notification box's absence
+                        if (!notificationBox && tryRun) {
+                            switch (notification.st) {
+                                case firebase.NotificationSendType.INIT_BOX_AND_SEND:
+                                    const { notificationBoxTemplate } = await createNotificationBoxInTransaction({ notificationBoxDocument }, transaction);
+                                    notificationBox = firebase.setIdAndKeyFromKeyIdRefOnDocumentData(notificationBoxTemplate, notificationBoxDocument);
+                                    createdBox = true;
+                                    break;
+                                case firebase.NotificationSendType.SEND_IF_BOX_EXISTS:
+                                    // delete the notification since it won't get sent.
+                                    await deleteNotification();
+                                    break;
+                                case firebase.NotificationSendType.SEND_WITHOUT_CREATING_BOX:
+                                    // continue with current tryRun
+                                    break;
+                            }
+                        }
+                        // if the notification box is not initialized/synchronized yet, do not run.
+                        if (tryRun && notificationBox && notificationBox.s) {
+                            notificationBoxNeedsInitialization = true;
+                            tryRun = false;
+                            nextSat = dateFns.addMinutes(now, NOTIFICATION_BOX_NOT_INITIALIZED_DELAY_MINUTES);
+                        }
+                    }
+                }
+                // update the notification send at time and attempt count
+                if (notification != null && nextSat != null && !deletedNotification) {
+                    const isAtMaxAttempts = notification.a >= NOTIFICATION_MAX_SEND_ATTEMPTS;
+                    if (isAtMaxAttempts && notificationBoxNeedsInitialization) {
+                        await deleteNotification(); // just delete the notification if the box still hasn't been initialized successfully at this point.
+                    }
+                    // check if it was just deleted
+                    if (!deletedNotification) {
+                        const a = isNotificationTask && tryRun ? notification.a : notification.a + 1; // do not update a notification task's attempt count here, unless tryRun fails
+                        // NOTE: It is important to update sat so the notification task queue running doesn't get stuck in a query loop by notifications/tasks that have a sat value that is in the past, but was just run.
+                        await notificationDocumentInTransaction.update({ sat: nextSat, a });
+                    }
+                }
+                return {
+                    nextSat,
+                    throttled,
+                    isNotificationTask,
+                    deletedNotification,
+                    createdBox,
+                    notificationBoxModelKey: model,
+                    notificationBoxNeedsInitialization,
+                    notificationBox,
+                    notification,
+                    templateInstance,
+                    isKnownTemplateType,
+                    notificationTaskHandler,
+                    isConfiguredTemplateType,
+                    tryRun,
+                    onlySendToExplicitlyEnabledRecipients,
+                    onlyTextExplicitlyEnabledRecipients
+                };
+            });
+            let success = false;
+            let isUniqueNotificationTask = false;
+            let uniqueNotificationTaskConflict = false;
+            let sendEmailsResult;
+            let sendTextsResult;
+            let sendNotificationSummaryResult;
+            let loadMessageFunctionFailure = false;
+            let buildMessageFailure = false;
+            let notificationMarkedDone = false;
+            let notificationTaskCompletionType;
+            let notificationTaskPartsRunCount = 0;
+            let notificationTaskLoopingProtectionTriggered;
+            let onSendAttemptedResult;
+            let onSendSuccessResult;
+            const notificationTemplateType = templateInstance?.type;
+            if (isNotificationTask) {
+                await handleNotificationTask();
+            }
+            else {
+                await handleNormalNotification();
+            }
+            async function _runNotificationTaskNextPart(input) {
+                const { notification, notificationTaskHandler, previouslyCompleteSubTasks } = input;
+                const { n: item, cat, ut } = notification;
+                let tryRunNextPart = false;
+                let partNotificationTaskCompletionType;
+                let partNotificationMarkedDone = false;
+                let partTprReversal = false;
+                let partSuccess = false;
+                let nextCompleteSubTasks;
+                const unique = ut ?? false;
+                const notificationTask = {
+                    notificationDocument,
+                    totalSendAttempts: notification.a,
+                    currentCheckpointSendAttempts: notification.at ?? 0,
+                    taskType: item.t,
+                    item,
+                    data: item.d,
+                    checkpoints: notification.tpr,
+                    createdAt: cat,
+                    unique
+                };
+                // calculate results
+                const notificationTemplate = {};
+                // perform the task
+                try {
+                    const handleTaskResult = await notificationTaskHandler.handleNotificationTask(notificationTask);
+                    const { completion, updateMetadata, delayUntil, canRunNextCheckpoint, allCompletedSubTasks } = handleTaskResult;
+                    partNotificationTaskCompletionType = completion;
+                    partSuccess = true;
+                    switch (completion) {
+                        case true:
+                            notificationTemplate.d = true; // mark as done
+                            break;
+                        case false:
+                            // failed
+                            notificationTemplate.a = notification.a + 1; // increase attempts count
+                            notificationTemplate.at = (notification.at ?? 0) + 1; // increase checkpoint attempts count
+                            // remove any completions, if applicable
+                            notificationTemplate.tpr = removeFromCompletionsArrayWithTaskResult(notification.tpr, handleTaskResult);
+                            partSuccess = false;
+                            break;
+                        default:
+                            // default case called if not true or false, which implies either a delay or partial completion
+                            // update the checkpoint attempts count
+                            if (Array.isArray(completion) && completion.length === 0) {
+                                notificationTemplate.at = (notification.at ?? 0) + 1; // increase checkpoint attempt/delays count
+                                tryRunNextPart = canRunNextCheckpoint === true && allCompletedSubTasks != null && delayUntil == null; // can only run the next part if subtasks were returned and there is no delay
+                            }
+                            else {
+                                tryRunNextPart = canRunNextCheckpoint === true && delayUntil == null; // can try the next part if there is no delayUntil and canRunNextCheckpoint is true
+                                notificationTemplate.at = 0; // reset checkpoint attempt/delay count
+                            }
+                            // add the checkpoint to the notification
+                            notificationTemplate.tpr = [
+                                ...removeFromCompletionsArrayWithTaskResult(notification.tpr, handleTaskResult), // remove any completions, if applicable
+                                ...util.asArray(completion)
+                            ];
+                            // calculate the updated notification item
+                            notificationTemplate.n = {
+                                ...notification.n,
+                                d: {
+                                    ...notification.n.d,
+                                    ...(updateMetadata ? util.filterOnlyUndefinedValues(updateMetadata) : undefined) // ignore any undefined values
+                                }
+                            };
+                            // can only run the next part if the tpr has changed, and the number of checkpoints completed has increased
+                            // if the tpr has not changed, then it is also considered a reversal
+                            if (tryRunNextPart) {
+                                const tprChanged = !util.iterablesAreSetEquivalent(notification.tpr, notificationTemplate.tpr);
+                                partTprReversal = !tprChanged || (tprChanged && notificationTemplate.tpr.length <= notification.tpr.length);
+                                if (allCompletedSubTasks != null) {
+                                    switch (allCompletedSubTasks) {
+                                        case true:
+                                        case false:
+                                            // only run if there is no tpr reversal flagged
+                                            tryRunNextPart = !partTprReversal;
+                                            break;
+                                        default:
+                                            // check subtask tpr changes
+                                            nextCompleteSubTasks = util.asArray(allCompletedSubTasks);
+                                            const subtaskTprChanged = !util.iterablesAreSetEquivalent(previouslyCompleteSubTasks, nextCompleteSubTasks);
+                                            partTprReversal = !subtaskTprChanged || (subtaskTprChanged && nextCompleteSubTasks.length <= previouslyCompleteSubTasks.length);
+                                            break;
+                                    }
+                                }
+                            }
+                            break;
+                    }
+                    // do not update sat if the task is complete
+                    if (completion !== true && delayUntil != null) {
+                        // must be at least 20 seconds into the future from now, and/or the nextSat time to avoid parallel runs
+                        const minimumNextSatTime = dateFns.addSeconds(new Date(), 20);
+                        notificationTemplate.sat = date.findMaxDate([util.dateOrMillisecondsToDate(delayUntil, now), nextSat, minimumNextSatTime]) ?? minimumNextSatTime;
+                    }
+                    partNotificationMarkedDone = notificationTemplate.d === true;
+                }
+                catch (e) {
+                    console.error(`Failed handling task for notification "${notification.key}" with type "${notificationTask.taskType}": `, e);
+                    notificationTemplate.a = notification.a + 1; // increase attempts count
+                    notificationTemplate.sat = util.dateOrMillisecondsToDate(NOTIFICATION_TASK_TYPE_FAILURE_DELAY_MS, now);
+                    partSuccess = false;
+                }
+                // notification tasks are read
+                let saveTaskResult = true;
+                if (unique) {
+                    isUniqueNotificationTask = true;
+                    const latestNotification = await notificationDocument.snapshotData();
+                    if (!latestNotification || !date.isSameDate(latestNotification.cat, notification.cat)) {
+                        saveTaskResult = false;
+                        uniqueNotificationTaskConflict = true;
+                    }
+                }
+                if (saveTaskResult) {
+                    await notificationDocument.update(notificationTemplate);
+                }
+                return {
+                    tryRunNextPart,
+                    partNotificationMarkedDone,
+                    partNotificationTaskCompletionType,
+                    partTprReversal,
+                    nextCompleteSubTasks,
+                    partSuccess
+                };
+            }
+            /**
+             * Notification task handling.
+             *
+             * Notification takss can have multiple async but sequential parts.
+             *
+             * Some of these parts may be able to be run immediately one after the other, instead of waiting for
+             * another sendNotification() to complete on it.
+             */
+            async function handleNotificationTask() {
+                const MAX_NOTIFICATION_TASK_PARTS_RUN_ALLOWED = 5;
+                if (tryRun && notification != null && notificationTaskHandler) {
+                    let currentNotification = notification;
+                    let previouslyCompleteSubTasks = [];
+                    notificationTaskLoopingProtectionTriggered = false;
+                    notificationTaskPartsRunCount = 0;
+                    while (notificationTaskPartsRunCount < MAX_NOTIFICATION_TASK_PARTS_RUN_ALLOWED) {
+                        notificationTaskPartsRunCount += 1;
+                        const result = await _runNotificationTaskNextPart({
+                            notification: currentNotification,
+                            notificationTaskHandler,
+                            previouslyCompleteSubTasks
+                        });
+                        notificationTaskCompletionType = result.partNotificationTaskCompletionType;
+                        previouslyCompleteSubTasks = result.nextCompleteSubTasks ?? [];
+                        success = result.partSuccess;
+                        const tryRunNextPart = result.partSuccess && result.tryRunNextPart && !notificationTaskLoopingProtectionTriggered;
+                        notificationTaskLoopingProtectionTriggered = notificationTaskLoopingProtectionTriggered || result.partTprReversal; // update the flag if the TPR has been reversed
+                        if (tryRunNextPart) {
+                            const updatedNotificationData = await notificationDocument.snapshotData();
+                            if (updatedNotificationData) {
+                                currentNotification = firebase.setIdAndKeyFromKeyIdRefOnDocumentData(updatedNotificationData, notificationDocument);
+                            }
+                            else {
+                                break; // notification is unavailable now
+                            }
+                        }
+                        else {
+                            break; // escape the loop
+                        }
+                    }
+                }
+            }
+            /**
+             * Handles a normal (non-task) notification.
+             */
+            async function handleNormalNotification() {
+                // notification is only null/undefined if it didn't exist.
+                if (notification != null) {
+                    if (tryRun && templateInstance != null) {
+                        // first load the message function
+                        const messageFunction = await templateInstance
+                            .loadMessageFunction({
+                            item: notification.n,
+                            notification,
+                            notificationBox: {
+                                m: notificationBoxModelKey
+                            }
+                        })
+                            .catch((e) => {
+                            loadMessageFunctionFailure = true;
+                            success = false;
+                            console.error(`Failed loading message function for type ${notificationTemplateType}: `, e);
+                            return undefined;
+                        });
+                        if (messageFunction) {
+                            function filterOutNoContentNotificationMessages(messages) {
+                                return messages.filter((x) => !x.flag);
+                            }
+                            // expand recipients
+                            const { emails: emailRecipients, texts: textRecipients, notificationSummaries: notificationSummaryRecipients } = await expandNotificationRecipients({
+                                notification,
+                                notificationBox,
+                                authService,
+                                notificationUserAccessor,
+                                globalRecipients: messageFunction.globalRecipients,
+                                onlySendToExplicitlyEnabledRecipients,
+                                onlyTextExplicitlyEnabledRecipients,
+                                notificationSummaryIdForUid: notificationSendService.notificationSummaryIdForUidFunction
+                            });
+                            let { es, ts, ps, ns, esr: currentEsr, tsr: currentTsr } = notification;
+                            // do emails
+                            let esr;
+                            if (es === firebase.NotificationSendState.QUEUED || es === firebase.NotificationSendState.SENT_PARTIAL) {
+                                const emailRecipientsAlreadySentTo = new Set(currentEsr.map((x) => x.toLowerCase()));
+                                const emailInputContexts = emailRecipients
+                                    .filter((x) => !emailRecipientsAlreadySentTo.has(x.emailAddress.toLowerCase()))
+                                    .map((x) => {
+                                    const context = {
+                                        recipient: {
+                                            n: x.name,
+                                            e: x.emailAddress,
+                                            t: x.phoneNumber
+                                        }
+                                    };
+                                    return context;
+                                });
+                                const emailMessages = await Promise.all(emailInputContexts.map(messageFunction))
+                                    .then(filterOutNoContentNotificationMessages)
+                                    .catch((e) => {
+                                    console.error(`Failed building message function for type ${notificationTemplateType}: `, e);
+                                    buildMessageFailure = true;
+                                    return undefined;
+                                });
+                                if (emailMessages?.length) {
+                                    if (notificationSendService.emailSendService != null) {
+                                        let sendInstance;
+                                        try {
+                                            sendInstance = await notificationSendService.emailSendService.buildSendInstanceForEmailNotificationMessages(emailMessages);
+                                        }
+                                        catch (e) {
+                                            console.error(`Failed building email send instance for notification "${notification.id}" with type "${notificationTemplateType}": `, e);
+                                            es = firebase.NotificationSendState.CONFIG_ERROR;
+                                        }
+                                        if (sendInstance) {
+                                            try {
+                                                sendEmailsResult = await sendInstance();
+                                            }
+                                            catch (e) {
+                                                console.error(`Failed sending email notification "${notification.id}" with type "${notificationTemplateType}": `, e);
+                                                es = firebase.NotificationSendState.SEND_ERROR;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        console.error(`Failed sending email notification "${notification.id}" with type "${notificationTemplateType}" due to no email service being configured.`);
+                                        es = firebase.NotificationSendState.CONFIG_ERROR;
+                                    }
+                                    if (sendEmailsResult != null) {
+                                        const { success, failed } = sendEmailsResult;
+                                        esr = success.length ? currentEsr.concat(success.map((x) => x.toLowerCase())) : undefined;
+                                        if (failed.length > 0) {
+                                            es = firebase.NotificationSendState.SENT_PARTIAL;
+                                        }
+                                        else {
+                                            es = firebase.NotificationSendState.SENT;
+                                        }
+                                    }
+                                }
+                                else {
+                                    es = firebase.NotificationSendState.SENT;
+                                }
+                            }
+                            // do phone numbers
+                            let tsr;
+                            if (ts === firebase.NotificationSendState.QUEUED || ts === firebase.NotificationSendState.SENT_PARTIAL) {
+                                const textRecipientsAlreadySentTo = new Set(currentTsr);
+                                const textInputContexts = textRecipients
+                                    .filter((x) => !textRecipientsAlreadySentTo.has(x.phoneNumber))
+                                    .map((x) => {
+                                    const context = {
+                                        recipient: {
+                                            n: x.name,
+                                            e: x.emailAddress,
+                                            t: x.phoneNumber
+                                        }
+                                    };
+                                    return context;
+                                });
+                                const textMessages = await Promise.all(textInputContexts.map(messageFunction))
+                                    .then(filterOutNoContentNotificationMessages)
+                                    .catch((e) => {
+                                    console.error(`Failed building message function for type ${notificationTemplateType}: `, e);
+                                    buildMessageFailure = true;
+                                    return undefined;
+                                });
+                                if (textMessages?.length) {
+                                    if (notificationSendService.textSendService != null) {
+                                        let sendInstance;
+                                        try {
+                                            sendInstance = await notificationSendService.textSendService.buildSendInstanceForTextNotificationMessages(textMessages);
+                                        }
+                                        catch (e) {
+                                            console.error(`Failed building text send instance for notification "${notification.id}" with type "${notificationTemplateType}": `, e);
+                                            ts = firebase.NotificationSendState.CONFIG_ERROR;
+                                        }
+                                        if (sendInstance) {
+                                            try {
+                                                sendTextsResult = await sendInstance();
+                                            }
+                                            catch (e) {
+                                                console.error(`Failed sending text notification "${notification.id}" with type "${notificationTemplateType}": `, e);
+                                                ts = firebase.NotificationSendState.SEND_ERROR;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        console.error(`Failed sending text notification "${notification.id}" with type "${notificationTemplateType}" due to no text service being configured.`);
+                                        ts = firebase.NotificationSendState.CONFIG_ERROR;
+                                    }
+                                    if (sendTextsResult != null) {
+                                        const { success, failed } = sendTextsResult;
+                                        tsr = success.length ? currentTsr.concat(success) : undefined;
+                                        if (failed.length > 0) {
+                                            ts = firebase.NotificationSendState.SENT_PARTIAL;
+                                        }
+                                        else {
+                                            ts = firebase.NotificationSendState.SENT;
+                                        }
+                                    }
+                                }
+                                else {
+                                    ts = firebase.NotificationSendState.SENT;
+                                }
+                            }
+                            ps = firebase.NotificationSendState.NO_TRY;
+                            // NOTE: FCM token management will probably done with a separate system within Notification that stores FCMs for specific users in the app. May also use UIDs to determine who got the push notificdation or not...
+                            // do notification summaries
+                            if (ns === firebase.NotificationSendState.QUEUED || ns === firebase.NotificationSendState.SENT_PARTIAL) {
+                                const notificationSummaryInputContexts = notificationSummaryRecipients.map((x) => {
+                                    const context = {
+                                        recipient: {
+                                            n: x.name,
+                                            s: x.notificationSummaryId
+                                        }
+                                    };
+                                    return context;
+                                });
+                                const notificationSummaryMessages = await Promise.all(notificationSummaryInputContexts.map(messageFunction))
+                                    .then(filterOutNoContentNotificationMessages)
+                                    .catch((e) => {
+                                    console.error(`Failed building message function for type ${notificationTemplateType}: `, e);
+                                    buildMessageFailure = true;
+                                    return undefined;
+                                });
+                                if (notificationSummaryMessages?.length) {
+                                    if (notificationSendService.notificationSummarySendService != null) {
+                                        let sendInstance;
+                                        try {
+                                            sendInstance = await notificationSendService.notificationSummarySendService.buildSendInstanceForNotificationSummaryMessages(notificationSummaryMessages);
+                                        }
+                                        catch (e) {
+                                            console.error(`Failed building notification summary send instance for notification "${notification.id}" with type "${notificationTemplateType}": `, e);
+                                            ns = firebase.NotificationSendState.CONFIG_ERROR;
+                                        }
+                                        if (sendInstance) {
+                                            try {
+                                                sendNotificationSummaryResult = await sendInstance();
+                                                ns = firebase.NotificationSendState.SENT;
+                                            }
+                                            catch (e) {
+                                                console.error(`Failed sending notification summary notification "${notification.id}" with type "${notificationTemplateType}": `, e);
+                                                ns = firebase.NotificationSendState.SEND_ERROR;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        console.error(`Failed sending notification summary notification "${notification.id}" with type "${notificationTemplateType}" due to no notification summary service being configured.`);
+                                        ns = firebase.NotificationSendState.CONFIG_ERROR;
+                                    }
+                                }
+                                else {
+                                    ns = firebase.NotificationSendState.SENT;
+                                }
+                            }
+                            // calculate results
+                            const notificationTemplate = { es, ts, ps, ns, esr, tsr };
+                            success = firebase.notificationSendFlagsImplyIsComplete(notificationTemplate);
+                            if (success) {
+                                notificationTemplate.d = true;
+                            }
+                            else {
+                                notificationTemplate.a = notification.a + 1;
+                                if (notificationTemplate.a >= NOTIFICATION_MAX_SEND_ATTEMPTS) {
+                                    notificationTemplate.d = true;
+                                }
+                            }
+                            await notificationDocument.update(notificationTemplate);
+                            notificationMarkedDone = notificationTemplate.d === true;
+                            const callbackDetails = {
+                                success,
+                                updatedSendFlags: notificationTemplate,
+                                sendEmailsResult,
+                                sendTextsResult,
+                                sendNotificationSummaryResult
+                            };
+                            const { onSendAttempted, onSendSuccess } = messageFunction;
+                            // call onSendAttempted, if one is configured
+                            if (onSendAttempted) {
+                                onSendAttemptedResult = await util.asPromise(onSendAttempted(callbackDetails))
+                                    .then((value) => {
+                                    return { value };
+                                })
+                                    .catch((e) => {
+                                    console.warn(`Caught exception while calling onSendAttempted for notification "${notification.id}" with type "${notificationTemplateType}": `, e);
+                                    return { error: e };
+                                });
+                            }
+                            // call onSendSuccess, if one is configured
+                            if (notificationMarkedDone && onSendSuccess) {
+                                onSendSuccessResult = await util.asPromise(onSendSuccess(callbackDetails))
+                                    .then((value) => {
+                                    return { value };
+                                })
+                                    .catch((e) => {
+                                    console.warn(`Caught exception while calling onSendSuccess for notification "${notification.id}" with type "${notificationTemplateType}": `, e);
+                                    return { error: e };
+                                });
+                            }
+                        }
+                    }
+                    else {
+                        switch (notification.st) {
+                            case firebase.NotificationSendType.SEND_IF_BOX_EXISTS:
+                                // deleted successfully
+                                success = deletedNotification;
+                                break;
+                        }
+                    }
+                }
+            }
+            const result = {
+                notificationTemplateType,
+                isKnownTemplateType,
+                isNotificationTask,
+                isUniqueNotificationTask,
+                uniqueNotificationTaskConflict,
+                isConfiguredTemplateType,
+                throttled,
+                exists: notification != null,
+                boxExists: notificationBox != null,
+                notificationTaskPartsRunCount,
+                notificationTaskLoopingProtectionTriggered,
+                notificationBoxNeedsInitialization,
+                notificationTaskCompletionType,
+                createdBox,
+                deletedNotification,
+                notificationMarkedDone,
+                tryRun,
+                success,
+                sendEmailsResult,
+                sendTextsResult,
+                sendNotificationSummaryResult,
+                loadMessageFunctionFailure,
+                buildMessageFailure,
+                onSendAttemptedResult,
+                onSendSuccessResult
+            };
+            return result;
+        };
+    });
+}
+const SEND_QUEUE_NOTIFICATIONS_TASK_EXCESS_THRESHOLD = 5000;
+function sendQueuedNotificationsFactory(context) {
+    const { firebaseServerActionTransformFunctionFactory, notificationCollectionGroup } = context;
+    const sendNotification = sendNotificationFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.SendQueuedNotificationsParams, async (params) => {
+        const { maxSendNotificationLoops } = params;
+        const maxLoops = maxSendNotificationLoops ?? Number.MAX_SAFE_INTEGER;
+        const sendNotificationLoopsTaskExcessThreshold = params.sendNotificationLoopsTaskExcessThreshold ?? SEND_QUEUE_NOTIFICATIONS_TASK_EXCESS_THRESHOLD;
+        return async (input) => {
+            const maxParallelTasks = input?.maxParellelSendTasks ?? params.maxParellelSendTasks ?? 5;
+            const onSendNotificationResult = input?.onSendNotificationResult ?? util.mapIdentityFunction();
+            let notificationLoopCount = 0;
+            let notificationBoxesCreated = 0;
+            let notificationsDeleted = 0;
+            let notificationTasksVisited = 0;
+            let notificationsVisited = 0;
+            let notificationsSucceeded = 0;
+            let notificationsDelayed = 0;
+            let notificationsFailed = 0;
+            let sendEmailsResult;
+            let sendTextsResult;
+            let sendNotificationSummaryResult;
+            const sendNotificationParams = { key: firebase.firestoreDummyKey(), throwErrorIfSent: false };
+            const sendNotificationInstance = await sendNotification(sendNotificationParams);
+            let excessLoopsDetected = false;
+            const sendQueuedNotifications = async () => {
+                const query = notificationCollectionGroup.queryDocument(firebase.notificationsPastSendAtTimeQuery());
+                const notificationDocuments = await query.getDocs();
+                const result = await util.performAsyncTasks(notificationDocuments, async (notificationDocument) => {
+                    const result = await sendNotificationInstance(notificationDocument);
+                    onSendNotificationResult(result, notificationDocument);
+                    return result;
+                }, {
+                    maxParallelTasks
+                });
+                return result;
+            };
+            // iterate through all notification items that need to be synced
+            while (notificationLoopCount < maxLoops) {
+                const sendQueuedNotificationsResults = await sendQueuedNotifications();
+                sendQueuedNotificationsResults.results.forEach((x) => {
+                    const result = x[1];
+                    if (result.success) {
+                        notificationsSucceeded += 1;
+                    }
+                    else if (result.createdBox || result.notificationBoxNeedsInitialization) {
+                        notificationsDelayed += 1;
+                    }
+                    else {
+                        notificationsFailed += 1;
+                    }
+                    if (result.isNotificationTask) {
+                        notificationTasksVisited += 1;
+                    }
+                    if (result.deletedNotification) {
+                        notificationsDeleted += 1;
+                    }
+                    if (result.createdBox) {
+                        notificationBoxesCreated += 1;
+                    }
+                    sendEmailsResult = firebase.mergeNotificationSendMessagesResult(sendEmailsResult, result.sendEmailsResult);
+                    sendTextsResult = firebase.mergeNotificationSendMessagesResult(sendTextsResult, result.sendTextsResult);
+                    sendNotificationSummaryResult = firebase.mergeNotificationSendMessagesResult(sendNotificationSummaryResult, result.sendNotificationSummaryResult);
+                });
+                const found = sendQueuedNotificationsResults.results.length;
+                notificationsVisited += found;
+                notificationLoopCount += 1;
+                if (!found) {
+                    break;
+                }
+                else if (!excessLoopsDetected && notificationLoopCount > sendNotificationLoopsTaskExcessThreshold) {
+                    excessLoopsDetected = true;
+                    console.error(`sendQueuedNotifications(EXCESS_LOOPS_DETECTED): Exceeded send notification loops task excess threshold of ${sendNotificationLoopsTaskExcessThreshold}.`);
+                    // continue the loops
+                }
+            }
+            const result = {
+                excessLoopsDetected,
+                notificationLoopCount,
+                notificationBoxesCreated,
+                notificationsDeleted,
+                notificationTasksVisited,
+                notificationsVisited,
+                notificationsSucceeded,
+                notificationsDelayed,
+                notificationsFailed,
+                sendEmailsResult,
+                sendTextsResult,
+                sendNotificationSummaryResult
+            };
+            return result;
+        };
+    });
+}
+function cleanupSentNotificationsFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory, notificationCollectionGroup, notificationBoxCollection, notificationWeekCollectionFactory } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase.CleanupSentNotificationsParams, async () => {
+        return async () => {
+            let notificationBoxesUpdatesCount = 0;
+            let notificationsDeleted = 0;
+            const notificationTasksDeletedCount = 0;
+            let notificationWeeksCreated = 0;
+            let notificationWeeksUpdated = 0;
+            // iterate through all Notification items that need to be cleaned up
+            while (true) {
+                const cleanupSentNotificationsResults = await cleanupSentNotifications();
+                cleanupSentNotificationsResults.results.forEach((x) => {
+                    const { itemsDeleted, weeksCreated, weeksUpdated } = x[1];
+                    notificationsDeleted += itemsDeleted;
+                    notificationWeeksCreated += weeksCreated;
+                    notificationWeeksUpdated += weeksUpdated;
+                });
+                const notificationBoxesUpdated = cleanupSentNotificationsResults.results.length;
+                notificationBoxesUpdatesCount += notificationBoxesUpdated;
+                if (!notificationBoxesUpdated) {
+                    break;
+                }
+            }
+            async function cleanupSentNotifications() {
+                const query = notificationCollectionGroup.queryDocument(firebase.notificationsReadyForCleanupQuery());
+                const notificationDocuments = await query.getDocs();
+                const notificationDocumentsGroupedByNotificationBox = Array.from(util.makeValuesGroupMap(notificationDocuments, (x) => x.parent.id).values());
+                const result = await util.performAsyncTasks(notificationDocumentsGroupedByNotificationBox, async (notificationDocumentsInSameBox) => {
+                    const allPairs = await firebase.getDocumentSnapshotDataPairs(notificationDocumentsInSameBox);
+                    const allPairsWithDataAndMarkedDeleted = allPairs.filter((x) => x.data?.d);
+                    const { included: taskPairsWithDataAndMarkedDeleted, excluded: normalPairsWithDataAndMarkedDeleted } = util.separateValues(allPairsWithDataAndMarkedDeleted, (x) => x.data?.st === firebase.NotificationSendType.TASK_NOTIFICATION);
+                    const pairsGroupedByWeek = Array.from(util.makeValuesGroupMap(normalPairsWithDataAndMarkedDeleted, (x) => date.yearWeekCode(x.data.sat)).entries());
+                    // batch incase there are a lot of new notifications to move to week
+                    const pairsGroupedByWeekInBatches = pairsGroupedByWeek
+                        .map((x) => {
+                        const batches = util.batch(x[1], 40);
+                        return batches.map((batch) => [x[0], batch]);
+                    })
+                        .flat();
+                    const notificationBoxDocument = await notificationBoxCollection.documentAccessor().loadDocument(notificationDocumentsInSameBox[0].parent);
+                    // create/update the NotificationWeek
+                    const notificationWeekResults = await util.performAsyncTasks(pairsGroupedByWeekInBatches, async ([yearWeekCode, notificationDocumentsInSameWeek]) => {
+                        return firestoreContext.runTransaction(async (transaction) => {
+                            const notificationWeekDocument = notificationWeekCollectionFactory(notificationBoxDocument).documentAccessorForTransaction(transaction).loadDocumentForId(`${yearWeekCode}`);
+                            const notificationDocumentsInTransaction = firebase.loadDocumentsForDocumentReferencesFromValues(notificationCollectionGroup.documentAccessorForTransaction(transaction), notificationDocumentsInSameWeek, (x) => x.snapshot.ref);
+                            const notificationWeek = await notificationWeekDocument.snapshotData();
+                            const newItems = util.filterMaybeArrayValues(notificationDocumentsInSameWeek.map((x) => {
+                                const data = x.data;
+                                const shouldSaveToNotificationWeek = firebase.shouldSaveNotificationToNotificationWeek(data);
+                                return shouldSaveToNotificationWeek ? data.n : undefined;
+                            }));
+                            const n = [...(notificationWeek?.n ?? []), ...newItems];
+                            if (!notificationWeek) {
+                                // create
+                                await notificationWeekDocument.create({
+                                    w: yearWeekCode,
+                                    n
+                                });
+                            }
+                            else {
+                                // update
+                                await notificationWeekDocument.update({
+                                    n
+                                });
+                            }
+                            // delete the notification items
+                            await Promise.all(notificationDocumentsInTransaction.map((x) => x.accessor.delete()));
+                            return {
+                                created: !notificationWeek
+                            };
+                        });
+                    });
+                    // delete all the task notifications
+                    const writeBatch = firestoreContext.batch();
+                    const writeBatchAccessor = notificationCollectionGroup.documentAccessorForTransaction(writeBatch);
+                    await Promise.all(taskPairsWithDataAndMarkedDeleted.map((x) => writeBatchAccessor.loadDocumentFrom(x.document).accessor.delete()));
+                    await writeBatch.commit();
+                    let weeksCreated = 0;
+                    let weeksUpdated = 0;
+                    const tasksDeleted = taskPairsWithDataAndMarkedDeleted.length;
+                    notificationWeekResults.results.forEach((x) => {
+                        if (x[1].created) {
+                            weeksCreated += 1;
+                        }
+                        else {
+                            weeksUpdated += 1;
+                        }
+                    });
+                    const result = {
+                        weeksCreated,
+                        weeksUpdated,
+                        itemsDeleted: allPairsWithDataAndMarkedDeleted.length,
+                        tasksDeleted
+                    };
+                    return result;
+                }, {
+                    maxParallelTasks: 10
+                });
+                return result;
+            }
+            const result = {
+                notificationBoxesUpdatesCount,
+                notificationTasksDeletedCount,
+                notificationsDeleted,
+                notificationWeeksCreated,
+                notificationWeeksUpdated
+            };
+            return result;
+        };
+    });
+}
+
+// MARK: NotificationInitServerActionsContextConfig
+/**
+ * Token to access/override the NotificationTemplateService's defaults records.
+ */
+const NOTIFICATION_INIT_SERVER_ACTIONS_CONTEXT_CONFIG_TOKEN = 'NOTIFICATION_INIT_SERVER_ACTIONS_CONTEXT_CONFIG';
+const MAKE_TEMPLATE_FOR_NOTIFICATION_RELATED_MODEL_INITIALIZATION_FUNCTION_DELETE_RESPONSE = false;
+class NotificationInitServerActions {
+}
+function notificationInitServerActions(context) {
+    return {
+        initializeNotificationBox: initializeNotificationBoxFactory(context),
+        initializeAllApplicableNotificationBoxes: initializeAllApplicableNotificationBoxesFactory(context),
+        initializeNotificationSummary: initializeNotificationSummaryFactory(context),
+        initializeAllApplicableNotificationSummaries: initializeAllApplicableNotificationSummariesFactory(context)
+    };
+}
+async function initializeNotificationModelInTransaction(input) {
+    const { makeTemplateFunction, throwErrorIfAlreadyInitialized, transaction, document: documentInTransaction, data: notificationBox } = input;
+    let initialized = false;
+    const alreadyInitialized = !notificationBox.s;
+    if (!alreadyInitialized) {
+        const flatModelKey = documentInTransaction.id;
+        const modelKey = firebase.inferKeyFromTwoWayFlatFirestoreModelKey(flatModelKey);
+        const modelCollectionName = firebase.firestoreModelKeyCollectionName(modelKey);
+        const input = {
+            transaction,
+            flatModelKey,
+            modelKey,
+            collectionName: modelCollectionName
+        };
+        const template = await makeTemplateFunction(input);
+        if (template === false) {
+            await documentInTransaction.accessor.delete();
+        }
+        else if (template == null) {
+            await documentInTransaction.update({
+                s: false, // set false when "f" is set true
+                fi: true
+            });
+        }
+        else {
+            initialized = true;
+            await documentInTransaction.update({
+                //
+                ...template,
+                m: undefined, // should not be changed
+                s: null, // is now initialized.
+                fi: false // set false
+            });
+        }
+    }
+    else if (throwErrorIfAlreadyInitialized) {
+        throw notificationModelAlreadyInitializedError();
+    }
+    return {
+        initialized,
+        alreadyInitialized
+    };
+}
+function initializeNotificationBoxInTransactionFactory(context) {
+    const { notificationBoxCollection, makeTemplateForNotificationBoxInitialization } = context;
+    return async (params, notificationBoxDocument, transaction) => {
+        const { throwErrorIfAlreadyInitialized } = params;
+        const notificationBoxDocumentInTransaction = notificationBoxCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(notificationBoxDocument);
+        const notificationBox = await firebaseServer.assertSnapshotData(notificationBoxDocumentInTransaction);
+        return initializeNotificationModelInTransaction({
+            makeTemplateFunction: makeTemplateForNotificationBoxInitialization,
+            throwErrorIfAlreadyInitialized,
+            transaction,
+            document: notificationBoxDocumentInTransaction,
+            data: notificationBox
+        });
+    };
+}
+function initializeNotificationBoxFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory } = context;
+    const initializeNotificationBoxInTransaction = initializeNotificationBoxInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.InitializeNotificationModelParams, async (params) => {
+        return async (notificationBoxDocument) => {
+            await firestoreContext.runTransaction((transaction) => initializeNotificationBoxInTransaction(params, notificationBoxDocument, transaction));
+            return notificationBoxDocument;
+        };
+    });
+}
+function initializeAllApplicableNotificationBoxesFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory, notificationBoxCollection, notificationCollectionGroup } = context;
+    const initializeNotificationBoxInTransaction = initializeNotificationBoxInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.InitializeAllApplicableNotificationBoxesParams, async () => {
+        return async () => {
+            let notificationBoxesVisited = 0;
+            let notificationBoxesSucceeded = 0;
+            let notificationBoxesFailed = 0;
+            let notificationBoxesAlreadyInitialized = 0;
+            const initializeNotificationBoxParams = { key: firebase.firestoreDummyKey(), throwErrorIfAlreadyInitialized: false };
+            async function initializeNotificationBoxes() {
+                const query = notificationBoxCollection.queryDocument(firebase.notificationBoxesFlaggedForNeedsInitializationQuery());
+                const notificationBoxDocuments = await query.getDocs();
+                const result = await util.performAsyncTasks(notificationBoxDocuments, async (notificationBoxDocument) => {
+                    return firestoreContext.runTransaction((transaction) => initializeNotificationBoxInTransaction(initializeNotificationBoxParams, notificationBoxDocument, transaction));
+                }, {
+                    maxParallelTasks: 5
+                });
+                return result;
+            }
+            // iterate through all NotificationBox items that need to be synced
+            while (true) {
+                const initializeNotificationBoxesResults = await initializeNotificationBoxes();
+                initializeNotificationBoxesResults.results.forEach((x) => {
+                    const result = x[1];
+                    if (result.alreadyInitialized) {
+                        notificationBoxesAlreadyInitialized += 1;
+                    }
+                    else if (result.initialized) {
+                        notificationBoxesSucceeded += 1;
+                    }
+                    else {
+                        notificationBoxesFailed += 1;
+                    }
+                });
+                const found = initializeNotificationBoxesResults.results.length;
+                notificationBoxesVisited += found;
+                if (!found) {
+                    break;
+                }
+            }
+            const result = {
+                notificationBoxesVisited,
+                notificationBoxesSucceeded,
+                notificationBoxesFailed,
+                notificationBoxesAlreadyInitialized
+            };
+            return result;
+        };
+    });
+}
+function initializeNotificationSummaryInTransactionFactory(context) {
+    const { notificationSummaryCollection, makeTemplateForNotificationSummaryInitialization } = context;
+    return async (params, notificationSummaryDocument, transaction) => {
+        const { throwErrorIfAlreadyInitialized } = params;
+        const notificationSummaryDocumentInTransaction = notificationSummaryCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(notificationSummaryDocument);
+        const notificationSummary = await firebaseServer.assertSnapshotData(notificationSummaryDocumentInTransaction);
+        return initializeNotificationModelInTransaction({
+            makeTemplateFunction: makeTemplateForNotificationSummaryInitialization,
+            throwErrorIfAlreadyInitialized,
+            transaction,
+            document: notificationSummaryDocumentInTransaction,
+            data: notificationSummary
+        });
+    };
+}
+function initializeNotificationSummaryFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory } = context;
+    const initializeNotificationSummaryInTransaction = initializeNotificationSummaryInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.InitializeNotificationModelParams, async (params) => {
+        return async (notificationSummaryDocument) => {
+            await firestoreContext.runTransaction((transaction) => initializeNotificationSummaryInTransaction(params, notificationSummaryDocument, transaction));
+            return notificationSummaryDocument;
+        };
+    });
+}
+function initializeAllApplicableNotificationSummariesFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory, notificationSummaryCollection, notificationCollectionGroup } = context;
+    const initializeNotificationSummaryInTransaction = initializeNotificationSummaryInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.InitializeAllApplicableNotificationSummariesParams, async () => {
+        return async () => {
+            let notificationSummariesVisited = 0;
+            let notificationSummariesSucceeded = 0;
+            let notificationSummariesFailed = 0;
+            let notificationSummariesAlreadyInitialized = 0;
+            const initializeNotificationSummaryParams = { key: firebase.firestoreDummyKey(), throwErrorIfAlreadyInitialized: false };
+            async function initializeNotificationSummaries() {
+                const query = notificationSummaryCollection.queryDocument(firebase.notificationSummariesFlaggedForNeedsInitializationQuery());
+                const notificationSummaryDocuments = await query.getDocs();
+                const result = await util.performAsyncTasks(notificationSummaryDocuments, async (notificationSummaryDocument) => {
+                    return firestoreContext.runTransaction((transaction) => initializeNotificationSummaryInTransaction(initializeNotificationSummaryParams, notificationSummaryDocument, transaction));
+                }, {
+                    maxParallelTasks: 5
+                });
+                return result;
+            }
+            // iterate through all NotificationSummary items that need to be synced
+            while (true) {
+                const initializeNotificationSummariesResults = await initializeNotificationSummaries();
+                initializeNotificationSummariesResults.results.forEach((x) => {
+                    const result = x[1];
+                    if (result.alreadyInitialized) {
+                        notificationSummariesAlreadyInitialized += 1;
+                    }
+                    else if (result.initialized) {
+                        notificationSummariesSucceeded += 1;
+                    }
+                    else {
+                        notificationSummariesFailed += 1;
+                    }
+                });
+                const found = initializeNotificationSummariesResults.results.length;
+                notificationSummariesVisited += found;
+                if (!found) {
+                    break;
+                }
+            }
+            const result = {
+                notificationSummariesVisited,
+                notificationSummariesSucceeded,
+                notificationSummariesFailed,
+                notificationSummariesAlreadyInitialized
+            };
+            return result;
+        };
+    });
+}
+
+/******************************************************************************
+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.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+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 __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+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;
+};
+
+// MARK: Tokens
+/**
+ * Token to access/override the NotificationTemplateService's defaults records.
+ */
+const NOTIFICATION_TEMPLATE_SERVICE_DEFAULTS_OVERRIDE_TOKEN = 'NOTIFICATION_TEMPLATE_SERVICE_DEFAULTS_OVERRIDE';
+/**
+ * Token to access the NotificationTemplateService's type configs array.
+ */
+const NOTIFICATION_TEMPLATE_SERVICE_CONFIGS_ARRAY_TOKEN = 'NOTIFICATION_TEMPLATE_SERVICE_CONFIGS_ARRAY';
+
+/**
+ * Service dedicated to providing access to NotificationMessageFunctionFactory values for specific NotificationTemplateTypes.
+ */
+exports.NotificationTemplateService = class NotificationTemplateService {
+    _defaults;
+    _config;
+    constructor(_inputDefaults, _inputConfigs) {
+        this._defaults = _inputDefaults ?? {};
+        this._config = new Map();
+        if (_inputConfigs != null) {
+            _inputConfigs.forEach((x) => {
+                this._config.set(x.type, x);
+            });
+        }
+    }
+    configPairForType(type) {
+        return [this._defaults[type], this._config.get(type)];
+    }
+    templateInstanceForType(type) {
+        return notificationTemplateServiceInstance(this, type);
+    }
+};
+exports.NotificationTemplateService = __decorate([
+    __param(0, common.Optional()),
+    __param(0, common.Inject(NOTIFICATION_TEMPLATE_SERVICE_DEFAULTS_OVERRIDE_TOKEN)),
+    __param(1, common.Inject(NOTIFICATION_TEMPLATE_SERVICE_CONFIGS_ARRAY_TOKEN)),
+    __metadata("design:paramtypes", [Object, Object])
+], exports.NotificationTemplateService);
+/**
+ * Creates a NotificationTemplateServiceInstance.
+ *
+ * @param service
+ * @param type
+ * @returns
+ */
+function notificationTemplateServiceInstance(service, type) {
+    const pair = service.configPairForType(type);
+    const isKnownType = pair[0] != null || pair[1] != null;
+    const defaultFactory = firebase.noContentNotificationMessageFunctionFactory();
+    const instanceConfig = pair[1];
+    return {
+        service,
+        type,
+        isConfiguredType: isKnownType,
+        loadMessageFunction: async (config) => {
+            const factory = instanceConfig?.factory ?? defaultFactory;
+            return factory(config);
+        }
+    };
+}
+
+/**
+ * Alternative version of createNotificationDocument() that checks if the document exists, and can run it if it does instead of recreated it.
+ *
+ * Does not support the use of a Transaction, as running should occur outside of a transaction.
+ *
+ * @param input
+ * @returns
+ */
+async function createOrRunUniqueNotificationDocument(input) {
+    const { expediteService, expediteInstance, updateNextRunAtTime, now: inputNow } = input;
+    let sat = input.template.sat;
+    if (updateNextRunAtTime != null) {
+        sat = updateNextRunAtTime === true ? (inputNow ?? new Date()) : updateNextRunAtTime;
+    }
+    const pair = firebase.createNotificationDocumentPair({
+        ...input,
+        template: {
+            ...input.template,
+            sat
+        }
+    });
+    if (!pair.notification.ut) {
+        throw new Error('createOrRunUniqueNotificationDocument(): Notification is not flagged as unique.');
+    }
+    const pairExists = await pair.notificationDocument.exists();
+    let result = {
+        ...pair,
+        notificationCreated: false
+    };
+    async function runNotificationTask() {
+        if (expediteService != null) {
+            result.runResult = await expediteService.sendNotification(pair.notificationDocument, input.sendNotificationOptions);
+        }
+        else if (expediteInstance != null) {
+            expediteInstance.enqueue(pair.notificationDocument);
+            result.runEnqueued = true;
+        }
+        else if (!result.notificationCreated && updateNextRunAtTime != null) {
+            await pair.notificationDocument.update({
+                sat: sat
+            });
+        }
+    }
+    if (pairExists) {
+        await runNotificationTask();
+    }
+    else {
+        result = await firebase._createNotificationDocumentFromPair(input, pair);
+        if (result.notificationCreated && input.runImmediatelyIfCreated) {
+            await runNotificationTask();
+        }
+    }
+    return result;
+}
+
+/**
+ * Service dedicated to providing access to NotificationMessageFunctionFactory values for specific NotificationTemplateTypes.
+ */
+class NotificationSendService {
+}
+
+/**
+ * Service dedicated to providing access to NotificationMessageFunctionFactory values for specific NotificationTemplateTypes.
+ */
+class NotificationTaskService {
+}
+
+/**
+ * Interface for a service that allows access to a NotificationServerActions instance and "expediting" the sending of notification(s) that should be emitted immediately for timeliness.
+ *
+ * @see MutableNotificationExpediteService is the default implementation.
+ */
+class NotificationExpediteService {
+}
+/**
+ * Creates a new NotificationExpediteServiceInstance with the input NotificationExpediteService.
+ 
+ * @param notificationExpediteService
+ * @returns
+ */
+function notificationExpediteServiceInstance(notificationExpediteService) {
+    let _documentsToSend = [];
+    const initialize = () => {
+        _documentsToSend = []; // resets the documents to send
+    };
+    const enqueue = (notificationDocument) => {
+        _documentsToSend.push(notificationDocument);
+    };
+    const enqueueCreateResult = (createResult) => {
+        let enqueued = false;
+        if (createResult.notificationDocument) {
+            enqueue(createResult.notificationDocument);
+            enqueued = true;
+        }
+        return enqueued;
+    };
+    const send = async (options) => {
+        const results = await util.runAsyncTasksForValues(_documentsToSend, (x) => notificationExpediteService.sendNotification(x, options), {
+            nonConcurrentTaskKeyFactory: (x) => x.parent.id // only send one notification at a time for a notification box
+        });
+        return results;
+    };
+    return {
+        initialize,
+        enqueue,
+        enqueueCreateResult,
+        send
+    };
+}
+// MARK: Implementation
+/**
+ * Service used to "expedite" the sending of a specific notification.
+ *
+ * Because the NotificationActionService is typically created after other action services are due to the dependency injection graph, this service is
+ * created before the NotificationActionService is created, and then later updated by the NotificationActionService.
+ *
+ * It is best provided by provideMutableNotificationExpediteService() as a global provider.
+ */
+exports.MutableNotificationExpediteService = class MutableNotificationExpediteService {
+    _notificationServerActions;
+    /**
+     * Returns the configured NotificationServerActions instance.
+     */
+    getNotificationServerActions() {
+        return this._notificationServerActions;
+    }
+    /**
+     * Sets the NotificationServerActions instance to use.
+     */
+    setNotificationServerActions(notificationServerActions) {
+        this._notificationServerActions = notificationServerActions;
+    }
+    async sendNotification(notificationDocument, options) {
+        const sendNotification = await this._notificationServerActions.sendNotification({ key: firebase.firestoreDummyKey(), ...options });
+        return sendNotification(notificationDocument);
+    }
+    expediteInstance() {
+        return notificationExpediteServiceInstance(this);
+    }
+};
+exports.MutableNotificationExpediteService = __decorate([
+    common.Injectable()
+], exports.MutableNotificationExpediteService);
+// MARK: Providers
+/**
+ * Provides an instance of MutableNotificationExpediteService and NotificationExpediteService.
+ *
+ * This should generally be used in the global module of an app.
+ */
+function provideMutableNotificationExpediteService() {
+    return [
+        exports.MutableNotificationExpediteService,
+        {
+            provide: NotificationExpediteService,
+            useExisting: exports.MutableNotificationExpediteService
+        }
+    ];
+}
+/**
+ * Convenience function that exports NotificationExpediteService and MutableNotificationExpediteService.
+ *
+ * This should generally be used in the global module of an app.
+ */
+function exportMutableNotificationExpediteService() {
+    return [NotificationExpediteService, exports.MutableNotificationExpediteService];
+}
+
+// MARK: Provider Factories
+function notificationServerActionsContextFactory(context, notificationTemplateService, notificationSendService, notificationTaskService, notificationsExpediteService) {
+    return { ...context, notificationTemplateService, notificationSendService, notificationTaskService, notificationsExpediteService };
+}
+function notificationServerActionsFactory(context, mutableNotificationExpediteService) {
+    return notificationServerActions(context);
+}
+function notificationInitServerActionsFactory(context, notificationInitServerActionsContextConfig) {
+    return notificationInitServerActions({
+        ...context,
+        ...notificationInitServerActionsContextConfig
+    });
+}
+/**
+ * Convenience function used to generate ModuleMetadata for an app's NotificationModule.
+ *
+ * By default this module exports:
+ * - NotificationServerActionContext (NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN)
+ * - NotificationTemplateService
+ * - NotificationServerActions
+ * - NotificationInitServerActions
+ * - NotificationExpediteService (MutableNotificationExpediteService is used as the existing, but it is not re-exported)
+ *
+ * Be sure the class that delares the module using this function also extends AbstractAppNotificationModule.
+ *
+ * @param provide
+ * @param useFactory
+ * @returns
+ */
+function appNotificationModuleMetadata(config$1) {
+    const { dependencyModule, imports, exports: exports$1, providers } = config$1;
+    const dependencyModuleImport = dependencyModule ? [dependencyModule] : [];
+    return {
+        imports: [config.ConfigModule, ...dependencyModuleImport, ...(imports ?? [])],
+        exports: [NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN, NotificationExpediteService, exports.NotificationTemplateService, NotificationServerActions, NotificationInitServerActions, ...(exports$1 ?? [])],
+        providers: [
+            {
+                provide: NotificationExpediteService,
+                useExisting: exports.MutableNotificationExpediteService
+            },
+            {
+                provide: NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN,
+                useFactory: notificationServerActionsContextFactory,
+                inject: [BASE_NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN, exports.NotificationTemplateService, NotificationSendService, NotificationTaskService, NotificationExpediteService]
+            },
+            {
+                provide: exports.NotificationTemplateService,
+                useClass: exports.NotificationTemplateService
+            },
+            {
+                provide: NotificationServerActions,
+                useFactory: notificationServerActionsFactory,
+                inject: [NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN, NotificationExpediteService]
+            },
+            {
+                provide: NotificationInitServerActions,
+                useFactory: notificationInitServerActionsFactory,
+                inject: [NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN, NOTIFICATION_INIT_SERVER_ACTIONS_CONTEXT_CONFIG_TOKEN]
+            },
+            ...(providers ?? [])
+        ]
+    };
+}
+/**
+ * Abstract module that should be extended when using appNotificationModuleMetadata.
+ */
+exports.AbstractAppNotificationModule = class AbstractAppNotificationModule {
+    constructor(mutableNotificationExpediteService, actions) {
+        mutableNotificationExpediteService.setNotificationServerActions(actions);
+    }
+};
+exports.AbstractAppNotificationModule = __decorate([
+    common.Module({}),
+    __param(0, common.Inject(exports.MutableNotificationExpediteService)),
+    __param(1, common.Inject(NotificationServerActions)),
+    __metadata("design:paramtypes", [exports.MutableNotificationExpediteService, NotificationServerActions])
+], exports.AbstractAppNotificationModule);
+/**
+ * Pre-configured global provider for MutableNotificationExpediteService/NotificationExpediteService.
+ */
+exports.GlobalNotificationModule = class GlobalNotificationModule {
+};
+exports.GlobalNotificationModule = __decorate([
+    common.Global(),
+    common.Module({
+        providers: provideMutableNotificationExpediteService(),
+        exports: exportMutableNotificationExpediteService()
+    })
+], exports.GlobalNotificationModule);
+
+function firestoreNotificationSummarySendService(config) {
+    const { context, allowCreateNotificationSummaries: inputAllowCreateNotificationSummaries } = config;
+    const { firestoreContext, notificationSummaryCollection } = context;
+    const allowCreateNotificationSummaries = inputAllowCreateNotificationSummaries ?? true;
+    const sendService = {
+        async buildSendInstanceForNotificationSummaryMessages(notificationMessages) {
+            const messagesGroupedByNotificationSummaryMapBuilder = util.multiValueMapBuilder();
+            notificationMessages.forEach((x) => {
+                if (x.inputContext.recipient.s != null && x.item != null) {
+                    // only add to map builder if recipient id is defined
+                    messagesGroupedByNotificationSummaryMapBuilder.add(x.inputContext.recipient.s, x);
+                }
+            });
+            const cutSubject = util.cutStringFunction({ maxLength: firebase.NOTIFICATION_SUMMARY_EMBEDDED_NOTIFICATION_ITEM_SUBJECT_MAX_LENGTH });
+            const cutMessage = util.cutStringFunction({ maxLength: firebase.NOTIFICATION_SUMMARY_EMBEDDED_NOTIFICATION_ITEM_MESSAGE_MAX_LENGTH });
+            const messagesGroups = messagesGroupedByNotificationSummaryMapBuilder.entries();
+            return async () => {
+                const success = [];
+                const failed = [];
+                const ignored = [];
+                await util.runAsyncTasksForValues(messagesGroups, async ([notificationSummaryId, messages]) => {
+                    await firestoreContext
+                        .runTransaction(async (transaction) => {
+                        const notificationSummaryDocument = notificationSummaryCollection.documentAccessorForTransaction(transaction).loadDocumentForId(notificationSummaryId);
+                        const notificationSummary = await notificationSummaryDocument.snapshotData();
+                        let updated = false;
+                        let updateTemplate;
+                        const existingMessages = notificationSummary?.n ?? [];
+                        const existingMessageIds = new Set(existingMessages.map((x) => x.id));
+                        // ignore any repeat messages
+                        const messagesToSend = messages.filter((x) => !existingMessageIds.has(x.item.id));
+                        if (messagesToSend.length > 0) {
+                            // add the new items to existing n, then keep the last 1000
+                            const sortedN = existingMessages
+                                .concat(messagesToSend.map((x) => {
+                                let message = '';
+                                if (x.content.openingMessage) {
+                                    message = x.content.openingMessage;
+                                }
+                                if (x.content.closingMessage) {
+                                    message = (message ? message + '\n\n' : message) + x.content.closingMessage;
+                                }
+                                const item = {
+                                    ...x.item,
+                                    s: cutSubject(x.content.title),
+                                    g: cutMessage(message)
+                                };
+                                return item;
+                            }))
+                                .sort(firebase.sortNotificationItemsFunction);
+                            const n = util.takeLast(sortedN, firebase.NOTIFICATION_SUMMARY_ITEM_LIMIT);
+                            updateTemplate = {
+                                n,
+                                lat: new Date()
+                            };
+                        }
+                        if (updateTemplate != null) {
+                            if (notificationSummary != null) {
+                                await notificationSummaryDocument.update(updateTemplate);
+                                updated = true;
+                            }
+                            else if (allowCreateNotificationSummaries) {
+                                // if it does not exist, and we are allowed to create new summaries, create it and add the new notifications
+                                const createTemplate = {
+                                    ...makeNewNotificationSummaryTemplate(firebase.inferKeyFromTwoWayFlatFirestoreModelKey(notificationSummaryId)),
+                                    ...updateTemplate
+                                };
+                                await notificationSummaryDocument.create(createTemplate);
+                                updated = true;
+                            }
+                        }
+                        return updated;
+                    })
+                        .then((updated) => {
+                        if (updated) {
+                            success.push(notificationSummaryId);
+                        }
+                        else {
+                            ignored.push(notificationSummaryId);
+                        }
+                    })
+                        .catch((e) => {
+                        console.error('firestoreNotificationSummarySendService(): failed updating notification summary', e);
+                        failed.push(notificationSummaryId);
+                    });
+                });
+                const sendResult = {
+                    success,
+                    failed,
+                    ignored
+                };
+                return sendResult;
+            };
+        }
+    };
+    return sendService;
+}
+
+/**
+ * NotificationTextSendService that ignores sending all messages.
+ *
+ * This is useful for cases where your app may eventually want to send text notifications and want the rest of your app configured like it currently does.
+ *
+ * @returns
+ */
+function ignoreSendNotificationTextSendService() {
+    const sendService = {
+        async buildSendInstanceForTextNotificationMessages(notificationMessages) {
+            return async () => {
+                const success = [];
+                const failed = [];
+                const ignored = notificationMessages.map((x) => x.inputContext.recipient.t);
+                const sendResult = {
+                    success,
+                    failed,
+                    ignored
+                };
+                return sendResult;
+            };
+        }
+    };
+    return sendService;
+}
+
+/**
+ * A basic NotificationTaskService implementation.
+ */
+function notificationTaskService(config) {
+    const { handlers: inputHandlers } = config;
+    const handlers = {};
+    inputHandlers.forEach((handlerConfig) => {
+        const { type } = handlerConfig;
+        handlers[type] = handlerForConfig(handlerConfig);
+    });
+    function handlerForConfig(handlerConfig) {
+        const { flow: inputFlows, allowRunMultipleParts } = handlerConfig;
+        const { included: checkpointFlows, excluded: nonCheckpointFlows } = util.separateValues(inputFlows, (x) => x.checkpoint != null);
+        if (inputFlows.length === 0) {
+            throw new Error('notificationTaskService(): NotificationTaskServiceTaskHandlerConfig must have at least one flow entry.');
+        }
+        else if (nonCheckpointFlows.length > 1) {
+            throw new Error('notificationTaskService(): NotificationTaskServiceTaskHandlerConfig must not have more than one non-checkpoint flow.');
+        }
+        return {
+            handleNotificationTask: async (notificationTask) => {
+                const { checkpoints: completedCheckpoints } = notificationTask;
+                let fn;
+                switch (completedCheckpoints.length) {
+                    case 0:
+                        fn = (nonCheckpointFlows[0] ?? checkpointFlows[0])?.fn;
+                        break;
+                    default:
+                        const completedCheckpointsSet = new Set(completedCheckpoints);
+                        /**
+                         * Find the next flow function that hasn't had its checkpoint completed yet.
+                         */
+                        const nextCheckpoint = checkpointFlows.find((x) => !completedCheckpointsSet.has(x.checkpoint));
+                        fn = nextCheckpoint?.fn;
+                        break;
+                }
+                let result;
+                if (fn) {
+                    result = await fn(notificationTask);
+                    // if allowRunMultipleParts is true, and the result doesn't have a canRunNextCheckpoint value, then set it to true.
+                    if (allowRunMultipleParts && result.canRunNextCheckpoint == null) {
+                        result.canRunNextCheckpoint = true;
+                    }
+                }
+                else {
+                    result = {
+                        completion: true // if there are no functions remaining, then the task is complete
+                    };
+                }
+                return result;
+            }
+        };
+    }
+    return {
+        isKnownNotificationTaskType: (notificationTaskType) => {
+            return handlers[notificationTaskType] !== undefined;
+        },
+        taskHandlerForNotificationTaskType: (notificationTaskType) => handlers[notificationTaskType]
+    };
+}
+
+/**
+ * Creates a NotificationTaskSubtaskNotificationTaskHandlerFactory.
+ */
+function notificationTaskSubtaskNotificationTaskHandlerFactory(factoryConfig) {
+    const { taskType, subtaskHandlerFunctionName: subtaskHandlerName, inputFunction, defaultCleanup, cleanupFunction, buildUpdateMetadata: inputBuildUpdateMetadata } = factoryConfig;
+    return (subtaskHandlerConfig) => {
+        const { processors: inputProcessors, maxCleanupRetryAttempts: inputMaxCleanupRetryAttempts, cleanupRetryDelay: inputCleanupRetryDelay, defaultAllowRunMultipleParts } = subtaskHandlerConfig;
+        const maxCleanupRetryAttempts = inputMaxCleanupRetryAttempts ?? firebase.DEFAULT_NOTIFICATION_TASK_SUBTASK_CLEANUP_RETRY_ATTEMPTS;
+        const cleanupRetryDelay = inputCleanupRetryDelay ?? firebase.DEFAULT_NOTIFICATION_TASK_SUBTASK_CLEANUP_RETRY_DELAY;
+        const buildUpdateMetadata = inputBuildUpdateMetadata ?? (() => undefined);
+        const processors = {};
+        inputProcessors.forEach((processorConfig) => {
+            const { target } = processorConfig;
+            processors[target] = processorFunctionForConfig(processorConfig);
+        });
+        /**
+         * Structure is similar to notificationTaskService(), but contained to handle the subtasks.
+         */
+        function processorFunctionForConfig(processorConfig) {
+            const { flow: inputFlows, cleanup, allowRunMultipleParts: processorAllowRunMultipleParts } = processorConfig;
+            const { included: subtaskFlows, excluded: nonSubtaskFlows } = util.separateValues(inputFlows, (x) => x.subtask != null);
+            const allowRunMultipleParts = processorAllowRunMultipleParts ?? defaultAllowRunMultipleParts;
+            if (inputFlows.length === 0) {
+                throw new Error(`${subtaskHandlerName}(): NotificationTaskSubtaskProcessorConfig must have at least one flow entry.`);
+            }
+            else if (nonSubtaskFlows.length > 1) {
+                throw new Error(`${subtaskHandlerName}(): NotificationTaskSubtaskProcessorConfig must not have more than one non-subtask flow.`);
+            }
+            const allKnownSubtasks = util.unique(inputFlows.map((x) => x.subtask));
+            return {
+                process: async (input) => {
+                    const { notificationTask, completedSubtasks, subtaskData } = input;
+                    let fn;
+                    switch (completedSubtasks.length) {
+                        case 0:
+                            fn = (nonSubtaskFlows[0] ?? subtaskFlows[0])?.fn;
+                            break;
+                        default:
+                            const completedSubtasksSet = new Set(completedSubtasks);
+                            /**
+                             * Find the next flow function that hasn't had its checkpoint completed yet.
+                             */
+                            const nextSubtask = subtaskFlows.find((x) => !completedSubtasksSet.has(x.subtask));
+                            fn = nextSubtask?.fn;
+                            break;
+                    }
+                    let result;
+                    if (fn) {
+                        /*
+                         * This section is similar to handleNotificationTask() in notification.action.server.ts,
+                         * but is modified to handle the subtasks. The main difference is the attempt count is maintained,
+                         * and instead is available via the normal NotificationTask attempts details.
+                         */
+                        const subtaskResult = await fn(input);
+                        const { completion: subtaskCompletion, updateMetadata: subtaskUpdateMetadata, delayUntil, canRunNextCheckpoint } = subtaskResult;
+                        let allSubtasksDone = false;
+                        let sfps = completedSubtasks;
+                        // update the task metadata to reflect the changes
+                        switch (subtaskCompletion) {
+                            case true:
+                                allSubtasksDone = true;
+                                break;
+                            case false:
+                                // remove any completions, if applicable
+                                sfps = removeFromCompletionsArrayWithTaskResult(sfps, subtaskResult);
+                                break;
+                            default:
+                                sfps = util.unique([
+                                    ...removeFromCompletionsArrayWithTaskResult(sfps, subtaskResult), // remove any completions, if applicable
+                                    ...util.asArray(subtaskCompletion)
+                                ]);
+                                const completedSubtasksSet = new Set(sfps);
+                                const incompleteSubtasks = allKnownSubtasks.filter((x) => !completedSubtasksSet.has(x));
+                                allSubtasksDone = incompleteSubtasks.length === 0;
+                                break;
+                        }
+                        // configure the update metadata result
+                        const sd = {
+                            ...subtaskData,
+                            ...subtaskUpdateMetadata
+                        };
+                        /**
+                         * This is updating the metadata for the NotificationTask, which has a nested data
+                         */
+                        const baseUpdateMetadata = {
+                            ...notificationTask.data,
+                            sfps,
+                            sd
+                        };
+                        let updateMetadata = (await buildUpdateMetadata(baseUpdateMetadata, input));
+                        if (updateMetadata) {
+                            // inject sfps and sd back in
+                            updateMetadata = {
+                                ...updateMetadata,
+                                sfps,
+                                sd
+                            };
+                        }
+                        else {
+                            updateMetadata = baseUpdateMetadata;
+                        }
+                        const nextCanRunNextCheckpoint = canRunNextCheckpoint ?? allowRunMultipleParts;
+                        result = {
+                            completion: allSubtasksDone ? ['processing'] : firebase.delayCompletion(), // return processing until all subtasks are complete.
+                            updateMetadata,
+                            canRunNextCheckpoint: nextCanRunNextCheckpoint,
+                            allCompletedSubTasks: sfps,
+                            delayUntil // delay is passed through
+                        };
+                    }
+                    else {
+                        // no more subtasks to process, and no metadata changes. Mark as processing complete and continue.
+                        result = firebase.completeSubtaskProcessingAndScheduleCleanupTaskResult();
+                    }
+                    return result;
+                },
+                cleanup
+            };
+        }
+        function useInputDataFactory(fn) {
+            return async (notificationTask) => {
+                const { data } = notificationTask;
+                let result;
+                if (data) {
+                    try {
+                        const inputFunctionResult = await inputFunction(data, notificationTask);
+                        result = await fn(notificationTask, inputFunctionResult, data);
+                    }
+                    catch (e) {
+                        if (e instanceof NotificationTaskSubTaskMissingRequiredDataTermination) {
+                            // Task is complete if the required data no longer exists. Nothing to cleanup.
+                            result = firebase.notificationTaskComplete();
+                        }
+                        else {
+                            // rethrow the error
+                            throw e;
+                        }
+                    }
+                }
+                else {
+                    // Improperly configured task. Complete immediately.
+                    result = firebase.notificationTaskComplete();
+                }
+                return result;
+            };
+        }
+        const result = {
+            type: taskType,
+            flow: [
+                {
+                    checkpoint: firebase.NOTIFICATION_TASK_SUBTASK_CHECKPOINT_PROCESSING,
+                    fn: useInputDataFactory(async (notificationTask, inputFunctionResult, data) => {
+                        let result;
+                        const baseInput = {
+                            ...inputFunctionResult,
+                            notificationTask
+                        };
+                        const { target } = baseInput;
+                        if (target) {
+                            const processor = processors[target];
+                            if (processor) {
+                                const { sd: subtaskData, sfps: completedSubtasks } = data;
+                                const input = {
+                                    ...baseInput,
+                                    target,
+                                    completedSubtasks: completedSubtasks ?? [],
+                                    subtaskData
+                                };
+                                result = await processor.process(input);
+                            }
+                            else {
+                                // processor is unknown. Complete the task.
+                                result = firebase.completeSubtaskProcessingAndScheduleCleanupTaskResult();
+                            }
+                        }
+                        else {
+                            // target is unknown. Complete the task.
+                            result = firebase.completeSubtaskProcessingAndScheduleCleanupTaskResult();
+                        }
+                        return result;
+                    })
+                },
+                {
+                    checkpoint: firebase.NOTIFICATION_TASK_SUBTASK_CHECKPOINT_CLEANUP,
+                    fn: useInputDataFactory(async (notificationTask, inputFunctionResult, data) => {
+                        let result;
+                        let cleanupFunctionInput = {
+                            ...inputFunctionResult,
+                            notificationTask
+                        };
+                        const { target } = cleanupFunctionInput;
+                        let cleanupInstructions;
+                        if (target) {
+                            const processor = processors[target];
+                            if (processor && processor.cleanup) {
+                                const { sd: subtaskData, sfps: completedSubtasks } = data;
+                                const input = {
+                                    ...cleanupFunctionInput,
+                                    notificationTask,
+                                    completedSubtasks: completedSubtasks ?? [],
+                                    target,
+                                    subtaskData
+                                };
+                                cleanupInstructions = (await processor.cleanup(input, defaultCleanup)) ?? (await defaultCleanup(cleanupFunctionInput));
+                                cleanupFunctionInput = input;
+                            }
+                            else {
+                                // processor is unknown. Complete the task.
+                                cleanupInstructions = await defaultCleanup(cleanupFunctionInput);
+                            }
+                        }
+                        else {
+                            // target is unknown. Complete the task.
+                            cleanupInstructions = await defaultCleanup(cleanupFunctionInput);
+                        }
+                        if (cleanupInstructions.cleanupSuccess === false && notificationTask.currentCheckpointSendAttempts <= maxCleanupRetryAttempts) {
+                            result = firebase.notificationTaskDelayRetry(cleanupInstructions.delayRetryUntil ?? cleanupRetryDelay);
+                        }
+                        else {
+                            result = await cleanupFunction(cleanupFunctionInput, cleanupInstructions);
+                        }
+                        return result;
+                    })
+                }
+            ]
+        };
+        return result;
+    };
+}
+// MARK: Internally Handled Errors
+/**
+ * Thrown when a subtask no longer has data available to continue processing.
+ *
+ * The subtask will be marked as immediately complete, and no cleanup will occur.
+ *
+ * This is useful in cases where the underlying models or data that the subtask rely on are deleted (and those models were also required for cleanup) so the task can be marked as complete without attempting cleanup.
+ */
+class NotificationTaskSubTaskMissingRequiredDataTermination extends makeError.BaseError {
+}
+/**
+ * Creates a NotificationTaskSubTaskMissingRequiredDataTermination.
+ */
+function notificationTaskSubTaskMissingRequiredDataTermination() {
+    return new NotificationTaskSubTaskMissingRequiredDataTermination();
+}
+
+function storageFileModelAlreadyInitializedError() {
+    return firebaseServer.preconditionConflictError({
+        message: `This model has already been initialized.`,
+        code: firebase.STORAGE_FILE_MODEL_ALREADY_INITIALIZED_ERROR_CODE
+    });
+}
+function storageFileNotFlaggedForGroupsSyncError() {
+    return firebaseServer.preconditionConflictError({
+        message: `This StorageFile has not been flagged for sync with its groups.`,
+        code: firebase.STORAGE_FILE_NOT_FLAGGED_FOR_GROUPS_SYNC_ERROR_CODE
+    });
+}
+function uploadedFileDoesNotExistError() {
+    return firebaseServer.preconditionConflictError({
+        message: `The target uploaded file does not exist.`,
+        code: firebase.UPLOADED_FILE_DOES_NOT_EXIST_ERROR_CODE
+    });
+}
+function uploadedFileIsNotAllowedToBeInitializedError() {
+    return firebaseServer.preconditionConflictError({
+        message: `The target uploaded file is not allowed to be initialized.`,
+        code: firebase.UPLOADED_FILE_NOT_ALLOWED_TO_BE_INITIALIZED_ERROR_CODE
+    });
+}
+function uploadedFileInitializationFailedError(data) {
+    return firebaseServer.internalServerError({
+        message: `The target uploaded file initialization failed with result type "${data.resultType}".`,
+        code: firebase.UPLOADED_FILE_INITIALIZATION_FAILED_ERROR_CODE,
+        data: {
+            resultType: data.resultType
+        }
+    });
+}
+function uploadedFileInitializationDiscardedError() {
+    return firebaseServer.internalServerError({
+        message: `The target uploaded file initialization was discarded.`,
+        code: firebase.UPLOADED_FILE_INITIALIZATION_DISCARDED_ERROR_CODE
+    });
+}
+function storageFileProcessingNotAllowedForInvalidStateError() {
+    return firebaseServer.preconditionConflictError({
+        message: `The target StorageFileDocument must be in an OK state to be processed and processing not flagged as SHOULD_NOT_PROCESS.`,
+        code: firebase.STORAGE_FILE_PROCESSING_NOT_ALLOWED_FOR_INVALID_STATE_ERROR_CODE
+    });
+}
+function storageFileProcessingNotQueuedForProcessingError() {
+    return firebaseServer.preconditionConflictError({
+        message: `The target StorageFileDocument is not queued for processing.`,
+        code: firebase.STORAGE_FILE_PROCESSING_NOT_QUEUED_FOR_PROCESSING_ERROR_CODE
+    });
+}
+function storageFileProcessingNotAvailableForTypeError() {
+    return firebaseServer.preconditionConflictError({
+        message: `The target StorageFileDocument is not available for processing.`,
+        code: firebase.STORAGE_FILE_PROCESSING_NOT_AVAILABLE_FOR_TYPE_ERROR_CODE
+    });
+}
+function storageFileAlreadyProcessedError() {
+    return firebaseServer.preconditionConflictError({
+        message: `The target StorageFileDocument has already finished processing.`,
+        code: firebase.STORAGE_FILE_ALREADY_PROCESSED_ERROR_CODE
+    });
+}
+function storageFileNotFlaggedForDeletionError() {
+    return firebaseServer.preconditionConflictError({
+        message: `The target StorageFileDocument is not flagged for deletion.`,
+        code: firebase.STORAGE_FILE_NOT_FLAGGED_FOR_DELETION_ERROR_CODE
+    });
+}
+function storageFileCannotBeDeletedYetError() {
+    return firebaseServer.preconditionConflictError({
+        message: `The target StorageFileDocument cannot be deleted yet.`,
+        code: firebase.STORAGE_FILE_CANNOT_BE_DELETED_YET_ERROR_CODE
+    });
+}
+function storageFileGroupQueuedForInitializationError() {
+    return firebaseServer.preconditionConflictError({
+        message: `The target StorageFileGroupDocument is queued for initialization.`,
+        code: firebase.STORAGE_FILE_GROUP_QUEUED_FOR_INITIALIZATION_ERROR_CODE
+    });
+}
+function createStorageFileGroupInputError() {
+    return firebaseServer.preconditionConflictError({
+        message: `The model or storageFileId is required for creating a StorageFileGroup.`,
+        code: firebase.STORAGE_FILE_GROUP_CREATE_INPUT_ERROR_CODE
+    });
+}
+
+/**
+ * Injection token for the BaseStorageFileServerActionsContext
+ */
+const BASE_STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN = 'BASE_STORAGE_FILE_SERVER_ACTION_CONTEXT';
+/**
+ * Injection token for the StorageFileServerActionsContext
+ */
+const STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN = 'STORAGE_FILE_SERVER_ACTION_CONTEXT';
+class StorageFileServerActions {
+}
+function storageFileServerActions(context) {
+    return {
+        createStorageFile: createStorageFileFactory(context),
+        initializeAllStorageFilesFromUploads: initializeAllStorageFilesFromUploadsFactory(context),
+        initializeStorageFileFromUpload: initializeStorageFileFromUploadFactory(context),
+        updateStorageFile: updateStorageFileFactory(context),
+        processAllQueuedStorageFiles: processAllQueuedStorageFilesFactory(context),
+        processStorageFile: processStorageFileFactory(context),
+        deleteAllQueuedStorageFiles: deleteAllQueuedStorageFilesFactory(context),
+        deleteStorageFile: deleteStorageFileFactory(context),
+        downloadStorageFile: downloadStorageFileFactory(context),
+        createStorageFileGroup: createStorageFileGroupFactory(context),
+        updateStorageFileGroup: updateStorageFileGroupFactory(context),
+        syncStorageFileWithGroups: syncStorageFileWithGroupsFactory(context),
+        syncAllFlaggedStorageFilesWithGroups: syncAllFlaggedStorageFilesWithGroupsFactory(context),
+        regenerateStorageFileGroupContent: regenerateStorageFileGroupContentFactory(context),
+        regenerateAllFlaggedStorageFileGroupsContent: regenerateAllFlaggedStorageFileGroupsContentFactory(context)
+    };
+}
+// MARK: Actions
+function createStorageFileFactory(context) {
+    const { storageFileCollection, firestoreContext, firebaseServerActionTransformFunctionFactory } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase.CreateStorageFileParams, async (params) => {
+        return async () => {
+            const storageFileDocument = null;
+            // TODO: check the file exists, and pull the metadata, and create the document
+            return storageFileDocument;
+        };
+    });
+}
+function initializeAllStorageFilesFromUploadsFactory(context) {
+    const { storageService, firebaseServerActionTransformFunctionFactory } = context;
+    const _initializeStorageFileFromUploadFile = _initializeStorageFileFromUploadFileFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.InitializeAllStorageFilesFromUploadsParams, async (params) => {
+        const { folderPath, maxFilesToInitialize, overrideUploadsFolderPath } = params;
+        const fullPath = util.mergeSlashPaths([overrideUploadsFolderPath ?? firebase.UPLOADS_FOLDER_PATH, folderPath]); // only targets the uploads folder
+        return async () => {
+            const folder = storageService.folder(fullPath);
+            const modelKeys = [];
+            let filesVisited = 0;
+            let initializationsSuccessCount = 0;
+            let initializationsFailureCount = 0;
+            await firebase.iterateStorageListFilesByEachFile({
+                folder,
+                includeNestedResults: true,
+                readItemsFromPageResult: (results) => results.result.files(),
+                iterateEachPageItem: async (file) => {
+                    const fileInstance = file.file();
+                    const initializeResult = await _initializeStorageFileFromUploadFile({ file: fileInstance }).catch(() => null);
+                    filesVisited++;
+                    if (initializeResult) {
+                        initializationsSuccessCount++;
+                        modelKeys.push(initializeResult.key);
+                    }
+                    else {
+                        initializationsFailureCount++;
+                    }
+                },
+                /**
+                 * The maximum number of files to initialize at once.
+                 */
+                iterateItemsLimit: maxFilesToInitialize ?? 1000,
+                /**
+                 * Iterate four separate pages at a time
+                 */
+                maxParallelPages: 4
+            });
+            const result = {
+                modelKeys,
+                filesVisited,
+                initializationsSuccessCount,
+                initializationsFailureCount
+            };
+            return result;
+        };
+    });
+}
+function _initializeStorageFileFromUploadFileFactory(context) {
+    const { firestoreContext, storageFileInitializeFromUploadService, notificationExpediteService } = context;
+    const processStorageFileInTransaction = _processStorageFileInTransactionFactory(context);
+    return async (input) => {
+        const { file, expediteProcessing } = input;
+        const { bucketId, pathString } = file.storagePath;
+        // file must exist
+        const exists = await file.exists();
+        if (!exists) {
+            throw uploadedFileDoesNotExistError();
+        }
+        // file must be allowed to be initialized
+        const isAllowedToBeInitialized = await storageFileInitializeFromUploadService.checkFileIsAllowedToBeInitialized(file);
+        if (!isAllowedToBeInitialized) {
+            throw uploadedFileIsNotAllowedToBeInitializedError();
+        }
+        let storageFileDocument;
+        let initializationResult;
+        let httpsError;
+        try {
+            initializationResult = await storageFileInitializeFromUploadService.initializeFromUpload({
+                file
+            });
+            async function deleteFile() {
+                try {
+                    // can now delete the uploaded file
+                    await file.delete();
+                }
+                catch (e) {
+                    // log errors here, but do nothing.
+                    console.error(`initializeStorageFileFromUpload(): Error deleting uploaded file (${bucketId}/${pathString})`, e);
+                }
+            }
+            switch (initializationResult.resultType) {
+                case 'success':
+                    await deleteFile();
+                    if (initializationResult.storageFileDocument) {
+                        storageFileDocument = initializationResult.storageFileDocument;
+                        // expedite processing if requested
+                        if (storageFileDocument != null && expediteProcessing) {
+                            const storageFile = await firebaseServer.assertSnapshotData(storageFileDocument);
+                            if (storageFile.ps === firebase.StorageFileProcessingState.QUEUED_FOR_PROCESSING) {
+                                const expediteInstance = notificationExpediteService.expediteInstance();
+                                await firestoreContext.runTransaction(async (transaction) => {
+                                    expediteInstance.initialize();
+                                    await processStorageFileInTransaction({
+                                        storageFileDocument: storageFileDocument,
+                                        expediteInstance
+                                    }, transaction);
+                                });
+                                await expediteInstance.send().catch(() => null);
+                            }
+                        }
+                    }
+                    else {
+                        httpsError = uploadedFileInitializationDiscardedError();
+                    }
+                    break;
+                case 'initializer_error':
+                    if (initializationResult.initializationError) {
+                        throw initializationResult.initializationError; // re-throw the encountered error
+                    }
+                    break;
+                case 'permanent_initializer_failure':
+                    // log the error
+                    if (initializationResult.initializationError) {
+                        console.warn(`initializeStorageFileFromUpload(): Permanent initializer failure for file (${bucketId}/${pathString})`, initializationResult.initializationError);
+                    }
+                    // delete the file
+                    await deleteFile();
+                    // return the error
+                    httpsError = uploadedFileInitializationFailedError({
+                        resultType: initializationResult.resultType,
+                        fileDeleted: true
+                    });
+                    break;
+                case 'no_determiner_match':
+                case 'no_initializer_configured':
+                default:
+                    httpsError = uploadedFileInitializationFailedError({
+                        resultType: initializationResult.resultType
+                    });
+                    console.error(`initializeStorageFileFromUpload(): Unknown file type (${initializationResult.resultType}) encountered for storage file "${bucketId}/${pathString}".`);
+                    break;
+            }
+        }
+        catch (e) {
+            console.error(`initializeStorageFileFromUpload(): Error while initializing storage file (${bucketId}/${pathString}) from upload`, e);
+            httpsError = uploadedFileInitializationFailedError({ resultType: 'initializer_error' });
+        }
+        if (httpsError) {
+            throw httpsError;
+        }
+        else if (!storageFileDocument) {
+            throw uploadedFileInitializationDiscardedError(); // throw again for redundancy
+        }
+        return storageFileDocument;
+    };
+}
+function initializeStorageFileFromUploadFactory(context) {
+    const { storageService, firebaseServerActionTransformFunctionFactory } = context;
+    const _initializeStorageFileFromUploadFile = _initializeStorageFileFromUploadFileFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.InitializeStorageFileFromUploadParams, async (params) => {
+        const { bucketId, pathString, expediteProcessing } = params;
+        return async () => {
+            const file = storageService.file(bucketId == null ? pathString : { bucketId, pathString });
+            return _initializeStorageFileFromUploadFile({ file, expediteProcessing });
+        };
+    });
+}
+function updateStorageFileFactory(context) {
+    const { storageFileCollection, firestoreContext, firebaseServerActionTransformFunctionFactory } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase.UpdateStorageFileParams, async (params) => {
+        const { sdat } = params;
+        return async (storageFileDocument) => {
+            const updateTemplate = {
+                sdat
+            };
+            await storageFileDocument.update(updateTemplate);
+            return storageFileDocument;
+        };
+    });
+}
+function updateStorageFileGroupFactory(context) {
+    const { firestoreContext, storageFileGroupCollection, firebaseServerActionTransformFunctionFactory } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase.UpdateStorageFileGroupParams, async (params) => {
+        const { entries } = params;
+        return async (storageFileGroupDocument) => {
+            await firestoreContext.runTransaction(async (transaction) => {
+                const storageFileGroupDocumentInTransaction = storageFileGroupCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(storageFileGroupDocument);
+                const storageFileGroup = await firebaseServer.assertSnapshotData(storageFileGroupDocumentInTransaction);
+                let f = undefined;
+                // update entries
+                if (entries?.length) {
+                    f = util.ModelRelationUtility.updateCollection(storageFileGroup.f, entries, {
+                        readKey: (x) => x.s,
+                        merge: (existing, update) => {
+                            const n = update.n === undefined ? existing.n : update.n;
+                            return {
+                                ...existing,
+                                n
+                            };
+                        }
+                    });
+                }
+                const updateTemplate = {
+                    f
+                };
+                await storageFileGroupDocumentInTransaction.update(updateTemplate);
+            });
+            return storageFileGroupDocument;
+        };
+    });
+}
+function processAllQueuedStorageFilesFactory(context) {
+    const { storageFileCollection, firebaseServerActionTransformFunctionFactory } = context;
+    const processStorageFile = processStorageFileFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.ProcessAllQueuedStorageFilesParams, async (params) => {
+        return async () => {
+            let storageFilesVisited = 0;
+            let storageFilesProcessStarted = 0;
+            let storageFilesFailedStarting = 0;
+            const proceessStorageFileParams = {
+                key: firebase.firestoreDummyKey()
+            };
+            const processStorageFileInstance = await processStorageFile(proceessStorageFileParams);
+            await firebase.iterateFirestoreDocumentSnapshotPairs({
+                documentAccessor: storageFileCollection.documentAccessor(),
+                iterateSnapshotPair: async (snapshotPair) => {
+                    storageFilesVisited++;
+                    const processStorageFileResult = await processStorageFileInstance(snapshotPair.document).catch(() => null);
+                    if (processStorageFileResult) {
+                        storageFilesProcessStarted++;
+                    }
+                    else {
+                        storageFilesFailedStarting++;
+                    }
+                },
+                constraintsFactory: () => firebase.storageFilesQueuedForProcessingQuery(),
+                queryFactory: storageFileCollection,
+                batchSize: undefined,
+                performTasksConfig: {
+                    maxParallelTasks: 10
+                }
+            });
+            const result = {
+                storageFilesVisited,
+                storageFilesProcessStarted,
+                storageFilesFailedStarting
+            };
+            return result;
+        };
+    });
+}
+function _processStorageFileInTransactionFactory(context) {
+    const { storageFileCollection, notificationCollectionGroup } = context;
+    return async (input, transaction) => {
+        const { storageFileDocument, storageFile: inputStorageFile, params, expediteInstance } = input;
+        const { checkRetryProcessing, forceRestartProcessing, processAgainIfSuccessful } = params ?? {};
+        const storageFileDocumentInTransaction = storageFileCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(storageFileDocument);
+        const storageFile = inputStorageFile ?? (await firebaseServer.assertSnapshotData(storageFileDocumentInTransaction));
+        async function beginProcessing(overrideExistingTask) {
+            const state = storageFile.fs;
+            // check the storageFile is in the OK state
+            if (state !== firebase.StorageFileState.OK) {
+                throw storageFileProcessingNotAllowedForInvalidStateError();
+            }
+            const createNotificationTaskResult = await firebase.createNotificationDocument({
+                context,
+                transaction,
+                template: firebase.storageFileProcessingNotificationTaskTemplate({
+                    storageFileDocument,
+                    overrideExistingTask
+                })
+            });
+            await storageFileDocumentInTransaction.update({
+                ps: firebase.StorageFileProcessingState.PROCESSING,
+                pat: new Date(), // set new processing start date
+                pcat: null, // clear processing completion date
+                pn: createNotificationTaskResult.notificationDocument.key
+            });
+            expediteInstance?.enqueueCreateResult(createNotificationTaskResult);
+        }
+        switch (storageFile.ps) {
+            case firebase.StorageFileProcessingState.INIT_OR_NONE:
+                // queue up for processing, unless it has no purpose
+                if (!storageFile.p) {
+                    throw storageFileProcessingNotAvailableForTypeError();
+                }
+                else {
+                    await beginProcessing(false);
+                }
+                break;
+            case firebase.StorageFileProcessingState.QUEUED_FOR_PROCESSING:
+                // begin processing
+                await beginProcessing(false);
+                break;
+            case firebase.StorageFileProcessingState.PROCESSING:
+                // check if the processing task is still running
+                const shouldCheckProcessing = !util.isThrottled(firebase.STORAGE_FILE_PROCESSING_STUCK_THROTTLE_CHECK_MS, storageFile.pat);
+                if (!storageFile.pn) {
+                    await beginProcessing(true); // if no processing task is set, restart processing to recover from the broken state
+                }
+                else {
+                    const { pn } = storageFile;
+                    const notificationDocument = notificationCollectionGroup.documentAccessorForTransaction(transaction).loadDocumentForKey(pn);
+                    if (checkRetryProcessing || shouldCheckProcessing) {
+                        const notification = await notificationDocument.snapshotData();
+                        if (!notification) {
+                            // the notification document is missing. Re-begin processing
+                            await beginProcessing(true);
+                        }
+                        else if (notification.d || forceRestartProcessing) {
+                            // if the notification is somehow in the done state but the StorageFile never got notified in the same transaction, requeue.
+                            await beginProcessing(true);
+                        }
+                        // NOTE: We could look at the state of the notification task more, but at this point the task is probably still valid and still running,
+                        // so we can only wait on it. In general if the task still exists and is not yet done, then we should wait on it as the
+                        // task running system should complete eventually by design.
+                    }
+                    else if (expediteInstance) {
+                        // enqueue the existing notification to be run in the expedite instance
+                        expediteInstance.enqueue(notificationDocument);
+                    }
+                }
+                break;
+            case firebase.StorageFileProcessingState.DO_NOT_PROCESS:
+                throw storageFileProcessingNotQueuedForProcessingError();
+            case firebase.StorageFileProcessingState.SUCCESS:
+                if (forceRestartProcessing || processAgainIfSuccessful) {
+                    await beginProcessing(true);
+                }
+                else {
+                    throw storageFileAlreadyProcessedError();
+                }
+                break;
+        }
+    };
+}
+function processStorageFileFactory(context) {
+    const { firestoreContext, notificationExpediteService, firebaseServerActionTransformFunctionFactory } = context;
+    const processStorageFileInTransaction = _processStorageFileInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.ProcessStorageFileParams, async (params) => {
+        const { runImmediately } = params;
+        return async (storageFileDocument) => {
+            const expediteInstance = notificationExpediteService.expediteInstance();
+            await firestoreContext.runTransaction(async (transaction) => {
+                expediteInstance.initialize();
+                await processStorageFileInTransaction({
+                    storageFileDocument,
+                    params,
+                    expediteInstance
+                }, transaction);
+            });
+            let expediteResult = null;
+            // expedite the task if requested
+            if (runImmediately) {
+                expediteResult = await expediteInstance.send().then((x) => x[0]);
+            }
+            const result = {
+                runImmediately: runImmediately ?? false,
+                expediteResult
+            };
+            return result;
+        };
+    });
+}
+function deleteAllQueuedStorageFilesFactory(context) {
+    const { storageFileCollection, firebaseServerActionTransformFunctionFactory } = context;
+    const deleteStorageFile = deleteStorageFileFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.DeleteAllQueuedStorageFilesParams, async (params) => {
+        return async () => {
+            let storageFilesVisited = 0;
+            let storageFilesDeleted = 0;
+            let storageFilesFailedDeleting = 0;
+            const deleteStorageFileInstance = await deleteStorageFile({
+                key: firebase.firestoreDummyKey()
+            });
+            await firebase.iterateFirestoreDocumentSnapshotPairs({
+                documentAccessor: storageFileCollection.documentAccessor(),
+                iterateSnapshotPair: async (snapshotPair) => {
+                    const { document: storageFileDocument } = snapshotPair;
+                    storageFilesVisited++;
+                    const deleteStorageFileResult = await deleteStorageFileInstance(storageFileDocument)
+                        .then(() => true)
+                        .catch(() => false);
+                    if (deleteStorageFileResult) {
+                        storageFilesDeleted++;
+                    }
+                    else {
+                        storageFilesFailedDeleting++;
+                    }
+                },
+                constraintsFactory: () => firebase.storageFilesQueuedForDeleteQuery(),
+                queryFactory: storageFileCollection,
+                batchSize: undefined,
+                performTasksConfig: {
+                    maxParallelTasks: 10
+                }
+            });
+            const result = {
+                storageFilesDeleted,
+                storageFilesFailedDeleting,
+                storageFilesVisited
+            };
+            return result;
+        };
+    });
+}
+function deleteStorageFileFactory(context) {
+    const { firestoreContext, storageService, storageFileCollection, firebaseServerActionTransformFunctionFactory } = context;
+    const syncStorageFileWithGroupsInTransaction = _syncStorageFileWithGroupsInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.DeleteStorageFileParams, async (params) => {
+        const { force } = params;
+        return async (inputStorageFileDocument) => {
+            await firestoreContext.runTransaction(async (transaction) => {
+                const storageFileDocument = await storageFileCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(inputStorageFileDocument);
+                const storageFile = await firebaseServer.assertSnapshotData(storageFileDocument);
+                const fileAccessor = storageService.file(storageFile);
+                if (!force) {
+                    if (!storageFile.sdat) {
+                        throw storageFileNotFlaggedForDeletionError();
+                    }
+                    else if (!util.isPast(storageFile.sdat)) {
+                        throw storageFileCannotBeDeletedYetError();
+                    }
+                }
+                // remove the storage file from any groups
+                await syncStorageFileWithGroupsInTransaction({ storageFileDocument, storageFile, force: true, removeAllStorageFileGroups: true }, transaction);
+                // delete the file
+                await fileAccessor.delete().catch(() => null);
+                // delete the document
+                await storageFileDocument.accessor.delete();
+            });
+        };
+    });
+}
+function downloadStorageFileFactory(context) {
+    const { storageService, firebaseServerActionTransformFunctionFactory, storageFileCollection } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase.DownloadStorageFileParams, async (params) => {
+        const { key: targetStorageFileDocumentKey, asAdmin, expiresAt, expiresIn: inputExpiresIn, responseDisposition, responseContentType } = params;
+        return async (storageFileDocument) => {
+            // if the StorageFileDocument was not provided, set it from the target key
+            if (!storageFileDocument) {
+                storageFileDocument = storageFileCollection.documentAccessor().loadDocumentForKey(targetStorageFileDocumentKey);
+            }
+            const storageFile = await firebaseServer.assertSnapshotData(storageFileDocument);
+            const fileAccessor = storageService.file(storageFile);
+            let result;
+            if (fileAccessor.getSignedUrl) {
+                const expiresIn = inputExpiresIn ?? util.MS_IN_MINUTE * 30;
+                const expires = util.expirationDetails({ defaultExpiresFromDateToNow: true, expiresAt, expiresIn });
+                let downloadUrlExpiresAt = expires.getExpirationDate();
+                // if they're not an admin, limit the expiration to a max of 30 days.
+                if (downloadUrlExpiresAt && !asAdmin) {
+                    const maxExpirationDate = dateFns.addDays(new Date(), 30);
+                    downloadUrlExpiresAt = date.findMinDate([downloadUrlExpiresAt, maxExpirationDate]);
+                }
+                const [downloadUrl, metadata] = await Promise.all([
+                    fileAccessor.getSignedUrl({
+                        action: 'read',
+                        expiresAt: downloadUrlExpiresAt ?? undefined,
+                        responseDisposition: responseDisposition ?? undefined, // can be set by anyone
+                        responseType: asAdmin ? (responseContentType ?? undefined) : undefined // can only be set by admins
+                    }),
+                    fileAccessor.getMetadata()
+                ]);
+                result = {
+                    url: downloadUrl,
+                    fileName: metadata.name ? util.slashPathDetails(metadata.name).end : undefined,
+                    mimeType: responseContentType ?? metadata.contentType,
+                    expiresAt: util.unixDateTimeSecondsNumberFromDate(downloadUrlExpiresAt)
+                };
+            }
+            else {
+                throw firebaseServer.internalServerError('Signed url function appears to not be avalable.');
+            }
+            return result;
+        };
+    });
+}
+function createStorageFileGroupInTransactionFactory(context) {
+    const { storageFileGroupCollection } = context;
+    return async (params, transaction) => {
+        const { now: inputNow, skipCreate, template } = params;
+        const now = inputNow ?? new Date();
+        const storageFileGroupDocument = firebase.loadStorageFileGroupDocumentForReferencePair(params, storageFileGroupCollection.documentAccessorForTransaction(transaction));
+        const storageFileGroupTemplate = {
+            o: firebase.firestoreDummyKey(), // set during initialization
+            cat: now,
+            s: true, // requires initialization
+            f: [],
+            ...template
+        };
+        if (!skipCreate) {
+            await storageFileGroupDocument.create(storageFileGroupTemplate);
+        }
+        return {
+            storageFileGroupTemplate,
+            storageFileGroupDocument
+        };
+    };
+}
+function createStorageFileGroupFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory } = context;
+    const createStorageFileGroupInTransaction = createStorageFileGroupInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.CreateStorageFileGroupParams, async (params) => {
+        const { model, storageFileId } = params;
+        const storageFileGroupRelatedModelKey = model ? model : storageFileId ? firebase.inferKeyFromTwoWayFlatFirestoreModelKey(storageFileId) : undefined;
+        if (!storageFileGroupRelatedModelKey) {
+            throw createStorageFileGroupInputError();
+        }
+        return async () => {
+            const result = await firestoreContext.runTransaction(async (transaction) => {
+                const { storageFileGroupDocument } = await createStorageFileGroupInTransaction({ storageFileGroupRelatedModelKey }, transaction);
+                return storageFileGroupDocument;
+            });
+            return result;
+        };
+    });
+}
+function _syncStorageFileWithGroupsInTransactionFactory(context) {
+    const { storageFileCollection, storageFileGroupCollection } = context;
+    const createStorageFileGroupInTransaction = createStorageFileGroupInTransactionFactory(context);
+    return async (input, transaction) => {
+        const { storageFileDocument, storageFile: inputStorageFile, force, removeAllStorageFileGroups, skipStorageFileUpdate } = input;
+        const storageFileDocumentInTransaction = storageFileCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(storageFileDocument);
+        const storageFileGroupDocumentAccessor = storageFileGroupCollection.documentAccessorForTransaction(transaction);
+        const storageFile = inputStorageFile ?? (await firebaseServer.assertSnapshotData(storageFileDocumentInTransaction));
+        if (!storageFile.gs && !force) {
+            throw storageFileNotFlaggedForGroupsSyncError();
+        }
+        const g = storageFile.g ?? [];
+        const storageFileGroupDocuments = firebase.loadDocumentsForIds(storageFileGroupDocumentAccessor, g);
+        const storageFileGroupPairs = await firebase.getDocumentSnapshotDataPairs(storageFileGroupDocuments);
+        let storageFilesGroupsCreated = 0;
+        let storageFilesGroupsUpdated = 0;
+        await util.performAsyncTasks(storageFileGroupPairs, async (storageFileGroupPair) => {
+            const { data: storageFileGroup, document: storageFileGroupDocument } = storageFileGroupPair;
+            const existsInStorageFileGroup = storageFileGroup?.f.some((x) => x.s === storageFileDocument.id);
+            const change = removeAllStorageFileGroups ? (existsInStorageFileGroup ? 'remove' : undefined) : !existsInStorageFileGroup ? 'add' : undefined;
+            switch (change) {
+                case 'add':
+                    // add it if it doesn't exist
+                    const createTemplate = firebase.calculateStorageFileGroupEmbeddedFileUpdate({
+                        storageFileGroup: storageFileGroup ?? { f: [] },
+                        insert: [
+                            {
+                                s: storageFileDocument.id
+                            }
+                        ],
+                        allowRecalculateRegenerateFlag: false
+                    });
+                    if (!storageFileGroup) {
+                        // if the group does not exist, then create it
+                        await createStorageFileGroupInTransaction({ storageFileGroupDocument, template: createTemplate }, transaction);
+                        storageFilesGroupsCreated += 1;
+                    }
+                    else {
+                        // if the group exists, then update it
+                        await storageFileGroupDocument.update(createTemplate);
+                        storageFilesGroupsUpdated += 1;
+                    }
+                    break;
+                case 'remove':
+                    // remove it
+                    const removeTemplate = firebase.calculateStorageFileGroupEmbeddedFileUpdate({
+                        storageFileGroup: storageFileGroup ?? { f: [] },
+                        remove: [storageFileDocument.id]
+                    });
+                    await storageFileGroupDocument.update(removeTemplate);
+                    storageFilesGroupsUpdated += 1;
+                    break;
+            }
+        });
+        const result = {
+            storageFilesGroupsCreated,
+            storageFilesGroupsUpdated
+        };
+        // update the storage file to no longer be flagged for sync
+        if (!skipStorageFileUpdate) {
+            await storageFileDocumentInTransaction.update({
+                gs: false
+            });
+        }
+        return result;
+    };
+}
+function syncStorageFileWithGroupsFactory(context) {
+    const { firestoreContext, storageFileCollection, storageFileGroupCollection, firebaseServerActionTransformFunctionFactory } = context;
+    const syncStorageFileWithGroupsInTransaction = _syncStorageFileWithGroupsInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.SyncStorageFileWithGroupsParams, async (params) => {
+        const { force } = params;
+        return async (storageFileDocument) => {
+            return firestoreContext.runTransaction(async (transaction) => syncStorageFileWithGroupsInTransaction({ storageFileDocument, force }, transaction));
+        };
+    });
+}
+function syncAllFlaggedStorageFilesWithGroupsFactory(context) {
+    const { firebaseServerActionTransformFunctionFactory, storageFileCollection } = context;
+    const syncStorageFileWithGroups = syncStorageFileWithGroupsFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.SyncAllFlaggedStorageFilesWithGroupsParams, async (params) => {
+        return async () => {
+            const syncStorageFileWithGroupsInstance = await syncStorageFileWithGroups({
+                key: firebase.firestoreDummyKey(),
+                force: true // force anyways; they should all be flagged for sync when the query hits
+            });
+            let storageFilesSynced = 0;
+            let storageFilesGroupsCreated = 0;
+            let storageFilesGroupsUpdated = 0;
+            await firebase.iterateFirestoreDocumentSnapshotPairBatches({
+                documentAccessor: storageFileCollection.documentAccessor(),
+                iterateSnapshotPairsBatch: async (snapshotPairBatch) => {
+                    // only sync StorageFiles that are flagged for sync
+                    await util.runAsyncTasksForValues(snapshotPairBatch.filter((x) => x.data.gs), async (snapshotPair) => {
+                        const { document: storageFileDocument } = snapshotPair;
+                        const result = await syncStorageFileWithGroupsInstance(storageFileDocument);
+                        storageFilesSynced += 1;
+                        storageFilesGroupsCreated += result.storageFilesGroupsCreated;
+                        storageFilesGroupsUpdated += result.storageFilesGroupsUpdated;
+                    }, {
+                        maxParallelTasks: 10, // can update 10 storageFiles/Groups at the same time
+                        nonConcurrentTaskKeyFactory: (x) => x.data.g // do not update the same group at the same time
+                    });
+                },
+                queryFactory: storageFileCollection,
+                constraintsFactory: () => firebase.storageFileFlaggedForSyncWithGroupsQuery(),
+                performTasksConfig: {
+                    sequential: true // run batches sequentially to avoid contention in updating a StorageFileGroup
+                },
+                totalSnapshotsLimit: 1000,
+                limitPerCheckpoint: 100
+            });
+            const result = {
+                storageFilesSynced,
+                storageFilesGroupsCreated,
+                storageFilesGroupsUpdated
+            };
+            return result;
+        };
+    });
+}
+function regenerateStorageFileGroupContentFactory(context) {
+    const { firestoreContext, storageService, storageFileCollection, storageFileGroupCollection, firebaseServerActionTransformFunctionFactory } = context;
+    const processStorageFileInTransaction = _processStorageFileInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.RegenerateStorageFileGroupContentParams, async (params) => {
+        const { force } = params;
+        const createStorageFileDocumentPair = firebase.createStorageFileDocumentPairFactory({
+            defaultCreationType: firebase.StorageFileCreationType.FOR_STORAGE_FILE_GROUP
+        });
+        return async (storageFileGroupDocument) => {
+            return firestoreContext.runTransaction(async (transaction) => {
+                const storageFileGroupDocumentInTransaction = storageFileGroupCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(storageFileGroupDocument);
+                const storageFileGroup = await firebaseServer.assertSnapshotData(storageFileGroupDocumentInTransaction);
+                const storageFileDocumentAccessor = storageFileCollection.documentAccessorForTransaction(transaction);
+                const { o, zsf, s } = storageFileGroup;
+                // must not be queued for initialization
+                if (s) {
+                    throw storageFileGroupQueuedForInitializationError();
+                }
+                const existingZipStorageFileDocument = zsf ? storageFileDocumentAccessor.loadDocumentForId(zsf) : undefined;
+                const [existingZipStorageFilePair] = await Promise.all([existingZipStorageFileDocument ? firebase.getDocumentSnapshotDataPair(existingZipStorageFileDocument) : undefined]);
+                let contentStorageFilesFlaggedForProcessing = 0;
+                const updateTemplate = {
+                    re: false // clear the regeneration flag
+                };
+                // For each content type, create/update/flag the StorageFile for processing that type
+                const { regenerateZip } = firebase.calculateStorageFileGroupRegeneration({ storageFileGroup, force });
+                if (regenerateZip) {
+                    // check that the storageFile exists, and if it doesn't, create a new one
+                    if (!existingZipStorageFilePair?.data) {
+                        const zipStorageFile = storageService.file(firebase.storageFileGroupZipFileStoragePath(storageFileGroupDocument.id));
+                        // create a new StorageFile
+                        const { storageFileDocument } = await createStorageFileDocumentPair({
+                            storagePathRef: zipStorageFile,
+                            accessor: storageFileDocumentAccessor,
+                            parentStorageFileGroup: storageFileGroupDocument,
+                            purpose: firebase.STORAGE_FILE_GROUP_ZIP_STORAGE_FILE_PURPOSE,
+                            shouldBeProcessed: true,
+                            ownershipKey: o,
+                            metadata: {
+                                sfg: storageFileGroupDocument.id
+                            }
+                        });
+                        updateTemplate.zsf = storageFileDocument.id;
+                    }
+                    else {
+                        // flag it for processing again
+                        await processStorageFileInTransaction({ params: { processAgainIfSuccessful: true }, storageFileDocument: existingZipStorageFilePair.document, storageFile: existingZipStorageFilePair.data }, transaction);
+                    }
+                    contentStorageFilesFlaggedForProcessing += 1;
+                }
+                // update the StorageFileGroup
+                await storageFileGroupDocumentInTransaction.update(updateTemplate);
+                const result = {
+                    contentStorageFilesFlaggedForProcessing
+                };
+                return result;
+            });
+        };
+    });
+}
+function regenerateAllFlaggedStorageFileGroupsContentFactory(context) {
+    const { firebaseServerActionTransformFunctionFactory, storageFileGroupCollection } = context;
+    const regenerateStorageFileGroupContent = regenerateStorageFileGroupContentFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.RegenerateAllFlaggedStorageFileGroupsContentParams, async (params) => {
+        return async () => {
+            const regenerateStorageFileGroupContentInstance = await regenerateStorageFileGroupContent({
+                key: firebase.firestoreDummyKey()
+            });
+            let storageFileGroupsUpdated = 0;
+            let contentStorageFilesFlaggedForProcessing = 0;
+            await firebase.iterateFirestoreDocumentSnapshotPairs({
+                documentAccessor: storageFileGroupCollection.documentAccessor(),
+                iterateSnapshotPair: async (snapshotPair) => {
+                    const { data: storageFileGroup } = snapshotPair;
+                    if (!storageFileGroup.s) {
+                        const result = await regenerateStorageFileGroupContentInstance(snapshotPair.document);
+                        storageFileGroupsUpdated += 1;
+                        contentStorageFilesFlaggedForProcessing += result.contentStorageFilesFlaggedForProcessing;
+                    }
+                },
+                queryFactory: storageFileGroupCollection,
+                constraintsFactory: () => firebase.storageFileGroupsFlaggedForContentRegenerationQuery(),
+                performTasksConfig: {
+                    maxParallelTasks: 10
+                },
+                totalSnapshotsLimit: 1000,
+                limitPerCheckpoint: 100
+            });
+            const result = {
+                storageFileGroupsUpdated,
+                contentStorageFilesFlaggedForProcessing
+            };
+            return result;
+        };
+    });
+}
+
+// MARK: StorageFileInitServerActionsContextConfig
+/**
+ * Token to access/override the StorageFileTemplateService's defaults records.
+ */
+const STORAGE_FILE_INIT_SERVER_ACTIONS_CONTEXT_CONFIG_TOKEN = 'STORAGE_FILE_INIT_SERVER_ACTIONS_CONTEXT_CONFIG';
+const MAKE_TEMPLATE_FOR_STORAGEFILE_RELATED_MODEL_INITIALIZATION_FUNCTION_DELETE_RESPONSE = false;
+class StorageFileInitServerActions {
+}
+function storageFileInitServerActions(context) {
+    return {
+        initializeStorageFileGroup: initializeStorageFileGroupFactory(context),
+        initializeAllApplicableStorageFileGroups: initializeAllApplicableStorageFileGroupsFactory(context)
+    };
+}
+async function initializeStorageFileModelInTransaction(input) {
+    const { makeTemplateFunction, throwErrorIfAlreadyInitialized, transaction, document: documentInTransaction, data: storageFileModel } = input;
+    let initialized = false;
+    const alreadyInitialized = !storageFileModel.s;
+    if (!alreadyInitialized) {
+        const flatModelKey = documentInTransaction.id;
+        const modelKey = firebase.inferKeyFromTwoWayFlatFirestoreModelKey(flatModelKey);
+        const modelCollectionName = firebase.firestoreModelKeyCollectionName(modelKey);
+        const input = {
+            transaction,
+            flatModelKey,
+            modelKey,
+            collectionName: modelCollectionName
+        };
+        const template = await makeTemplateFunction(input);
+        if (template === false) {
+            await documentInTransaction.accessor.delete();
+        }
+        else if (template == null) {
+            await documentInTransaction.update({
+                s: false, // set false when "f" is set true
+                fi: true
+            });
+        }
+        else {
+            initialized = true;
+            await documentInTransaction.update({
+                //
+                ...template,
+                m: undefined, // should not be changed
+                s: null, // is now initialized.
+                fi: false // set false
+            });
+        }
+    }
+    else if (throwErrorIfAlreadyInitialized) {
+        throw storageFileModelAlreadyInitializedError();
+    }
+    return {
+        initialized,
+        alreadyInitialized
+    };
+}
+function initializeStorageFileGroupInTransactionFactory(context) {
+    const { storageFileGroupCollection, makeTemplateForStorageFileGroupInitialization } = context;
+    return async (params, storageFileGroupDocument, transaction) => {
+        const { throwErrorIfAlreadyInitialized } = params;
+        const storageFileGroupDocumentInTransaction = storageFileGroupCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(storageFileGroupDocument);
+        const storageFileGroup = await firebaseServer.assertSnapshotData(storageFileGroupDocumentInTransaction);
+        return initializeStorageFileModelInTransaction({
+            makeTemplateFunction: async (input) => {
+                const baseTemplate = (await makeTemplateForStorageFileGroupInitialization(input));
+                // template can only define o and any StorageFileGroupContentFlagsData properties
+                return {
+                    o: baseTemplate.o,
+                    z: baseTemplate.z,
+                    re: true // always flag for content regeneration
+                };
+            },
+            throwErrorIfAlreadyInitialized,
+            transaction,
+            document: storageFileGroupDocumentInTransaction,
+            data: storageFileGroup
+        });
+    };
+}
+function initializeStorageFileGroupFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory } = context;
+    const initializeStorageFileGroupInTransaction = initializeStorageFileGroupInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.InitializeStorageFileModelParams, async (params) => {
+        return async (storageFileGroupDocument) => {
+            await firestoreContext.runTransaction((transaction) => initializeStorageFileGroupInTransaction(params, storageFileGroupDocument, transaction));
+            return storageFileGroupDocument;
+        };
+    });
+}
+function initializeAllApplicableStorageFileGroupsFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory, storageFileGroupCollection } = context;
+    const initializeStorageFileGroupInTransaction = initializeStorageFileGroupInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase.InitializeAllApplicableStorageFileGroupsParams, async () => {
+        return async () => {
+            let storageFileGroupsVisited = 0;
+            let storageFileGroupsSucceeded = 0;
+            let storageFileGroupsFailed = 0;
+            let storageFileGroupsAlreadyInitialized = 0;
+            const initializeStorageFileGroupParams = { key: firebase.firestoreDummyKey(), throwErrorIfAlreadyInitialized: false };
+            async function initializeStorageFileGroups() {
+                const query = storageFileGroupCollection.queryDocument(firebase.storageFileGroupsFlaggedForNeedsInitializationQuery());
+                const storageFileGroupDocuments = await query.getDocs();
+                const result = await util.performAsyncTasks(storageFileGroupDocuments, async (storageFileGroupDocument) => {
+                    return firestoreContext.runTransaction((transaction) => initializeStorageFileGroupInTransaction(initializeStorageFileGroupParams, storageFileGroupDocument, transaction));
+                }, {
+                    maxParallelTasks: 5
+                });
+                return result;
+            }
+            while (true) {
+                const initializeStorageFileGroupsResults = await initializeStorageFileGroups();
+                initializeStorageFileGroupsResults.results.forEach((x) => {
+                    const result = x[1];
+                    if (result.alreadyInitialized) {
+                        storageFileGroupsAlreadyInitialized += 1;
+                    }
+                    else if (result.initialized) {
+                        storageFileGroupsSucceeded += 1;
+                    }
+                    else {
+                        storageFileGroupsFailed += 1;
+                    }
+                });
+                const found = initializeStorageFileGroupsResults.results.length;
+                storageFileGroupsVisited += found;
+                if (!found) {
+                    break;
+                }
+            }
+            const result = {
+                storageFileGroupsVisited,
+                storageFileGroupsSucceeded,
+                storageFileGroupsFailed,
+                storageFileGroupsAlreadyInitialized
+            };
+            return result;
+        };
+    });
+}
+
+/**
+ * Service dedicated to initializing a StorageFileDocument value from an uploaded file.
+ */
+class StorageFileInitializeFromUploadService {
+}
+
+// MARK: Provider Factories
+function storageFileServerActionsContextFactory(context, storageFileInitializeFromUploadService) {
+    return { ...context, storageFileInitializeFromUploadService };
+}
+function storageFileServerActionsFactory(context) {
+    return storageFileServerActions(context);
+}
+function storageFileInitServerActionsFactory(context, storageFileInitServerActionsContextConfig) {
+    return storageFileInitServerActions({
+        ...context,
+        ...storageFileInitServerActionsContextConfig
+    });
+}
+/**
+ * Convenience function used to generate ModuleMetadata for an app's StorageFileModule.
+ *
+ * By default this module exports:
+ * - StorageFileServerActionContext (STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN)
+ * - StorageFileServerActions
+ * - StorageFileInitServerActions
+ *
+ * Be sure the class that delares the module using this function also extends AbstractAppStorageFileModule.
+ *
+ * @param provide
+ * @param useFactory
+ * @returns
+ */
+function appStorageFileModuleMetadata(config$1) {
+    const { dependencyModule, imports, exports: exports$1, providers } = config$1;
+    const dependencyModuleImport = dependencyModule ? [dependencyModule] : [];
+    return {
+        imports: [config.ConfigModule, ...dependencyModuleImport, ...(imports ?? [])],
+        exports: [STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN, StorageFileServerActions, StorageFileInitServerActions, ...(exports$1 ?? [])],
+        providers: [
+            {
+                provide: STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN,
+                useFactory: storageFileServerActionsContextFactory,
+                inject: [BASE_STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN, StorageFileInitializeFromUploadService]
+            },
+            {
+                provide: StorageFileServerActions,
+                useFactory: storageFileServerActionsFactory,
+                inject: [STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN]
+            },
+            {
+                provide: StorageFileInitServerActions,
+                useFactory: storageFileInitServerActionsFactory,
+                inject: [STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN, STORAGE_FILE_INIT_SERVER_ACTIONS_CONTEXT_CONFIG_TOKEN]
+            },
+            ...(providers ?? [])
+        ]
+    };
+}
+
+/**
+ * Performs a query and flags the matching StorageFiles for deletion.
+ *
+ * @param input The input for the query and flagging.
+ * @returns The result of the query and flagging.
+ */
+async function queryAndFlagStorageFilesForDelete(input) {
+    const { storageFileCollection, constraints, queuedForDeleteTime: inputQueueForDeleteTime, skipDeleteForKeys } = input;
+    const queuedForDeleteTime = inputQueueForDeleteTime ?? true;
+    const skipDeleteSet = new Set(util.asArray(skipDeleteForKeys));
+    let visitedCount = 0;
+    let queuedForDeleteCount = 0;
+    await firebase.iterateFirestoreDocumentSnapshotPairs({
+        documentAccessor: storageFileCollection.documentAccessor(),
+        iterateSnapshotPair: async (snapshotPair) => {
+            const { document, data: storageFile } = snapshotPair;
+            if (!storageFile.sdat && !skipDeleteSet.has(storageFile.key)) {
+                await document.update(markStorageFileForDeleteTemplate(queuedForDeleteTime));
+                queuedForDeleteCount++;
+            }
+            visitedCount++;
+        },
+        queryFactory: storageFileCollection,
+        constraintsFactory: () => constraints,
+        batchSize: undefined,
+        performTasksConfig: {
+            maxParallelTasks: 20
+        }
+    });
+    return {
+        visitedCount,
+        queuedForDeleteCount
+    };
+}
+/**
+ * Creates a template for updating a StorageFile to be queued for deletion at the input time.
+ *
+ * @param queueForDeleteTime When to delete the StorageFile. If true or unset, the StorageFile will be flagged to be deleted immediately.
+ * @returns The update template for the StorageFile.
+ */
+function markStorageFileForDeleteTemplate(queueForDeleteTime) {
+    const updateTemplate = {
+        sdat: queueForDeleteTime === true || queueForDeleteTime == null ? new Date() : util.dateFromDateOrTimeMillisecondsNumber(queueForDeleteTime),
+        fs: firebase.StorageFileState.QUEUED_FOR_DELETE
+    };
+    return updateTemplate;
+}
+
+const storageFileProcessingNotificationTaskHandlerDefaultCleanup = () => {
+    return {
+        cleanupSuccess: true,
+        nextProcessingState: firebase.StorageFileProcessingState.SUCCESS,
+        queueForDelete: false // do not queue for delete automatically
+    };
+};
+/**
+ * Creates a NotificationTaskServiceTaskHandlerConfig that handles the StorageFileProcessingNotificationTask.
+ */
+function storageFileProcessingNotificationTaskHandler(config) {
+    const { processors: inputProcessors, storageAccessor, storageFileFirestoreCollections, allStorageFileGroupProcessorConfig } = config;
+    const storageFileDocumentAccessor = storageFileFirestoreCollections.storageFileCollection.documentAccessor();
+    const makeFileDetailsAccessor = firebase.storedFileReaderFactory();
+    const defaultCleanup = storageFileProcessingNotificationTaskHandlerDefaultCleanup;
+    const processors = [...inputProcessors];
+    if (allStorageFileGroupProcessorConfig !== false) {
+        const storageFileGroupProcessors = allStorageFileGroupStorageFileProcessingPurposeSubtaskProcessors({
+            ...allStorageFileGroupProcessorConfig,
+            storageFileFirestoreCollections,
+            storageAccessor
+        });
+        util.pushArrayItemsIntoArray(processors, storageFileGroupProcessors);
+    }
+    return notificationTaskSubtaskNotificationTaskHandlerFactory({
+        taskType: firebase.STORAGE_FILE_PROCESSING_NOTIFICATION_TASK_TYPE,
+        subtaskHandlerFunctionName: 'storageFileProcessingNotificationTaskHandler',
+        inputFunction: async (data) => {
+            const storageFileDocument = await storageFileDocumentAccessor.loadDocumentForId(data.storageFile);
+            const loadStorageFile = util.cachedGetter(async () => {
+                const storageFile = await firebase.getDocumentSnapshotData(storageFileDocument, true);
+                if (!storageFile) {
+                    throw notificationTaskSubTaskMissingRequiredDataTermination();
+                }
+                return storageFile;
+            });
+            let purpose = data?.p;
+            if (!purpose) {
+                // attempt to load the purpose from the storage file, if it exists.
+                purpose = (await loadStorageFile().then((x) => x.p));
+            }
+            let storagePath;
+            if (data.storagePath) {
+                storagePath = data.storagePath;
+            }
+            else {
+                storagePath = await loadStorageFile().then((x) => ({ bucketId: x.bucketId, pathString: x.pathString }));
+            }
+            const file = storageAccessor.file(storagePath);
+            const fileDetailsAccessor = makeFileDetailsAccessor(file);
+            const input = {
+                target: purpose,
+                loadStorageFile,
+                fileDetailsAccessor,
+                storageFileDocument
+            };
+            return input;
+        },
+        buildUpdateMetadata: (baseUpdateMetadata, input) => {
+            const { target } = input;
+            return {
+                ...baseUpdateMetadata,
+                // always re-copy the target/storagePath for the next run so StorageFile does not have to be reloaded
+                p: target,
+                storagePath: firebase.copyStoragePath(input.fileDetailsAccessor.input)
+            };
+        },
+        defaultCleanup,
+        cleanupFunction: async function (input, cleanupInstructions) {
+            const { storageFileDocument } = input;
+            const { nextProcessingState, queueForDelete, flagResyncWithStorageFileGroups: syncWithStorageFileGroups } = cleanupInstructions;
+            let updateTemplate = {
+                ps: nextProcessingState ?? firebase.StorageFileProcessingState.SUCCESS,
+                pcat: new Date(), // set new cleanup/completion date
+                pn: null // clear reference
+            };
+            const shouldQueueForDelete = queueForDelete != null && queueForDelete !== false;
+            if (shouldQueueForDelete) {
+                updateTemplate = {
+                    ...updateTemplate,
+                    ...markStorageFileForDeleteTemplate(queueForDelete)
+                };
+            }
+            else if (syncWithStorageFileGroups) {
+                // resync with storage file groups
+                updateTemplate.gs = true;
+            }
+            await storageFileDocument.update(updateTemplate);
+            return firebase.notificationTaskComplete();
+        }
+    })({
+        ...config,
+        processors
+    });
+}
+function allStorageFileGroupStorageFileProcessingPurposeSubtaskProcessors(config) {
+    const { excludeZipProcessing } = config;
+    const processors = [];
+    if (!excludeZipProcessing) {
+        processors.push(storageFileGroupZipStorageFileProcessingPurposeSubtaskProcessor(config));
+    }
+    return processors;
+}
+function storageFileGroupZipStorageFileProcessingPurposeSubtaskProcessor(config) {
+    const { storageFileFirestoreCollections, storageAccessor, zip } = config;
+    const { storageFileCollection, storageFileGroupCollection } = storageFileFirestoreCollections;
+    const { maxNumberOfFilesToZipInParallel: inputMaxNumberOfFilesToZipInParallel, zipFileDisplayNameFunctionFactory: inputZipFileDisplayNameFunctionFactory, configureZipInfoJson: inputConfigureZipInfoJson, configureZipArchiverOptions: inputConfigureZipArchiverOptions, finalizeZipArchive } = zip ?? {};
+    const maxNumberOfFilesToZipInParallel = inputMaxNumberOfFilesToZipInParallel ?? 3;
+    const appendZipInfoJson = inputConfigureZipInfoJson !== false;
+    const configureZipArchiverOptions = inputConfigureZipArchiverOptions ?? (() => ({ zlib: { level: 9 } }));
+    const configureZipInfoJson = (appendZipInfoJson ? inputConfigureZipInfoJson : undefined) ?? util.MAP_IDENTITY;
+    const zipFileDisplayNameFunctionFactory = inputZipFileDisplayNameFunctionFactory ?? (() => () => null);
+    const storageFileGroupZipProcessorConfig = {
+        target: firebase.STORAGE_FILE_GROUP_ZIP_STORAGE_FILE_PURPOSE,
+        cleanup: zip?.cleanup,
+        flow: [
+            {
+                subtask: firebase.STORAGE_FILE_GROUP_ZIP_STORAGE_FILE_PURPOSE_CREATE_ZIP_SUBTASK,
+                fn: async (input) => {
+                    const { storageFileDocument, fileDetailsAccessor } = input;
+                    const storageFile = await input.loadStorageFile();
+                    const storageFileMetadata = storageFile.d;
+                    const storageFileGroupId = storageFileMetadata?.sfg;
+                    let result;
+                    async function flagStorageFileForDeletion() {
+                        await storageFileDocument.update(markStorageFileForDeleteTemplate());
+                        return firebase.notificationTaskComplete(); // skip cleanup step
+                    }
+                    if (storageFileGroupId) {
+                        const storageFileGroupDocument = storageFileGroupCollection.documentAccessor().loadDocumentForId(storageFileGroupId);
+                        const storageFileGroup = await storageFileGroupDocument.snapshotData();
+                        if (storageFileGroup) {
+                            const embeddedFilesMap = new Map(storageFileGroup.f.map((x) => [x.s, x]));
+                            const storageFileIdsToZip = storageFileGroup.f.map((x) => x.s);
+                            const storageFilesToZip = firebase.loadDocumentsForIds(storageFileCollection.documentAccessor(), storageFileIdsToZip);
+                            const storageFileDataPairsToZip = await firebase.getDocumentSnapshotDataPairs(storageFilesToZip);
+                            const zipFileDisplayNameFunction = await zipFileDisplayNameFunctionFactory({ storageFileGroup, storageFileGroupDocument });
+                            let flagCleanFileAssociations = undefined;
+                            // create a new file
+                            const zipFileAccessor = storageAccessor.file(fileDetailsAccessor.input);
+                            if (zipFileAccessor.uploadStream && zipFileAccessor.getStream) {
+                                const uploadStream = zipFileAccessor.uploadStream({
+                                    contentType: util.ZIP_FILE_MIME_TYPE
+                                });
+                                const startedAt = new Date();
+                                const archiverOptions = await configureZipArchiverOptions({ input, storageFileGroup });
+                                const newArchive = archiver('zip', archiverOptions);
+                                // pipe the archive to the upload stream
+                                newArchive.pipe(uploadStream, { end: true });
+                                // upload each of the files to the archive
+                                await util.performAsyncTasks(storageFileDataPairsToZip, async (storageFileDataPair) => {
+                                    const { data: storageFile } = storageFileDataPair;
+                                    if (storageFile) {
+                                        const { n: storageFileDisplayName } = storageFile;
+                                        // make sure it references the storage file group
+                                        const referencesStorageFileGroup = storageFile.g.some((x) => x === storageFileGroupId);
+                                        if (referencesStorageFileGroup) {
+                                            const fileAccessor = storageAccessor.file(storageFile);
+                                            const metadata = await fileAccessor.getMetadata().catch(() => null);
+                                            if (metadata) {
+                                                const fileSlashPathDetails = util.slashPathDetails(metadata.name);
+                                                const storageFileGroupEmbeddedFile = embeddedFilesMap.get(storageFile.id);
+                                                const { n: embeddedFileNameOverride } = storageFileGroupEmbeddedFile;
+                                                const nameFromFactory = await zipFileDisplayNameFunction({ metadata, fileAccessor, storageFile, storageFileDocument, storageFileGroupEmbeddedFile });
+                                                let untypedName = nameFromFactory || storageFileDisplayName || embeddedFileNameOverride || fileSlashPathDetails.fileName;
+                                                let extension;
+                                                if (fileSlashPathDetails.typedFileExtension) {
+                                                    extension = fileSlashPathDetails.typedFileExtension;
+                                                }
+                                                else if (metadata.contentType) {
+                                                    extension = util.documentFileExtensionForMimeType(metadata.contentType);
+                                                }
+                                                // set the default name if still unset
+                                                untypedName = untypedName || `sf_${storageFile.id}`;
+                                                const name = extension ? `${untypedName}.${extension}` : untypedName;
+                                                const fileStream = fileAccessor.getStream();
+                                                await util.useCallback((x) => {
+                                                    // append the file to the archive
+                                                    newArchive.append(fileStream, {
+                                                        name
+                                                    });
+                                                    // if the stream errors, call back
+                                                    fileStream.on('error', (e) => x(e));
+                                                    // when the stream finishes, call back
+                                                    fileStream.on('finish', () => x());
+                                                });
+                                            }
+                                            else {
+                                                flagCleanFileAssociations = true;
+                                            }
+                                        }
+                                        else {
+                                            flagCleanFileAssociations = true;
+                                        }
+                                    }
+                                }, {
+                                    maxParallelTasks: maxNumberOfFilesToZipInParallel
+                                });
+                                const finishedAt = new Date();
+                                // create the info.json file
+                                if (appendZipInfoJson) {
+                                    const infoJson = await configureZipInfoJson({
+                                        sfg: storageFileGroupId,
+                                        sf: storageFileIdsToZip,
+                                        s: startedAt.toISOString(),
+                                        f: finishedAt.toISOString()
+                                    });
+                                    let infoJsonString;
+                                    try {
+                                        infoJsonString = JSON.stringify(infoJson);
+                                    }
+                                    catch (e) {
+                                        console.error('storageFileGroupZipStorageFileProcessingPurposeSubtaskProcessor(): Failed to convert the info json to a string. Check your custom configureInfoJson() function.', e);
+                                    }
+                                    if (infoJsonString) {
+                                        newArchive.append(infoJsonString, {
+                                            name: firebase.STORAGE_FILE_GROUP_ZIP_INFO_JSON_FILE_NAME
+                                        });
+                                    }
+                                }
+                                // perform any other tasks using the zip archive
+                                if (finalizeZipArchive) {
+                                    await finalizeZipArchive({
+                                        input,
+                                        storageFileGroup,
+                                        archive: newArchive
+                                    });
+                                }
+                                // finalize the archive
+                                await newArchive.finalize();
+                                // update the StorageFileGroup
+                                await storageFileGroupDocument.update({
+                                    zat: finishedAt,
+                                    c: flagCleanFileAssociations
+                                });
+                                // schedule/run the cleanup task
+                                result = firebase.notificationSubtaskComplete({
+                                    canRunNextCheckpoint: true
+                                });
+                            }
+                            else {
+                                // uploadStream is not available for some reason? Should never occur.
+                                console.warn('storageFileGroupZipStorageFileProcessingPurposeSubtaskProcessor(): uploadStream is not available for some reason while creating a new zip.');
+                                result = firebase.notificationTaskDelayRetry(util.MS_IN_HOUR);
+                            }
+                        }
+                        else {
+                            // storage file group no longer exists. Flag the StorageFile for deletion.
+                            result = await flagStorageFileForDeletion();
+                        }
+                    }
+                    else {
+                        // improperly configured StorageFile for this type. Flag the StorageFile for deletion.
+                        result = await flagStorageFileForDeletion();
+                    }
+                    return result;
+                }
+            }
+        ]
+    };
+    return storageFileGroupZipProcessorConfig;
+}
+
+function storageFileInitializeFromUploadServiceInitializerResultPermanentFailure(error, createdFile) {
+    return {
+        error,
+        permanentFailure: true,
+        createdFile
+    };
+}
+/**
+ * A basic StorageFileInitializeFromUploadService implementation.
+ */
+function storageFileInitializeFromUploadService(config) {
+    const { storageService, storageFileCollection, initializer: inputInitializers, determiner: inputDeterminers, validate, checkFileIsAllowedToBeInitialized: inputCheckFileIsAllowedToBeInitialized, requireStorageFileRelatedFileMetadataBeSet } = config;
+    const allDeterminers = [];
+    const initializers = {};
+    const detailsAccessorFactory = firebase.storedFileReaderFactory();
+    if (inputDeterminers) {
+        util.pushItemOrArrayItemsIntoArray(allDeterminers, inputDeterminers);
+    }
+    // iterate initializers
+    inputInitializers.forEach((initializer) => {
+        const { type: inputTypes, determiner: inputDeterminer } = initializer;
+        const types = util.asArray(inputTypes);
+        types.forEach((type) => {
+            initializers[type] = initializer;
+        });
+        if (inputDeterminer) {
+            const wrappedDeterminer = firebase.limitUploadFileTypeDeterminer(inputDeterminer, types);
+            allDeterminers.push(wrappedDeterminer);
+        }
+    });
+    const determiner = firebase.combineUploadFileTypeDeterminers({
+        determiners: allDeterminers,
+        ...{
+            completeSearchOnFirstMatch: true,
+            ...config.combineDeterminersConfig
+        }
+    });
+    // validate initializers
+    if (validate) {
+        const allInitializerTypes = Object.keys(initializers);
+        const allDeterminerTypes = new Set(determiner.getPossibleFileTypes());
+        // all initializer types should have a corresponding determiner
+        allInitializerTypes.forEach((type) => {
+            if (!allDeterminerTypes.has(type)) {
+                throw new Error(`Initializer type ${type} does not have a corresponding determiner.`);
+            }
+        });
+    }
+    async function determineUploadFileType(input) {
+        const { file } = input;
+        const fileDetailsAccessor = detailsAccessorFactory(file);
+        return determiner.determine(fileDetailsAccessor);
+    }
+    return {
+        checkFileIsAllowedToBeInitialized: inputCheckFileIsAllowedToBeInitialized ?? util.asDecisionFunction(true),
+        determineUploadFileType,
+        initializeFromUpload: async (input) => {
+            const determinerResult = await determineUploadFileType(input);
+            let resultType;
+            let createdFilePath;
+            let storageFileDocument;
+            let processorError;
+            let previousStorageFilesFlaggedForDeletion;
+            if (determinerResult) {
+                const { input: fileDetailsAccessor } = determinerResult;
+                resultType = 'success';
+                const initializer = initializers[determinerResult.type];
+                if (initializer) {
+                    try {
+                        const initializerResult = await initializer.initialize({ determinerResult, fileDetailsAccessor });
+                        if (initializerResult.error) {
+                            const { error, permanentFailure, createdFile } = initializerResult;
+                            processorError = error;
+                            if (permanentFailure) {
+                                resultType = 'permanent_initializer_failure';
+                            }
+                            else {
+                                resultType = 'initializer_error';
+                            }
+                            // delete the created file
+                            if (createdFile != null) {
+                                await storageService
+                                    .file(createdFile.storagePath)
+                                    .delete()
+                                    .catch(() => 0);
+                            }
+                        }
+                        else {
+                            let flagPreviousForDelete;
+                            if (initializerResult.createStorageFileResult) {
+                                const { createStorageFileResult, flagPreviousForDelete: flagPreviousForDeleteResult } = initializerResult;
+                                createdFilePath = firebase.copyStoragePath(createStorageFileResult.storageFile);
+                                storageFileDocument = createStorageFileResult.storageFileDocument;
+                                if (flagPreviousForDeleteResult) {
+                                    if (typeof flagPreviousForDeleteResult === 'object') {
+                                        flagPreviousForDelete = flagPreviousForDeleteResult;
+                                    }
+                                    else {
+                                        const { p, pg, u } = createStorageFileResult.storageFile;
+                                        if (!p || !u) {
+                                            throw new Error('initializeFromUpload(): flagPreviousForDelete=true requires that the created StorageFile have a purpose (p) and user (u).');
+                                        }
+                                        flagPreviousForDelete = {
+                                            purpose: p,
+                                            purposeSubgroup: pg,
+                                            user: u
+                                        };
+                                    }
+                                }
+                            }
+                            else {
+                                createdFilePath = firebase.copyStoragePath(initializerResult.createdFile.storagePath);
+                                storageFileDocument = initializerResult.storageFileDocument;
+                                flagPreviousForDelete = initializerResult.flagPreviousForDelete;
+                            }
+                            // sanitize the returned value, incase the result comes from a transaction
+                            if (storageFileDocument) {
+                                storageFileDocument = storageFileCollection.documentAccessor().loadDocumentFrom(storageFileDocument);
+                            }
+                            // set the metadata on the associated file
+                            try {
+                                const createdFile = storageService.file(createdFilePath);
+                                const fileMetadata = await createdFile.getMetadata();
+                                await createdFile.setMetadata({
+                                    customMetadata: {
+                                        ...fileMetadata.customMetadata,
+                                        [firebase.STORAGEFILE_RELATED_FILE_METADATA_KEY]: storageFileDocument.id
+                                    }
+                                });
+                            }
+                            catch (e) {
+                                // failed to set the metadata. It isn't strictly necessary, so don't throw an error unless configured to always throw an error
+                                if (requireStorageFileRelatedFileMetadataBeSet) {
+                                    // mark the created item for delete
+                                    await storageFileDocument.update(markStorageFileForDeleteTemplate());
+                                    // throw the exception
+                                    throw e;
+                                }
+                            }
+                            // if flagPreviousForDelete is set, flag the previous storage files for deletion
+                            if (flagPreviousForDelete) {
+                                const flagForDeleteResult = await queryAndFlagStorageFilesForDelete({
+                                    storageFileCollection,
+                                    constraints: firebase.storageFilePurposeAndUserQuery(flagPreviousForDelete),
+                                    skipDeleteForKeys: [storageFileDocument.key]
+                                });
+                                previousStorageFilesFlaggedForDeletion = flagForDeleteResult.queuedForDeleteCount;
+                            }
+                        }
+                    }
+                    catch (e) {
+                        resultType = 'initializer_error';
+                        processorError = e;
+                    }
+                }
+                else {
+                    resultType = 'no_initializer_configured';
+                }
+            }
+            else {
+                resultType = 'no_determiner_match';
+            }
+            const result = {
+                resultType,
+                storageFileDocument,
+                initializationError: processorError,
+                previousStorageFilesFlaggedForDeletion
+            };
+            return result;
+        }
+    };
+}
+
+exports.BASE_NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN = BASE_NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN;
+exports.BASE_STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN = BASE_STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN;
+exports.KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS = KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS;
+exports.KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY = KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY;
+exports.MAILGUN_NOTIFICATION_EMAIL_SEND_SERVICE_DEFAULT_MAX_BATCH_SIZE_PER_REQUEST = MAILGUN_NOTIFICATION_EMAIL_SEND_SERVICE_DEFAULT_MAX_BATCH_SIZE_PER_REQUEST;
+exports.MAKE_TEMPLATE_FOR_NOTIFICATION_RELATED_MODEL_INITIALIZATION_FUNCTION_DELETE_RESPONSE = MAKE_TEMPLATE_FOR_NOTIFICATION_RELATED_MODEL_INITIALIZATION_FUNCTION_DELETE_RESPONSE;
+exports.MAKE_TEMPLATE_FOR_STORAGEFILE_RELATED_MODEL_INITIALIZATION_FUNCTION_DELETE_RESPONSE = MAKE_TEMPLATE_FOR_STORAGEFILE_RELATED_MODEL_INITIALIZATION_FUNCTION_DELETE_RESPONSE;
+exports.NOTIFICATION_BOX_NOT_INITIALIZED_DELAY_MINUTES = NOTIFICATION_BOX_NOT_INITIALIZED_DELAY_MINUTES;
+exports.NOTIFICATION_INIT_SERVER_ACTIONS_CONTEXT_CONFIG_TOKEN = NOTIFICATION_INIT_SERVER_ACTIONS_CONTEXT_CONFIG_TOKEN;
+exports.NOTIFICATION_MAX_SEND_ATTEMPTS = NOTIFICATION_MAX_SEND_ATTEMPTS;
+exports.NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN = NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN;
+exports.NOTIFICATION_TASK_MINIMUM_SET_AT_THROTTLE_TIME_MINUTES = NOTIFICATION_TASK_MINIMUM_SET_AT_THROTTLE_TIME_MINUTES;
+exports.NOTIFICATION_TASK_TYPE_FAILURE_DELAY_HOURS = NOTIFICATION_TASK_TYPE_FAILURE_DELAY_HOURS;
+exports.NOTIFICATION_TASK_TYPE_FAILURE_DELAY_MS = NOTIFICATION_TASK_TYPE_FAILURE_DELAY_MS;
+exports.NOTIFICATION_TASK_TYPE_MAX_SEND_ATTEMPTS = NOTIFICATION_TASK_TYPE_MAX_SEND_ATTEMPTS;
+exports.NOTIFICATION_TEMPLATE_SERVICE_CONFIGS_ARRAY_TOKEN = NOTIFICATION_TEMPLATE_SERVICE_CONFIGS_ARRAY_TOKEN;
+exports.NOTIFICATION_TEMPLATE_SERVICE_DEFAULTS_OVERRIDE_TOKEN = NOTIFICATION_TEMPLATE_SERVICE_DEFAULTS_OVERRIDE_TOKEN;
+exports.NotificationExpediteService = NotificationExpediteService;
+exports.NotificationInitServerActions = NotificationInitServerActions;
+exports.NotificationSendService = NotificationSendService;
+exports.NotificationServerActions = NotificationServerActions;
+exports.NotificationTaskService = NotificationTaskService;
+exports.NotificationTaskSubTaskMissingRequiredDataTermination = NotificationTaskSubTaskMissingRequiredDataTermination;
+exports.SEND_QUEUE_NOTIFICATIONS_TASK_EXCESS_THRESHOLD = SEND_QUEUE_NOTIFICATIONS_TASK_EXCESS_THRESHOLD;
+exports.STORAGE_FILE_INIT_SERVER_ACTIONS_CONTEXT_CONFIG_TOKEN = STORAGE_FILE_INIT_SERVER_ACTIONS_CONTEXT_CONFIG_TOKEN;
+exports.STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN = STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN;
+exports.StorageFileInitServerActions = StorageFileInitServerActions;
+exports.StorageFileInitializeFromUploadService = StorageFileInitializeFromUploadService;
+exports.StorageFileServerActions = StorageFileServerActions;
+exports.UNKNOWN_NOTIFICATION_TASK_TYPE_DELETE_AFTER_RETRY_ATTEMPTS = UNKNOWN_NOTIFICATION_TASK_TYPE_DELETE_AFTER_RETRY_ATTEMPTS;
+exports.UNKNOWN_NOTIFICATION_TASK_TYPE_HOURS_DELAY = UNKNOWN_NOTIFICATION_TASK_TYPE_HOURS_DELAY;
+exports.UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS = UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS;
+exports.UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY = UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY;
+exports._initializeStorageFileFromUploadFileFactory = _initializeStorageFileFromUploadFileFactory;
+exports._processStorageFileInTransactionFactory = _processStorageFileInTransactionFactory;
+exports._syncStorageFileWithGroupsInTransactionFactory = _syncStorageFileWithGroupsInTransactionFactory;
+exports.allStorageFileGroupStorageFileProcessingPurposeSubtaskProcessors = allStorageFileGroupStorageFileProcessingPurposeSubtaskProcessors;
+exports.appNotificationModuleMetadata = appNotificationModuleMetadata;
+exports.appStorageFileModuleMetadata = appStorageFileModuleMetadata;
+exports.cleanupSentNotificationsFactory = cleanupSentNotificationsFactory;
+exports.createNotificationBoxFactory = createNotificationBoxFactory;
+exports.createNotificationBoxInTransactionFactory = createNotificationBoxInTransactionFactory;
+exports.createNotificationIdRequiredError = createNotificationIdRequiredError;
+exports.createNotificationSummaryFactory = createNotificationSummaryFactory;
+exports.createNotificationUserFactory = createNotificationUserFactory;
+exports.createOrRunUniqueNotificationDocument = createOrRunUniqueNotificationDocument;
+exports.createStorageFileFactory = createStorageFileFactory;
+exports.createStorageFileGroupFactory = createStorageFileGroupFactory;
+exports.createStorageFileGroupInTransactionFactory = createStorageFileGroupInTransactionFactory;
+exports.createStorageFileGroupInputError = createStorageFileGroupInputError;
+exports.deleteAllQueuedStorageFilesFactory = deleteAllQueuedStorageFilesFactory;
+exports.deleteStorageFileFactory = deleteStorageFileFactory;
+exports.downloadStorageFileFactory = downloadStorageFileFactory;
+exports.expandNotificationRecipients = expandNotificationRecipients;
+exports.exportMutableNotificationExpediteService = exportMutableNotificationExpediteService;
+exports.firestoreNotificationSummarySendService = firestoreNotificationSummarySendService;
+exports.ignoreSendNotificationTextSendService = ignoreSendNotificationTextSendService;
+exports.initializeAllApplicableNotificationBoxesFactory = initializeAllApplicableNotificationBoxesFactory;
+exports.initializeAllApplicableNotificationSummariesFactory = initializeAllApplicableNotificationSummariesFactory;
+exports.initializeAllApplicableStorageFileGroupsFactory = initializeAllApplicableStorageFileGroupsFactory;
+exports.initializeAllStorageFilesFromUploadsFactory = initializeAllStorageFilesFromUploadsFactory;
+exports.initializeNotificationBoxFactory = initializeNotificationBoxFactory;
+exports.initializeNotificationBoxInTransactionFactory = initializeNotificationBoxInTransactionFactory;
+exports.initializeNotificationModelInTransaction = initializeNotificationModelInTransaction;
+exports.initializeNotificationSummaryFactory = initializeNotificationSummaryFactory;
+exports.initializeNotificationSummaryInTransactionFactory = initializeNotificationSummaryInTransactionFactory;
+exports.initializeStorageFileFromUploadFactory = initializeStorageFileFromUploadFactory;
+exports.initializeStorageFileGroupFactory = initializeStorageFileGroupFactory;
+exports.initializeStorageFileGroupInTransactionFactory = initializeStorageFileGroupInTransactionFactory;
+exports.initializeStorageFileModelInTransaction = initializeStorageFileModelInTransaction;
+exports.mailgunNotificationEmailSendService = mailgunNotificationEmailSendService;
+exports.makeNewNotificationSummaryTemplate = makeNewNotificationSummaryTemplate;
+exports.markStorageFileForDeleteTemplate = markStorageFileForDeleteTemplate;
+exports.notificationBoxDoesNotExist = notificationBoxDoesNotExist;
+exports.notificationBoxExclusionTargetInvalidError = notificationBoxExclusionTargetInvalidError;
+exports.notificationBoxExistsForModelError = notificationBoxExistsForModelError;
+exports.notificationBoxRecipientDoesNotExistsError = notificationBoxRecipientDoesNotExistsError;
+exports.notificationBoxUnregistredModelTypeInitializationError = notificationBoxUnregistredModelTypeInitializationError;
+exports.notificationExpediteServiceInstance = notificationExpediteServiceInstance;
+exports.notificationInitServerActions = notificationInitServerActions;
+exports.notificationInitServerActionsFactory = notificationInitServerActionsFactory;
+exports.notificationModelAlreadyInitializedError = notificationModelAlreadyInitializedError;
+exports.notificationServerActions = notificationServerActions;
+exports.notificationServerActionsContextFactory = notificationServerActionsContextFactory;
+exports.notificationServerActionsFactory = notificationServerActionsFactory;
+exports.notificationTaskService = notificationTaskService;
+exports.notificationTaskSubTaskMissingRequiredDataTermination = notificationTaskSubTaskMissingRequiredDataTermination;
+exports.notificationTaskSubtaskNotificationTaskHandlerFactory = notificationTaskSubtaskNotificationTaskHandlerFactory;
+exports.notificationTemplateServiceInstance = notificationTemplateServiceInstance;
+exports.notificationUserBlockedFromBeingAddedToRecipientsError = notificationUserBlockedFromBeingAddedToRecipientsError;
+exports.notificationUserInvalidUidForCreateError = notificationUserInvalidUidForCreateError;
+exports.notificationUserLockedConfigFromBeingUpdatedError = notificationUserLockedConfigFromBeingUpdatedError;
+exports.processAllQueuedStorageFilesFactory = processAllQueuedStorageFilesFactory;
+exports.processStorageFileFactory = processStorageFileFactory;
+exports.provideMutableNotificationExpediteService = provideMutableNotificationExpediteService;
+exports.queryAndFlagStorageFilesForDelete = queryAndFlagStorageFilesForDelete;
+exports.regenerateAllFlaggedStorageFileGroupsContentFactory = regenerateAllFlaggedStorageFileGroupsContentFactory;
+exports.regenerateStorageFileGroupContentFactory = regenerateStorageFileGroupContentFactory;
+exports.resyncAllNotificationUsersFactory = resyncAllNotificationUsersFactory;
+exports.resyncNotificationUserFactory = resyncNotificationUserFactory;
+exports.sendNotificationFactory = sendNotificationFactory;
+exports.sendQueuedNotificationsFactory = sendQueuedNotificationsFactory;
+exports.storageFileAlreadyProcessedError = storageFileAlreadyProcessedError;
+exports.storageFileCannotBeDeletedYetError = storageFileCannotBeDeletedYetError;
+exports.storageFileGroupQueuedForInitializationError = storageFileGroupQueuedForInitializationError;
+exports.storageFileGroupZipStorageFileProcessingPurposeSubtaskProcessor = storageFileGroupZipStorageFileProcessingPurposeSubtaskProcessor;
+exports.storageFileInitServerActions = storageFileInitServerActions;
+exports.storageFileInitServerActionsFactory = storageFileInitServerActionsFactory;
+exports.storageFileInitializeFromUploadService = storageFileInitializeFromUploadService;
+exports.storageFileInitializeFromUploadServiceInitializerResultPermanentFailure = storageFileInitializeFromUploadServiceInitializerResultPermanentFailure;
+exports.storageFileModelAlreadyInitializedError = storageFileModelAlreadyInitializedError;
+exports.storageFileNotFlaggedForDeletionError = storageFileNotFlaggedForDeletionError;
+exports.storageFileNotFlaggedForGroupsSyncError = storageFileNotFlaggedForGroupsSyncError;
+exports.storageFileProcessingNotAllowedForInvalidStateError = storageFileProcessingNotAllowedForInvalidStateError;
+exports.storageFileProcessingNotAvailableForTypeError = storageFileProcessingNotAvailableForTypeError;
+exports.storageFileProcessingNotQueuedForProcessingError = storageFileProcessingNotQueuedForProcessingError;
+exports.storageFileProcessingNotificationTaskHandler = storageFileProcessingNotificationTaskHandler;
+exports.storageFileProcessingNotificationTaskHandlerDefaultCleanup = storageFileProcessingNotificationTaskHandlerDefaultCleanup;
+exports.storageFileServerActions = storageFileServerActions;
+exports.storageFileServerActionsContextFactory = storageFileServerActionsContextFactory;
+exports.storageFileServerActionsFactory = storageFileServerActionsFactory;
+exports.syncAllFlaggedStorageFilesWithGroupsFactory = syncAllFlaggedStorageFilesWithGroupsFactory;
+exports.syncStorageFileWithGroupsFactory = syncStorageFileWithGroupsFactory;
+exports.updateNotificationBoxFactory = updateNotificationBoxFactory;
+exports.updateNotificationBoxRecipientExclusionInTransactionFactory = updateNotificationBoxRecipientExclusionInTransactionFactory;
+exports.updateNotificationBoxRecipientFactory = updateNotificationBoxRecipientFactory;
+exports.updateNotificationBoxRecipientInTransactionFactory = updateNotificationBoxRecipientInTransactionFactory;
+exports.updateNotificationSummaryFactory = updateNotificationSummaryFactory;
+exports.updateNotificationUserFactory = updateNotificationUserFactory;
+exports.updateNotificationUserNotificationBoxRecipientConfig = updateNotificationUserNotificationBoxRecipientConfig;
+exports.updateStorageFileFactory = updateStorageFileFactory;
+exports.updateStorageFileGroupFactory = updateStorageFileGroupFactory;
+exports.uploadedFileDoesNotExistError = uploadedFileDoesNotExistError;
+exports.uploadedFileInitializationDiscardedError = uploadedFileInitializationDiscardedError;
+exports.uploadedFileInitializationFailedError = uploadedFileInitializationFailedError;
+exports.uploadedFileIsNotAllowedToBeInitializedError = uploadedFileIsNotAllowedToBeInitializedError;