@dereekb/firebase-server 12.7.0 → 13.0.1

package/index.cjs.js

@@ -0,0 +1,2859 @@
+'use strict';
+
+var firebase = require('@dereekb/firebase');
+var util = require('@dereekb/util');
+var https = require('firebase-functions/https');
+var date = require('@dereekb/date');
+var makeError = require('make-error');
+var rxjs = require('rxjs');
+var firestore = require('@google-cloud/firestore');
+var common = require('@nestjs/common');
+var nestjs = require('@dereekb/nestjs');
+var v2 = require('firebase-functions/v2');
+var model = require('@dereekb/model');
+var admin = require('firebase-admin');
+var storage = require('@google-cloud/storage');
+var dateFns = require('date-fns');
+var types = require('util/types');
+var core = require('@nestjs/core');
+var platformExpress = require('@nestjs/platform-express');
+var express = require('express');
+
+function unauthenticatedContextHasNoAuthData() {
+    return unauthenticatedError({
+        message: 'expected auth',
+        code: firebase.DBX_FIREBASE_SERVER_NO_AUTH_ERROR_CODE
+    });
+}
+function unauthenticatedContextHasNoUidError() {
+    return unauthenticatedError({
+        message: 'no user uid',
+        code: firebase.DBX_FIREBASE_SERVER_NO_AUTH_ERROR_CODE
+    });
+}
+// MARK: General Errors
+const UNAUTHENTICATED_ERROR_CODE = 'UNAUTHENTICATED';
+function unauthenticatedError(messageOrError) {
+    const serverError = util.partialServerError(messageOrError);
+    return new https.HttpsError('unauthenticated', serverError?.message || 'unauthenticated', {
+        status: 401,
+        code: UNAUTHENTICATED_ERROR_CODE,
+        ...serverError,
+        _error: undefined
+    });
+}
+const FORBIDDEN_ERROR_CODE = 'FORBIDDEN';
+function forbiddenError(messageOrError) {
+    const serverError = util.partialServerError(messageOrError);
+    return new https.HttpsError('permission-denied', serverError?.message || 'forbidden', {
+        status: 403,
+        code: FORBIDDEN_ERROR_CODE,
+        ...serverError,
+        _error: undefined
+    });
+}
+const PERMISSION_DENIED_ERROR_CODE = 'PERMISSION_DENIED';
+function permissionDeniedError(messageOrError) {
+    const serverError = util.partialServerError(messageOrError);
+    return new https.HttpsError('permission-denied', serverError?.message || 'permission denied', {
+        status: 403,
+        code: PERMISSION_DENIED_ERROR_CODE,
+        ...serverError,
+        _error: undefined
+    });
+}
+const NOT_FOUND_ERROR_CODE = 'NOT_FOUND';
+function notFoundError(messageOrError) {
+    const serverError = util.partialServerError(messageOrError);
+    return new https.HttpsError('not-found', serverError?.message || 'not found', {
+        status: 404,
+        code: NOT_FOUND_ERROR_CODE,
+        ...serverError,
+        _error: undefined
+    });
+}
+const MODEL_NOT_AVAILABLE_ERROR_CODE = 'MODEL_NOT_AVAILABLE';
+function modelNotAvailableError(messageOrError) {
+    const serverError = util.partialServerError(messageOrError);
+    return new https.HttpsError('not-found', serverError?.message || 'model was not available', {
+        status: 404,
+        code: MODEL_NOT_AVAILABLE_ERROR_CODE,
+        ...serverError,
+        _error: undefined
+    });
+}
+const BAD_REQUEST_ERROR_CODE = 'BAD_REQUEST';
+function badRequestError(messageOrError) {
+    const serverError = util.partialServerError(messageOrError);
+    return new https.HttpsError('invalid-argument', serverError?.message || 'bad request', {
+        status: 400,
+        code: BAD_REQUEST_ERROR_CODE,
+        ...serverError,
+        _error: undefined
+    });
+}
+const CONFLICT_ERROR_CODE = 'CONFLICT';
+function preconditionConflictError(messageOrError) {
+    const serverError = util.partialServerError(messageOrError);
+    return new https.HttpsError('failed-precondition', serverError?.message || 'conflict', {
+        status: 409,
+        code: CONFLICT_ERROR_CODE,
+        ...serverError,
+        _error: undefined
+    });
+}
+const ALREADY_EXISTS_ERROR_CODE = 'ALREADY_EXISTS';
+function alreadyExistsError(messageOrError) {
+    const serverError = util.partialServerError(messageOrError);
+    return new https.HttpsError('already-exists', serverError?.message || 'already exists', {
+        status: 409,
+        code: ALREADY_EXISTS_ERROR_CODE,
+        ...serverError,
+        _error: undefined
+    });
+}
+const UNAVAILABLE_ERROR_CODE = 'UNAVAILABLE';
+function unavailableError(messageOrError) {
+    const serverError = util.partialServerError(messageOrError);
+    return new https.HttpsError('unavailable', serverError?.message || 'service unavailable', {
+        status: 503,
+        code: UNAVAILABLE_ERROR_CODE,
+        ...serverError,
+        _error: undefined
+    });
+}
+const UNAVAILABLE_OR_DEACTIVATED_FUNCTION_ERROR_CODE = 'UNAVAILABLE_OR_DEACTIVATED_FUNCTION';
+function unavailableOrDeactivatedFunctionError(messageOrError) {
+    const serverError = util.partialServerError(messageOrError);
+    return new https.HttpsError('unimplemented', serverError?.message || 'the requested function is not available or has been deactivated for use', {
+        status: 501,
+        code: UNAVAILABLE_OR_DEACTIVATED_FUNCTION_ERROR_CODE,
+        ...serverError,
+        _error: undefined
+    });
+}
+const INTERNAL_SERVER_ERROR_CODE = 'INTERNAL_ERROR';
+function internalServerError(messageOrError) {
+    const serverError = util.partialServerError(messageOrError);
+    return new https.HttpsError('internal', serverError?.message || 'internal error', {
+        status: 500,
+        code: INTERNAL_SERVER_ERROR_CODE,
+        ...serverError,
+        _error: undefined
+    });
+}
+function isFirebaseHttpsError(input) {
+    return typeof input === 'object' && input.code != null && input.httpErrorCode != null && input.toJSON != null;
+}
+function isFirebaseError(input) {
+    return typeof input === 'object' && input.code != null && input.message != null && input.toJSON != null;
+}
+/**
+ * Creates a FirebaseServerErrorInfo from the input.
+ *
+ * @param e
+ * @returns
+ */
+function firebaseServerErrorInfo(e) {
+    let type = 'unknown';
+    let httpsError;
+    let firebaseError;
+    let firebaseErrorCode;
+    let httpsErrorDetailsServerError;
+    let serverErrorCode;
+    if (e != null) {
+        if (isFirebaseHttpsError(e)) {
+            type = 'httpsError';
+            httpsError = e;
+            firebaseErrorCode = httpsError.code;
+            if (httpsError.details && util.isServerError(httpsError.details)) {
+                httpsErrorDetailsServerError = httpsError.details;
+                serverErrorCode = httpsErrorDetailsServerError.code;
+            }
+        }
+        else if (isFirebaseError(e)) {
+            type = 'firebaseError';
+            firebaseError = e;
+            firebaseErrorCode = firebaseError.code;
+        }
+    }
+    return {
+        httpsError,
+        firebaseError,
+        firebaseErrorCode,
+        httpsErrorDetailsServerError,
+        serverErrorCode,
+        type,
+        e
+    };
+}
+function firebaseServerErrorInfoCodePair(e) {
+    const info = firebaseServerErrorInfo(e);
+    return [info.firebaseErrorCode, info];
+}
+function firebaseServerErrorInfoServerErrorPair(e) {
+    const info = firebaseServerErrorInfo(e);
+    return [info.httpsErrorDetailsServerError, info];
+}
+function firebaseServerErrorInfoServerErrorCodePair(e) {
+    const info = firebaseServerErrorInfo(e);
+    return [info.serverErrorCode, info];
+}
+function handleFirebaseError(e, handleFirebaseErrorFn) {
+    const firebaseError = e.code ? e : undefined;
+    if (firebaseError) {
+        handleFirebaseErrorFn(firebaseError);
+    }
+}
+
+function isContextWithAuthData(context) {
+    return Boolean(context.auth !== null && context.auth?.uid);
+}
+function assertIsContextWithAuthData(context) {
+    if (!isContextWithAuthData(context)) {
+        throw unauthenticatedContextHasNoAuthData();
+    }
+}
+
+function firebaseAuthTokenFromDecodedIdToken(token) {
+    return {
+        email: token.email,
+        emailVerified: token.email_verified,
+        phoneNumber: token.phone_number,
+        lastSignInTime: new Date(token.auth_time).toISOString(),
+        lastRefreshTime: new Date(token.iat).toISOString()
+    };
+}
+
+/**
+ * Awaits the load result from the input promise. If it encounters a FIREBASE_AUTH_USER_NOT_FOUND_ERROR, then returns undefined. Throws the error otherwise.
+ * @param promise
+ * @returns
+ */
+async function getAuthUserOrUndefined(promise) {
+    try {
+        return await promise;
+    }
+    catch (error) {
+        if (error?.code === firebase.FIREBASE_AUTH_USER_NOT_FOUND_ERROR) {
+            return undefined;
+        }
+        else {
+            throw error;
+        }
+    }
+}
+
+/**
+ * Thrown by sendSetupDetails() if the user has no setup configuration available, meaning they probably already have accepted their invite or is in an invalid state.
+ */
+class FirebaseServerAuthNewUserSendSetupDetailsNoSetupConfigError extends makeError.BaseError {
+    constructor() {
+        super(`This user has no setup configuration available.`);
+    }
+}
+/**
+ * Thrown by sendSetupDetails() if the user was recently sent details.
+ */
+class FirebaseServerAuthNewUserSendSetupDetailsThrottleError extends makeError.BaseError {
+    lastSentAt;
+    constructor(lastSentAt) {
+        super(`This user was recently sent details. Try again later.`);
+        this.lastSentAt = lastSentAt;
+    }
+}
+/**
+ * Thrown by sendSetupDetails() if the user was recently sent details.
+ */
+class FirebaseServerAuthNewUserSendSetupDetailsSendOnceError extends makeError.BaseError {
+    constructor() {
+        super(`The user has been sent details before and the sendSetupDetailsOnce configuration was true.`);
+    }
+}
+
+const DEFAULT_FIREBASE_PASSWORD_NUMBER_GENERATOR = util.randomNumberFactory({ min: 100000, max: 1000000, round: 'floor' }); // 6 digits
+class AbstractFirebaseServerAuthUserContext {
+    _service;
+    _uid;
+    _loadRecord = util.cachedGetter(() => this._service.auth.getUser(this._uid));
+    constructor(service, uid) {
+        this._service = service;
+        this._uid = uid;
+    }
+    get service() {
+        return this._service;
+    }
+    get uid() {
+        return this._uid;
+    }
+    async exists() {
+        return getAuthUserOrUndefined(this._loadRecord()).then((x) => Boolean(x));
+    }
+    loadRecord() {
+        return this._loadRecord();
+    }
+    loadDetails() {
+        return this.loadRecord().then((record) => this.service.authDetailsForRecord(record));
+    }
+    _generateResetPasswordKey() {
+        return String(DEFAULT_FIREBASE_PASSWORD_NUMBER_GENERATOR());
+    }
+    async beginResetPassword() {
+        const password = this._generateResetPasswordKey();
+        const passwordClaimsData = {
+            [firebase.FIREBASE_SERVER_AUTH_CLAIMS_RESET_PASSWORD_KEY]: password,
+            [firebase.FIREBASE_SERVER_AUTH_CLAIMS_RESET_LAST_COM_DATE_KEY]: date.toISODateString(new Date())
+        };
+        // set the claims
+        await this.updateClaims(passwordClaimsData);
+        // update the user
+        await this.updateUser({ password });
+        return passwordClaimsData;
+    }
+    async loadResetPasswordClaims() {
+        const claims = await this.loadClaims();
+        if (claims.resetPassword != null) {
+            return claims;
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * Sets the user's password.
+     */
+    async setPassword(password) {
+        const record = await this.updateUser({ password });
+        // clear password reset claims
+        await this.updateClaims({
+            [firebase.FIREBASE_SERVER_AUTH_CLAIMS_RESET_PASSWORD_KEY]: null,
+            [firebase.FIREBASE_SERVER_AUTH_CLAIMS_RESET_LAST_COM_DATE_KEY]: null
+        });
+        return record;
+    }
+    async updateUser(template) {
+        return this.service.auth.updateUser(this.uid, template);
+    }
+    async loadRoles() {
+        const claims = await this.loadClaims();
+        return this.service.readRoles(claims);
+    }
+    async addRoles(roles) {
+        const claims = this._claimsForRolesChange(roles);
+        return this.updateClaims(claims);
+    }
+    async removeRoles(roles) {
+        const baseClaims = this._claimsForRolesChange(roles);
+        const claims = {};
+        util.forEachKeyValue(baseClaims, {
+            forEach: ([key]) => {
+                claims[key] = null; // set null on every key
+            },
+            filter: util.KeyValueTypleValueFilter.NONE // don't skip any key/value
+        });
+        return this.updateClaims(claims);
+    }
+    /**
+     * Sets the claims using the input roles and roles set.
+     *
+     * All other claims are cleared.
+     *
+     * Use the claimsToRetain input to retain other claims that are outside of the roles.
+     *
+     * @param roles
+     * @param claimsToRetain
+     * @returns
+     */
+    async setRoles(roles, claimsToRetain) {
+        const claims = {
+            ...claimsToRetain,
+            ...this._claimsForRolesChange(Array.from(roles))
+        };
+        return this.setClaims(claims);
+    }
+    _claimsForRolesChange(roles) {
+        // filter null/undefined since the claims will contain null values for claims that are not related.
+        return util.filterNullAndUndefinedValues(this.service.claimsForRoles(util.asSet(roles)));
+    }
+    loadClaims() {
+        return this.loadRecord().then((x) => (x.customClaims ?? {}));
+    }
+    async updateClaims(claims) {
+        const currentClaims = await this.loadClaims();
+        let newClaims;
+        if (currentClaims) {
+            newClaims = {
+                ...currentClaims,
+                ...util.filterUndefinedValues(claims, false)
+            };
+            newClaims = util.filterNullAndUndefinedValues(newClaims);
+        }
+        else {
+            newClaims = claims;
+        }
+        return this.setClaims(newClaims);
+    }
+    clearClaims() {
+        return this.setClaims(null);
+    }
+    setClaims(claims) {
+        return this.service.auth.setCustomUserClaims(this.uid, claims).then(() => {
+            this._loadRecord.reset(); // reset the cache
+        });
+    }
+}
+class AbstractFirebaseServerAuthContext {
+    _service;
+    _context;
+    _authRoles = util.cachedGetter(() => this.service.readRoles(this.claims));
+    _isAdmin = util.cachedGetter(() => this.service.isAdminInRoles(this._authRoles()));
+    _hasSignedTos = util.cachedGetter(() => this.service.hasSignedTosInRoles(this._authRoles()));
+    _userContext = util.cachedGetter(() => this.service.userContext(this.context.auth.uid));
+    constructor(service, context) {
+        this._service = service;
+        this._context = context;
+    }
+    get service() {
+        return this._service;
+    }
+    get context() {
+        return this._context;
+    }
+    get userContext() {
+        return this._userContext();
+    }
+    get isAdmin() {
+        return this._isAdmin();
+    }
+    get hasSignedTos() {
+        return this._hasSignedTos();
+    }
+    get authRoles() {
+        return this._authRoles();
+    }
+    get token() {
+        return this.context.auth.token;
+    }
+    get claims() {
+        return this.context.auth.token;
+    }
+    // MARK: FirebaseServerAuthUserContext
+    get uid() {
+        return this.userContext.uid;
+    }
+}
+/**
+ * 1 hour
+ */
+const DEFAULT_SETUP_COM_THROTTLE_TIME = date.hoursToMs(1);
+function userContextFromUid(authService, userContextOrUid) {
+    const userContext = typeof userContextOrUid === 'string' ? authService.userContext(userContextOrUid) : userContextOrUid;
+    return userContext;
+}
+class AbstractFirebaseServerNewUserService {
+    _authService;
+    setupThrottleTime = DEFAULT_SETUP_COM_THROTTLE_TIME;
+    constructor(authService) {
+        this._authService = authService;
+    }
+    get authService() {
+        return this._authService;
+    }
+    async initializeNewUser(input) {
+        const { uid, email, phone, sendSetupContent, sendSetupContentIfUserExists, sendSetupDetailsOnce, sendSetupIgnoreThrottle, sendSetupThrowErrors, data, sendDetailsInTestEnvironment } = input;
+        let userRecordPromise;
+        if (uid) {
+            userRecordPromise = this.authService.auth.getUser(uid);
+        }
+        else if (email) {
+            userRecordPromise = this.authService.auth.getUserByEmail(email);
+        }
+        else if (phone) {
+            userRecordPromise = this.authService.auth.getUserByPhoneNumber(phone);
+        }
+        else {
+            throw new Error('email or phone is required to initialize a new user.');
+        }
+        let userRecord = await getAuthUserOrUndefined(userRecordPromise);
+        let userRecordId;
+        let createdUser = false;
+        if (!userRecord) {
+            const createResult = await this.createNewUser(input);
+            // add the setup password to the user's credentials
+            const userContext = this.authService.userContext(createResult.user.uid);
+            await this.addNewUserSetupClaims(userContext, createResult.password);
+            createdUser = true;
+            userRecordId = userContext.uid;
+            userRecord = await userContext.loadRecord();
+        }
+        else {
+            userRecordId = userRecord.uid;
+        }
+        // send content if necessary
+        if ((createdUser && sendSetupContent === true) || sendSetupContentIfUserExists) {
+            const sentEmail = await this.sendSetupContent(userRecordId, { data, sendSetupDetailsOnce, ignoreSendThrottleTime: sendSetupIgnoreThrottle, throwErrors: sendSetupThrowErrors, sendDetailsInTestEnvironment });
+            // reload the user record
+            if (sentEmail) {
+                const userContext = this.authService.userContext(userRecordId);
+                userRecord = await userContext.loadRecord();
+            }
+        }
+        return userRecord;
+    }
+    async addNewUserSetupClaims(userContextOrUid, setupPassword) {
+        const password = setupPassword ?? this.generateRandomSetupPassword();
+        const userContext = userContextFromUid(this.authService, userContextOrUid);
+        await userContext.updateClaims({
+            [firebase.FIREBASE_SERVER_AUTH_CLAIMS_SETUP_PASSWORD_KEY]: password
+        });
+        return userContext;
+    }
+    async sendSetupContent(userContextOrUid, config) {
+        const setupDetails = await this.loadSetupDetails(userContextOrUid, config);
+        let sentContent = false;
+        if (setupDetails) {
+            const { setupCommunicationAt } = setupDetails.claims;
+            const hasSentCommunication = Boolean(setupCommunicationAt);
+            if (config?.sendSetupDetailsOnce && hasSentCommunication) {
+                // do not send.
+                if (config?.throwErrors) {
+                    throw new FirebaseServerAuthNewUserSendSetupDetailsSendOnceError();
+                }
+            }
+            else {
+                const lastSentAt = setupCommunicationAt ? new Date(setupCommunicationAt) : undefined;
+                const sendIsThrottled = hasSentCommunication && !config?.ignoreSendThrottleTime && util.isThrottled(this.setupThrottleTime, lastSentAt);
+                if (!sendIsThrottled) {
+                    await this.sendSetupContentToUser(setupDetails);
+                    await this.updateSetupContentSentTime(setupDetails);
+                    sentContent = true;
+                }
+                else if (config?.throwErrors) {
+                    throw new FirebaseServerAuthNewUserSendSetupDetailsThrottleError(lastSentAt);
+                }
+            }
+        }
+        else if (config?.throwErrors) {
+            throw new FirebaseServerAuthNewUserSendSetupDetailsNoSetupConfigError();
+        }
+        return sentContent;
+    }
+    async loadSetupDetails(userContextOrUid, config) {
+        const userContext = userContextFromUid(this.authService, userContextOrUid);
+        const userExists = await userContext.exists();
+        let details;
+        if (userExists) {
+            details = await this.loadSetupDetailsForUserContext(userContext, config);
+        }
+        return details;
+    }
+    async loadSetupDetailsForUserContext(userContext, config) {
+        let details;
+        const { setupPassword, setupCommunicationAt } = await userContext.loadClaims();
+        if (setupPassword) {
+            details = {
+                userContext,
+                claims: {
+                    setupPassword,
+                    setupCommunicationAt
+                },
+                data: config?.data,
+                sendDetailsInTestEnvironment: config?.sendDetailsInTestEnvironment
+            };
+        }
+        return details;
+    }
+    async updateSetupContentSentTime(details) {
+        const setupCommunicationAt = date.toISODateString(new Date());
+        await details.userContext.updateClaims({
+            setupCommunicationAt
+        });
+    }
+    /**
+     * Update a user's claims to clear any setup-related content.
+     *
+     * Returns true if a user was updated.
+     *
+     * @param uid
+     */
+    async markUserSetupAsComplete(uid) {
+        const userContext = this.authService.userContext(uid);
+        const userExists = await userContext.exists();
+        if (userExists) {
+            await this.updateClaimsToClearUser(userContext);
+        }
+        return userExists;
+    }
+    async createNewUser(input) {
+        const { uid, displayName, email, phone: phoneNumber, setupPassword: inputPassword } = input;
+        const password = inputPassword ?? this.generateRandomSetupPassword();
+        const user = await this.authService.auth.createUser({
+            uid,
+            displayName,
+            email,
+            phoneNumber,
+            password
+        });
+        return {
+            user,
+            password
+        };
+    }
+    generateRandomSetupPassword() {
+        return `${DEFAULT_FIREBASE_PASSWORD_NUMBER_GENERATOR()}`;
+    }
+    async updateClaimsToClearUser(userContext) {
+        await userContext.updateClaims({
+            [firebase.FIREBASE_SERVER_AUTH_CLAIMS_SETUP_PASSWORD_KEY]: null,
+            [firebase.FIREBASE_SERVER_AUTH_CLAIMS_SETUP_LAST_COM_DATE_KEY]: null
+        });
+    }
+}
+class NoSetupContentFirebaseServerNewUserService extends AbstractFirebaseServerNewUserService {
+    async sendSetupContentToUser(user) {
+        // send nothing.
+    }
+}
+/**
+ * FirebaseServer auth service that provides accessors to auth-related components.
+ */
+class FirebaseServerAuthService {
+}
+/**
+ * Abstract FirebaseServerAuthService implementation.
+ */
+class AbstractFirebaseServerAuthService {
+    _auth;
+    constructor(auth) {
+        this._auth = auth;
+    }
+    get auth() {
+        return this._auth;
+    }
+    context(context) {
+        assertIsContextWithAuthData(context);
+        return this._context(context);
+    }
+    isAdmin(claims) {
+        return this.isAdminInRoles(this.readRoles(claims));
+    }
+    isAdminInRoles(roles) {
+        return roles.has(util.AUTH_ADMIN_ROLE);
+    }
+    hasSignedTos(claims) {
+        return this.hasSignedTosInRoles(this.readRoles(claims));
+    }
+    hasSignedTosInRoles(roles) {
+        return roles.has(util.AUTH_TOS_SIGNED_ROLE);
+    }
+    newUser() {
+        return new NoSetupContentFirebaseServerNewUserService(this);
+    }
+    authContextInfo(context) {
+        const { auth } = context;
+        let result;
+        if (auth) {
+            const _roles = util.cachedGetter(() => this.readRoles(auth.token));
+            const getClaims = () => auth.token;
+            result = {
+                uid: auth.uid,
+                isAdmin: () => this.isAdminInRoles(_roles()),
+                getClaims,
+                getAuthRoles: _roles,
+                token: firebaseAuthTokenFromDecodedIdToken(auth.token)
+            };
+        }
+        return result;
+    }
+    authDetailsForRecord(record) {
+        return {
+            uid: record.uid,
+            email: record.email,
+            emailVerified: record.emailVerified,
+            phoneNumber: record.phoneNumber,
+            disabled: record.disabled,
+            displayName: record.displayName,
+            photoURL: record.photoURL,
+            creationTime: record.metadata.creationTime ? new Date(record.metadata.creationTime).toISOString() : undefined,
+            lastSignInTime: record.metadata.lastSignInTime ? new Date(record.metadata.lastSignInTime).toISOString() : undefined,
+            lastRefreshTime: record.metadata.lastRefreshTime ? new Date(record.metadata.lastRefreshTime).toISOString() : undefined
+        };
+    }
+}
+
+class FirebaseServerEnvService {
+}
+
+/**
+ * Creates UpdateData corresponding to the input increment update.
+ *
+ * @param input
+ * @returns
+ */
+function firestoreServerIncrementUpdateToUpdateData(input) {
+    return util.mapObjectMap(input, (incrementValue) => {
+        return firestore.FieldValue.increment(incrementValue ?? 0);
+    });
+}
+
+/**
+ * Creates UpdateData corresponding to the input array update.
+ *
+ * @param input
+ * @returns
+ */
+function firestoreServerArrayUpdateToUpdateData(input) {
+    const union = input?.union;
+    const remove = input?.remove;
+    function createUpdatesWithArrayFunction(fieldUpdate, arrayUpdateFunction) {
+        let result;
+        if (fieldUpdate) {
+            result = util.mapObjectMap(fieldUpdate, (arrayUpdate) => {
+                let result;
+                if (arrayUpdate) {
+                    result = arrayUpdateFunction(...arrayUpdate); // use spread operator to insert each value as an argument, as "nested arrays" are not allowed in the Firestore
+                }
+                return result;
+            });
+        }
+        return result;
+    }
+    const updateData = {
+        ...createUpdatesWithArrayFunction(union, firestore.FieldValue.arrayUnion),
+        ...createUpdatesWithArrayFunction(remove, firestore.FieldValue.arrayRemove)
+    };
+    return updateData;
+}
+
+// MARK: Accessor
+/**
+ * FirestoreDocumentDataAccessor implementation for a batch.
+ */
+class WriteBatchFirestoreDocumentDataAccessor {
+    documentRef;
+    _batch;
+    constructor(batch, documentRef) {
+        this.documentRef = documentRef;
+        this._batch = batch;
+    }
+    get batch() {
+        return this._batch;
+    }
+    stream() {
+        return rxjs.from(this.get()); // todo
+    }
+    create(data) {
+        this.batch.create(this.documentRef, data);
+        return Promise.resolve();
+    }
+    exists() {
+        return this.get().then((x) => x.exists);
+    }
+    get() {
+        return this.documentRef.get();
+    }
+    getWithConverter(converter) {
+        return this.documentRef.withConverter(converter).get();
+    }
+    delete(params) {
+        this.batch.delete(this.documentRef, params?.precondition);
+        return Promise.resolve();
+    }
+    set(data) {
+        this.batch.set(this.documentRef, data);
+        return Promise.resolve();
+    }
+    increment(data, params) {
+        return this.update(firestoreServerIncrementUpdateToUpdateData(data), params);
+    }
+    arrayUpdate(data, params) {
+        return this.update(firestoreServerArrayUpdateToUpdateData(data), params);
+    }
+    update(data, params) {
+        if (params?.precondition != null) {
+            this.batch.update(this.documentRef, data, params?.precondition);
+        }
+        else {
+            this.batch.update(this.documentRef, data);
+        }
+        return Promise.resolve();
+    }
+}
+/**
+ * Creates a new FirestoreDocumentDataAccessorFactory for a Batch.
+ *
+ * @param batch
+ * @returns
+ */
+function writeBatchAccessorFactory(writeBatch) {
+    return {
+        accessorFor: (ref) => new WriteBatchFirestoreDocumentDataAccessor(writeBatch, ref)
+    };
+}
+// MARK: Context
+class WriteBatchFirestoreDocumentContext {
+    _batch;
+    contextType = firebase.FirestoreDocumentContextType.BATCH;
+    accessorFactory;
+    constructor(batch) {
+        this._batch = batch;
+        this.accessorFactory = writeBatchAccessorFactory(batch);
+    }
+    get batch() {
+        return this._batch;
+    }
+}
+function writeBatchDocumentContext(batch) {
+    return new WriteBatchFirestoreDocumentContext(batch);
+}
+
+// MARK: Accessor
+class DefaultFirestoreDocumentDataAccessor {
+    _documentRef;
+    constructor(documentRef) {
+        this._documentRef = documentRef;
+    }
+    get documentRef() {
+        return this._documentRef;
+    }
+    stream() {
+        return firebase.streamFromOnSnapshot(({ next, error }) => this.documentRef.onSnapshot(next, error));
+    }
+    create(data) {
+        return this.documentRef.create(data);
+    }
+    exists() {
+        return this.get().then((x) => x.exists);
+    }
+    get() {
+        return this.documentRef.get();
+    }
+    getWithConverter(converter) {
+        return this.documentRef.withConverter(converter).get();
+    }
+    delete(params) {
+        return this.documentRef.delete(params?.precondition);
+    }
+    set(data, options) {
+        return options ? this.documentRef.set(data, options) : this.documentRef.set(data);
+    }
+    increment(data, params) {
+        return this.update(firestoreServerIncrementUpdateToUpdateData(data), params);
+    }
+    arrayUpdate(data, params) {
+        return this.update(firestoreServerArrayUpdateToUpdateData(data), params);
+    }
+    update(data, params) {
+        return params?.precondition ? this.documentRef.update(data, params.precondition) : this.documentRef.update(data);
+    }
+}
+function defaultFirestoreAccessorFactory() {
+    return {
+        accessorFor: (ref) => new DefaultFirestoreDocumentDataAccessor(ref)
+    };
+}
+// MARK: Context
+function defaultFirestoreDocumentContext() {
+    return {
+        contextType: firebase.FirestoreDocumentContextType.NONE,
+        accessorFactory: defaultFirestoreAccessorFactory()
+    };
+}
+
+// MARK: Accessor
+/**
+ * FirestoreDocumentDataAccessor implementation for a transaction.
+ */
+class TransactionFirestoreDocumentDataAccessor {
+    _transaction;
+    _documentRef;
+    constructor(transaction, documentRef) {
+        this._transaction = transaction;
+        this._documentRef = documentRef;
+    }
+    get transaction() {
+        return this._transaction;
+    }
+    get documentRef() {
+        return this._documentRef;
+    }
+    stream() {
+        return rxjs.from(this.get());
+    }
+    create(data) {
+        this.transaction.create(this.documentRef, data);
+        return Promise.resolve();
+    }
+    exists() {
+        return this.get().then((x) => x.exists);
+    }
+    get() {
+        return this.transaction.get(this.documentRef);
+    }
+    getWithConverter(converter) {
+        return this.transaction.get(this.documentRef.withConverter(converter));
+    }
+    delete() {
+        this.transaction.delete(this.documentRef);
+        return Promise.resolve();
+    }
+    set(data, options) {
+        this.transaction.set(this.documentRef, data, options);
+        return Promise.resolve();
+    }
+    increment(data, params) {
+        return this.update(firestoreServerIncrementUpdateToUpdateData(data), params);
+    }
+    arrayUpdate(data, params) {
+        return this.update(firestoreServerArrayUpdateToUpdateData(data), params);
+    }
+    update(data, params) {
+        if (params?.precondition) {
+            this.transaction.update(this.documentRef, data, params?.precondition);
+        }
+        else {
+            this.transaction.update(this.documentRef, data);
+        }
+        return Promise.resolve();
+    }
+}
+/**
+ * Creates a new FirestoreDocumentDataAccessorFactory for a Transaction.
+ *
+ * @param transaction
+ * @returns
+ */
+function transactionAccessorFactory(transaction) {
+    return {
+        accessorFor: (ref) => new TransactionFirestoreDocumentDataAccessor(transaction, ref)
+    };
+}
+// MARK: Context
+class TransactionFirestoreDocumentContext {
+    _transaction;
+    contextType = firebase.FirestoreDocumentContextType.TRANSACTION;
+    accessorFactory;
+    constructor(transaction) {
+        this._transaction = transaction;
+        this.accessorFactory = transactionAccessorFactory(transaction);
+    }
+    get transaction() {
+        return this._transaction;
+    }
+}
+function transactionDocumentContext(transaction) {
+    return new TransactionFirestoreDocumentContext(transaction);
+}
+
+function collectionRefForPath(start, path, pathSegments) {
+    let ref = start.collection(path);
+    if (pathSegments?.length) {
+        if (pathSegments?.length % 2 !== 0) {
+            throw new Error(`Invalid number of path segments provided for collection. Path: "${path}" + "${pathSegments}"`);
+        }
+        const batches = util.batch(pathSegments, 2); // batch to tuple [string, string]
+        batches.forEach((x) => {
+            const [first, second] = x;
+            ref = ref.doc(first).collection(second);
+        });
+    }
+    return ref;
+}
+function docRefForPath(start, path, pathSegments) {
+    let doc = (path ? start.doc(path) : start.doc());
+    if (pathSegments?.length) {
+        const batches = util.batch(pathSegments, 2); // batch to tuple [string, string]
+        batches.forEach((x) => {
+            const [first, second] = x;
+            const collection = doc.collection(first);
+            doc = second ? collection.doc(second) : collection.doc();
+        });
+    }
+    return doc;
+}
+function googleCloudFirestoreAccessorDriver() {
+    return {
+        doc: (collection, path, ...pathSegments) => docRefForPath(collection, path, pathSegments),
+        docAtPath: (firestore, fullPath) => firestore.doc(fullPath),
+        collectionGroup: (firestore, collectionId) => firestore.collectionGroup(collectionId),
+        collection: (firestore, path, ...pathSegments) => collectionRefForPath(firestore, path, pathSegments),
+        subcollection: (document, path, ...pathSegments) => collectionRefForPath(document, path, pathSegments),
+        transactionFactoryForFirestore: (firestore) => async (fn) => await firestore.runTransaction(fn),
+        writeBatchFactoryForFirestore: (firestore) => () => firestore.batch(),
+        defaultContextFactory: defaultFirestoreDocumentContext,
+        transactionContextFactory: transactionDocumentContext,
+        writeBatchContextFactory: writeBatchDocumentContext
+    };
+}
+
+const FIRESTORE_CLIENT_QUERY_CONSTRAINT_HANDLER_MAPPING = {
+    [firebase.FIRESTORE_LIMIT_QUERY_CONSTRAINT_TYPE]: (builder, data) => builder.limit(data.limit),
+    [firebase.FIRESTORE_LIMIT_TO_LAST_QUERY_CONSTRAINT_TYPE]: (builder, data) => builder.limitToLast(data.limit),
+    [firebase.FIRESTORE_ORDER_BY_QUERY_CONSTRAINT_TYPE]: (builder, data) => builder.orderBy(data.fieldPath, data.directionStr),
+    [firebase.FIRESTORE_ORDER_BY_DOCUMENT_ID_QUERY_CONSTRAINT_TYPE]: (builder, data) => builder.orderBy(firestore.FieldPath.documentId(), data.directionStr),
+    [firebase.FIRESTORE_WHERE_QUERY_CONSTRAINT_TYPE]: (builder, data) => builder.where(data.fieldPath, data.opStr, data.value),
+    [firebase.FIRESTORE_WHERE_DOCUMENT_ID_QUERY_CONSTRAINT_TYPE]: (builder, data) => builder.where(firestore.FieldPath.documentId(), data.opStr, data.value),
+    [firebase.FIRESTORE_OFFSET_QUERY_CONSTRAINT_TYPE]: (builder, data) => builder.offset(data.offset),
+    [firebase.FIRESTORE_START_AT_QUERY_CONSTRAINT_TYPE]: (builder, data) => builder.startAt(data.snapshot),
+    [firebase.FIRESTORE_START_AT_VALUE_QUERY_CONSTRAINT_TYPE]: (builder, data) => builder.startAt(...data.fieldValues),
+    [firebase.FIRESTORE_START_AFTER_QUERY_CONSTRAINT_TYPE]: (builder, data) => builder.startAfter(data.snapshot),
+    [firebase.FIRESTORE_END_AT_QUERY_CONSTRAINT_TYPE]: (builder, data) => builder.endAt(data.snapshot),
+    [firebase.FIRESTORE_END_AT_VALUE_QUERY_CONSTRAINT_TYPE]: (builder, data) => builder.endAt(...data.fieldValues),
+    [firebase.FIRESTORE_END_BEFORE_QUERY_CONSTRAINT_TYPE]: (builder, data) => builder.endBefore(data.snapshot)
+};
+function firestoreClientQueryConstraintFunctionsDriver() {
+    return firebase.makeFirestoreQueryConstraintFunctionsDriver({
+        mapping: FIRESTORE_CLIENT_QUERY_CONSTRAINT_HANDLER_MAPPING,
+        init: (query) => query,
+        build: (query) => query,
+        documentIdFieldPath: () => firestore.FieldPath.documentId()
+    });
+}
+function googleCloudFirestoreQueryDriver() {
+    return {
+        ...firestoreClientQueryConstraintFunctionsDriver(),
+        countDocs(query) {
+            return query
+                .count()
+                .get()
+                .then((x) => x.data().count);
+        },
+        getDocs(query, transaction) {
+            let result;
+            if (transaction) {
+                result = transaction.get(query);
+            }
+            else {
+                result = query.get();
+            }
+            return result;
+        },
+        streamDocs(query) {
+            return firebase.streamFromOnSnapshot(({ next, error }) => query.onSnapshot(next, error));
+        }
+    };
+}
+
+function googleCloudFirestoreDrivers() {
+    return {
+        firestoreDriverIdentifier: '@google-cloud/firestore',
+        firestoreDriverType: 'production',
+        firestoreAccessorDriver: googleCloudFirestoreAccessorDriver(),
+        firestoreQueryDriver: googleCloudFirestoreQueryDriver()
+    };
+}
+
+/**
+ * Creates a FirestoreContextFactory that uses the @'@google-cloud/firestore package.
+ */
+const googleCloudFirestoreContextFactory = firebase.firestoreContextFactory(googleCloudFirestoreDrivers());
+
+function assertContextHasAuth(context) {
+    if (!isContextWithAuthData(context)) {
+        throw unauthenticatedContextHasNoUidError();
+    }
+}
+/**
+ * Attempts to load data from the document. A modelNotAvailableError is thrown if the snapshot data is null/undefined (the document does not exist).
+ *
+ * @param document
+ * @param message
+ * @returns
+ */
+async function assertSnapshotData(document, message) {
+    const data = await document.snapshotData();
+    if (data == null) {
+        throw modelNotAvailableError({
+            message: message ?? `The ${document.modelType} was unavailable.`
+        });
+    }
+    return data;
+}
+/**
+ * Convenience function for assertSnapshotData that also attaches the id and key of the document to the data.
+ *
+ * @param document
+ * @param message
+ * @returns
+ */
+async function assertSnapshotDataWithKey(document, message) {
+    const data = await assertSnapshotData(document, message);
+    return firebase.setIdAndKeyFromKeyIdRefOnDocumentData(data, document);
+}
+/**
+ * Asserts that the document exists. A modelNotAvailableError is thrown if the document does not exist.
+ *
+ * @param document
+ * @param message
+ * @returns
+ */
+async function assertDocumentExists(document, message) {
+    const exists = await document.exists();
+    if (!exists) {
+        throw documentModelNotAvailableError(document, message);
+    }
+}
+/**
+ * Error thrown by assertDocumentExists().
+ *
+ * @param document
+ * @param message
+ * @returns
+ */
+function documentModelNotAvailableError(document, message) {
+    return modelNotAvailableError({
+        message: message ?? `The ${document.modelType} was unavailable.`
+    });
+}
+
+const PHONE_NUMBER_ALREADY_EXISTS_ERROR_CODE = 'PHONE_NUMBER_ALREADY_EXISTS';
+function phoneNumberAlreadyExistsError() {
+    return preconditionConflictError({
+        code: PHONE_NUMBER_ALREADY_EXISTS_ERROR_CODE,
+        message: 'This phone number already exists in the system.'
+    });
+}
+function handleFirebaseAuthError(e, handleUnknownCode) {
+    handleFirebaseError(e, (firebaseError) => {
+        switch (firebaseError.code) {
+            case 'auth/phone-number-already-exists':
+                throw phoneNumberAlreadyExistsError();
+            default:
+                handleUnknownCode?.(firebaseError);
+                break;
+        }
+    });
+}
+
+/******************************************************************************
+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
+/**
+ * Nest Injection Token to access the
+ */
+const FIREBASE_APP_TOKEN = 'FIREBASE_APP_TOKEN';
+// MARK: Firebase Admin Provider
+function firebaseServerAppTokenProvider(useFactory) {
+    return {
+        provide: FIREBASE_APP_TOKEN,
+        useFactory
+    };
+}
+
+// MARK: Tokens
+/**
+ * Token to access the Auth for the app.
+ */
+const FIREBASE_AUTH_TOKEN = 'FIREBASE_AUTH_TOKEN';
+/**
+ * Nest provider module for Firebase that provides a firestore, etc. from the firestore token.
+ */
+exports.FirebaseServerAuthModule = class FirebaseServerAuthModule {
+};
+exports.FirebaseServerAuthModule = __decorate([
+    common.Module({
+        providers: [
+            {
+                provide: FIREBASE_AUTH_TOKEN,
+                useFactory: (app) => app.auth(),
+                inject: [FIREBASE_APP_TOKEN]
+            }
+        ],
+        exports: [FIREBASE_AUTH_TOKEN]
+    })
+], exports.FirebaseServerAuthModule);
+function provideFirebaseServerAuthService(provider) {
+    return [
+        {
+            ...provider,
+            inject: provider.inject ?? [FIREBASE_AUTH_TOKEN]
+        },
+        {
+            provide: FirebaseServerAuthService,
+            useExisting: provider.provide
+        }
+    ];
+}
+/**
+ * Convenience function used to generate ModuleMetadata for an app's Auth related modules and FirebaseServerAuthService provider.
+ *
+ * @param provide
+ * @param useFactory
+ * @returns
+ */
+function firebaseServerAuthModuleMetadata(config) {
+    return nestjs.mergeModuleMetadata({
+        imports: [exports.FirebaseServerAuthModule],
+        exports: [exports.FirebaseServerAuthModule, config.serviceProvider.provide],
+        providers: provideFirebaseServerAuthService(config.serviceProvider)
+    }, config);
+}
+
+function assertIsAdminInRequest(request) {
+    if (!isAdminInRequest(request)) {
+        throw forbiddenError();
+    }
+}
+function isAdminInRequest(request) {
+    return request.nest.authService.context(request).isAdmin;
+}
+function assertIsAdminOrTargetUserInRequestData(request, requireUid) {
+    if (!isAdminOrTargetUserInRequestData(request, requireUid)) {
+        throw forbiddenError();
+    }
+    return request.data.uid ?? request.auth?.uid;
+}
+function isAdminOrTargetUserInRequestData(request, requireUid = false) {
+    const uid = request.data.uid;
+    const authUid = request.auth?.uid;
+    let isAdminOrTargetUser = true;
+    if ((requireUid && uid == null) || (uid != null && uid !== authUid)) {
+        isAdminOrTargetUser = request.nest.authService.context(request).isAdmin;
+    }
+    return isAdminOrTargetUser;
+}
+function assertHasSignedTosInRequest(request) {
+    if (!hasSignedTosInRequest(request)) {
+        throw forbiddenError({
+            message: 'ToS has not been signed.'
+        });
+    }
+}
+function hasSignedTosInRequest(request) {
+    return request.nest.authService.context(request).hasSignedTos;
+}
+function assertHasRolesInRequest(request, authRoles) {
+    if (!hasAuthRolesInRequest(request, authRoles)) {
+        throw forbiddenError({
+            message: 'Missing required auth roles.',
+            data: {
+                roles: util.asArray(authRoles)
+            }
+        });
+    }
+}
+function hasAuthRolesInRequest(request, authRoles) {
+    return util.containsAllValues(request.nest.authService.context(request).authRoles, authRoles);
+}
+/**
+ * Returns true if the claims have a FIREBASE_SERVER_AUTH_CLAIMS_SETUP_PASSWORD_KEY claims value, indicating they are a newly invited user.
+ *
+ * This may be used to filter out new users that were not invited from finishing their onboarding.
+ *
+ * @param request
+ */
+function hasNewUserSetupPasswordInRequest(request) {
+    const claims = request.nest.authService.context(request).claims;
+    return claims[firebase.FIREBASE_SERVER_AUTH_CLAIMS_SETUP_PASSWORD_KEY] != null;
+}
+
+/**
+ * Creates a OnCallWithAuthorizedNestContext function for creating a model.
+ *
+ * @param map
+ * @returns
+ */
+function onCallDevelopmentFunction(map, config = {}) {
+    const { preAssert = () => undefined } = config;
+    return (request) => {
+        const specifier = request.data.specifier;
+        const devFn = map[specifier];
+        if (devFn) {
+            preAssert({ request, specifier });
+            return devFn({
+                ...request,
+                specifier,
+                data: request.data.data
+            });
+        }
+        else {
+            throw developmentUnknownSpecifierError(specifier);
+        }
+    };
+}
+function developmentUnknownSpecifierError(specifier) {
+    return badRequestError(util.serverError({
+        status: 400,
+        code: 'UNKNOWN_SPECIFIER_ERROR',
+        message: `Invalid specifier "${specifier}" to run.`,
+        data: {
+            specifier
+        }
+    }));
+}
+
+const NO_RUN_NAME_SPECIFIED_FOR_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_CODE = 'NO_RUN_NAME_SPECIFIED_FOR_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION';
+function noRunNameSpecifiedForScheduledFunctionDevelopmentFunction() {
+    return badRequestError({
+        code: NO_RUN_NAME_SPECIFIED_FOR_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_CODE,
+        message: `Must specify run parameter.`
+    });
+}
+const UNKNOWN_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_NAME_CODE = 'UNKNOWN_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_NAME';
+function unknownScheduledFunctionDevelopmentFunctionName(name) {
+    return badRequestError({
+        code: UNKNOWN_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_NAME_CODE,
+        message: `Unknown function with name "${name}"`,
+        data: {
+            name
+        }
+    });
+}
+const UNKNOWN_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_TYPE_CODE = 'UNKNOWN_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_TYPE';
+function unknownScheduledFunctionDevelopmentFunctionType(type) {
+    return badRequestError({
+        code: UNKNOWN_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_TYPE_CODE,
+        message: `Unknown type "${type}"`,
+        data: {
+            type
+        }
+    });
+}
+
+function makeScheduledFunctionDevelopmentFunction(config) {
+    const { allScheduledFunctions } = config;
+    const getListValues = util.cachedGetter(() => {
+        const result = [];
+        util.forEachKeyValue(allScheduledFunctions, {
+            forEach: (x) => {
+                const [functionName, config] = x;
+                result.push({
+                    name: functionName.toString()
+                });
+            }
+        });
+        return result;
+    });
+    return async (request) => {
+        const { data } = request;
+        const { type } = data;
+        switch (type) {
+            case 'run':
+                const targetRunName = data.run;
+                if (!targetRunName) {
+                    throw noRunNameSpecifiedForScheduledFunctionDevelopmentFunction();
+                }
+                const targetFunction = allScheduledFunctions[targetRunName];
+                if (!targetFunction) {
+                    throw unknownScheduledFunctionDevelopmentFunctionName(targetRunName);
+                }
+                try {
+                    await targetFunction._runNow();
+                }
+                catch (e) {
+                    console.error(`Failed manually running task "${targetRunName}".`, e);
+                    throw e;
+                }
+                return {
+                    type: 'run',
+                    success: true
+                };
+            case 'list':
+                return {
+                    type: 'list',
+                    list: getListValues()
+                };
+            default:
+                throw unknownScheduledFunctionDevelopmentFunctionType(type);
+        }
+    };
+}
+
+function setNestContextOnRequest(makeNestContext, request) {
+    request.nest = makeNestContext(request.nestApplication);
+    return request;
+}
+/**
+ * Wraps the input OnCallWithNestContext function to flag it as optional to have auth data.
+ *
+ * @param fn
+ * @returns
+ */
+function optionalAuthContext(fn) {
+    const fnWithOptionalAuth = ((request) => fn(request));
+    fnWithOptionalAuth._requireAuth = false;
+    return fnWithOptionalAuth;
+}
+/**
+ * Asserts that the input request has auth data if the inputOnCallWithAuthAwareNestRequireAuthRef object is flagged to require auth.
+ *
+ * @param fn
+ * @param request
+ */
+function assertRequestRequiresAuthForFunction(fn, request) {
+    if (fn._requireAuth !== false) {
+        assertIsContextWithAuthData(request);
+    }
+}
+/**
+ * Creates an OnCallWithNestContext wrapper that validates the input CallableContext to assert the context has auth data before entering the function.
+ *
+ * @param fn
+ * @returns
+ */
+function inAuthContext(fn) {
+    return (request) => {
+        assertIsContextWithAuthData(request);
+        return fn(request);
+    };
+}
+
+function firebaseServerDevFunctions(config) {
+    const { enabled, secure, nest, developerFunctionsMap, onCallFactory, allScheduledFunctions, disableDevelopmentScheduleFunction } = config;
+    let dev;
+    if (enabled) {
+        const fullFunctionsMap = {
+            ...developerFunctionsMap
+        };
+        if (allScheduledFunctions && disableDevelopmentScheduleFunction !== false) {
+            fullFunctionsMap[firebase.SCHEDULED_FUNCTION_DEV_FUNCTION_SPECIFIER] = makeScheduledFunctionDevelopmentFunction({
+                allScheduledFunctions
+            });
+        }
+        let onCallFunction = onCallDevelopmentFunction(fullFunctionsMap);
+        if (secure != false) {
+            onCallFunction = inAuthContext(onCallFunction);
+        }
+        dev = onCallFactory(onCallFunction)(nest);
+    }
+    else {
+        dev = onCallFactory(async (x) => {
+            throw unavailableError({
+                message: 'developer tools service is not enabled.'
+            });
+        })(nest);
+    }
+    return {
+        dev
+    };
+}
+
+exports.DefaultFirebaseServerEnvService = class DefaultFirebaseServerEnvService extends nestjs.ServerEnvironmentService {
+    /**
+     * Enabled when not in production and not in a testing environment.
+     */
+    get developmentSchedulerEnabled() {
+        return !this.isProduction && !this.isTestingEnv;
+    }
+};
+exports.DefaultFirebaseServerEnvService = __decorate([
+    common.Injectable()
+], exports.DefaultFirebaseServerEnvService);
+
+function nestAppIsProductionEnvironment(nest) {
+    return () => nest().then((x) => x.get(FirebaseServerEnvService).isProduction);
+}
+function nestAppHasDevelopmentSchedulerEnabled(nest) {
+    return () => nest().then((x) => x.get(FirebaseServerEnvService).developmentSchedulerEnabled);
+}
+
+// MARK: Tokens
+/**
+ * Token to access the Firestore.
+ */
+const FIREBASE_FIRESTORE_TOKEN = 'FIREBASE_FIRESTORE_TOKEN';
+/**
+ * Token to access the root FirestoreContext for a server.
+ */
+const FIREBASE_FIRESTORE_CONTEXT_TOKEN = 'FIREBASE_FIRESTORE_CONTEXT_TOKEN';
+/**
+ * Nest provider module for Firebase that provides a firestore, etc. from the firestore token.
+ */
+exports.FirebaseServerFirestoreModule = class FirebaseServerFirestoreModule {
+};
+exports.FirebaseServerFirestoreModule = __decorate([
+    common.Module({
+        providers: [
+            {
+                provide: FIREBASE_FIRESTORE_TOKEN,
+                useFactory: (app) => app.firestore(),
+                inject: [FIREBASE_APP_TOKEN]
+            }
+        ],
+        exports: [FIREBASE_FIRESTORE_TOKEN]
+    })
+], exports.FirebaseServerFirestoreModule);
+/**
+ * Nest provider module for firebase that includes the FirebaseServerFirestoreModule and provides a value for FIRESTORE_CONTEXT_TOKEN using the googleCloudFirestoreContextFactory.
+ */
+exports.FirebaseServerFirestoreContextModule = class FirebaseServerFirestoreContextModule {
+};
+exports.FirebaseServerFirestoreContextModule = __decorate([
+    common.Module({
+        imports: [exports.FirebaseServerFirestoreModule],
+        providers: [
+            {
+                provide: FIREBASE_FIRESTORE_CONTEXT_TOKEN,
+                useFactory: googleCloudFirestoreContextFactory,
+                inject: [FIREBASE_FIRESTORE_TOKEN]
+            }
+        ],
+        exports: [exports.FirebaseServerFirestoreModule, FIREBASE_FIRESTORE_CONTEXT_TOKEN]
+    })
+], exports.FirebaseServerFirestoreContextModule);
+/**
+ * Used to configure a Nestjs provider for a FirestoreCollections-type object that is initialized with a FirestoreContext.
+ *
+ * @param type
+ * @param useFactory
+ * @returns
+ */
+function provideAppFirestoreCollections({ provide, useFactory }) {
+    return [
+        {
+            provide,
+            useFactory,
+            inject: [FIREBASE_FIRESTORE_CONTEXT_TOKEN]
+        }
+    ];
+}
+/**
+ * Convenience function used to generate ModuleMetadata for an app's Firestore related modules and an appFirestoreCollection
+ *
+ * @param provide
+ * @param useFactory
+ * @returns
+ */
+function appFirestoreModuleMetadata(config) {
+    return {
+        imports: [exports.FirebaseServerFirestoreContextModule, ...(config.imports ?? [])],
+        exports: [exports.FirebaseServerFirestoreContextModule, config.provide, ...(config.exports ?? [])],
+        providers: [...provideAppFirestoreCollections(config), ...(config.providers ?? [])]
+    };
+}
+
+/**
+ * Creates a BlockingFunctionWithHandler from the input.
+ *
+ * @param blockingFunctionBuilder
+ * @param handler
+ * @returns
+ */
+function makeBlockingFunctionWithHandler(blockingFunctionBuilder, handler, opts) {
+    const blockingFn = opts != null ? blockingFunctionBuilder(opts, handler) : blockingFunctionBuilder(handler);
+    blockingFn.__handler = handler;
+    return blockingFn;
+}
+/**
+ * Creates a BlockingFunctionHandlerWithNestContextFactory.
+ *
+ * @param appFactory
+ * @param makeNestContext
+ * @returns
+ */
+function blockingFunctionHandlerWithNestContextFactory(makeNestContext) {
+    return (fn) => {
+        return (nestAppPromiseGetter) => {
+            const handlerBuilder = (handler) => {
+                const fnHandler = (event) => nestAppPromiseGetter().then((nestApplication) => handler({
+                    ...event,
+                    nest: makeNestContext(nestApplication)
+                }));
+                return fnHandler;
+            };
+            return fn(handlerBuilder);
+        };
+    };
+}
+
+/**
+ * Creates a factory for generating OnCallWithNestApplication (firebase-functions v2) functions.
+ *
+ * @param opts
+ * @returns
+ */
+function onCallHandlerWithNestApplicationFactory(defaultOpts = {}) {
+    return (fn, opts) => {
+        return (nestAppPromiseGetter) => v2.https.onCall({ ...defaultOpts, ...opts }, (request) => nestAppPromiseGetter().then((nestApplication) => fn({
+            ...request,
+            nestApplication
+        })));
+    };
+}
+/**
+ * Creates a factory for generating OnCallWithNestContext functions with a nest context object that is generated by the input function.
+ *
+ * @param appFactory
+ * @param makeNestContext
+ * @returns
+ */
+function onCallHandlerWithNestContextFactory(appFactory, makeNestContext) {
+    return (fn, opts) => appFactory((request) => fn(setNestContextOnRequest(makeNestContext, request)), opts);
+}
+
+/**
+ * Creates a CloudEventHandlerWithNestContextFactory.
+ *
+ * @param appFactory
+ * @param makeNestContext
+ * @returns
+ */
+function cloudEventHandlerWithNestContextFactory(makeNestContext) {
+    return (fn) => {
+        return (nestAppPromiseGetter) => {
+            const handlerBuilder = (handler) => {
+                const fnHandler = (event) => nestAppPromiseGetter().then((nestApplication) => handler({
+                    ...event,
+                    nest: makeNestContext(nestApplication)
+                }));
+                return fnHandler;
+            };
+            return fn(handlerBuilder);
+        };
+    };
+}
+
+function setNestContextOnScheduleRequest(makeNestContext, request) {
+    request.nest = makeNestContext(request.nestApplication);
+    return request;
+}
+
+function makeOnScheduleHandlerWithNestApplicationRequest(nestApplication, scheduleContext) {
+    return {
+        nestApplication,
+        scheduleContext
+    };
+}
+/**
+ * Creates a factory for generating OnCallWithNestApplication functions.
+ *
+ * @param nestAppPromiseGetter
+ * @returns
+ */
+function onScheduleHandlerWithNestApplicationFactory(baseScheduleConfig) {
+    return (inputSchedule, fn) => {
+        const schedule = util.mergeObjects([baseScheduleConfig, inputSchedule]);
+        if (!schedule.schedule) {
+            if (schedule.cron) {
+                if (typeof schedule.cron === 'number') {
+                    schedule.schedule = util.cronExpressionRepeatingEveryNMinutes(schedule.cron);
+                }
+                else {
+                    schedule.schedule = schedule.cron;
+                }
+            }
+            else {
+                throw new Error('Missing required "cron" or "schedule" variable for configuration.');
+            }
+        }
+        return (nestAppPromiseGetter) => {
+            const runNow = (scheduleContext) => nestAppPromiseGetter().then((x) => fn(makeOnScheduleHandlerWithNestApplicationRequest(x, scheduleContext)));
+            const fnn = v2.scheduler.onSchedule(schedule, runNow);
+            fnn._schedule = schedule;
+            fnn._runNow = runNow;
+            return fnn;
+        };
+    };
+}
+/**
+ * Creates a factory for generating OnCallWithNestContext functions with a nest context object that is generated by the input function.
+ *
+ * @param appFactory
+ * @param makeNestContext
+ * @returns
+ */
+function onScheduleHandlerWithNestContextFactory(appFactory, makeNestContext) {
+    return (schedule, fn) => appFactory(schedule, (request) => fn(setNestContextOnScheduleRequest(makeNestContext, request)));
+}
+
+/**
+ * Creates a TaskQueueFunctionHandlerWithNestContextFactory.
+ *
+ * @param appFactory
+ * @param makeNestContext
+ * @returns
+ */
+function taskQueueFunctionHandlerWithNestContextFactory(makeNestContext) {
+    return (fn) => {
+        return (nestAppPromiseGetter) => {
+            const handlerBuilder = (handler) => {
+                const fnHandler = (taskRequest) => nestAppPromiseGetter().then((nestApplication) => handler({
+                    ...taskRequest,
+                    nest: makeNestContext(nestApplication)
+                }));
+                return fnHandler;
+            };
+            return fn(handlerBuilder);
+        };
+    };
+}
+// TODO(FUTURE): Add factory that also adds onTaskDispatched usage, as the above is incomplete for full usage and only sets up a function for the request.
+
+class AbstractFirebaseServerActionsContext {
+}
+function firebaseServerActionsContext(options) {
+    return {
+        ...firebaseServerActionsTransformContext(options)
+    };
+}
+const defaultFirebaseServerActionsTransformFactoryLogErrorFunction = (details) => {
+    console.log('firebaseServerActionsTransformFactory() encountered validation error: ', details);
+};
+function firebaseServerActionsTransformContext(options) {
+    const firebaseServerActionTransformFactory = firebaseServerActionsTransformFactory(options);
+    const firebaseServerActionTransformFunctionFactory = model.toTransformAndValidateFunctionResultFactory(firebaseServerActionTransformFactory);
+    return {
+        firebaseServerActionTransformFactory,
+        firebaseServerActionTransformFunctionFactory
+    };
+}
+const FIREBASE_SERVER_VALIDATION_ERROR_CODE = 'VALIDATION_ERROR';
+/**
+ *
+ * @param validationError
+ * @returns
+ */
+function firebaseServerValidationServerError(validationError) {
+    const nestValidationExceptionFactory = new common.ValidationPipe({
+        forbidUnknownValues: false
+    }).createExceptionFactory();
+    const nestError = nestValidationExceptionFactory(validationError);
+    const data = nestError.getResponse();
+    return {
+        message: 'One or more data/form validation errors occurred.',
+        code: FIREBASE_SERVER_VALIDATION_ERROR_CODE,
+        data
+    };
+}
+/**
+ * Creates a new badRequestError with the validation error details as the response data.
+ *
+ * @param validationError
+ * @returns
+ */
+function firebaseServerValidationError(validationError) {
+    const serverError = firebaseServerValidationServerError(validationError);
+    return badRequestError(serverError);
+}
+function firebaseServerActionsTransformFactory(options) {
+    const { logError, defaultValidationOptions } = options ?? {};
+    const logErrorFunction = logError !== false ? (typeof logError === 'function' ? logError : defaultFirebaseServerActionsTransformFactoryLogErrorFunction) : util.mapIdentityFunction;
+    return model.transformAndValidateObjectFactory({
+        handleValidationError: (validationError) => {
+            const serverError = firebaseServerValidationServerError(validationError);
+            const { data } = serverError;
+            logErrorFunction(data);
+            throw badRequestError(serverError);
+        },
+        defaultValidationOptions
+    });
+}
+
+function injectNestIntoRequest(nest, request) {
+    return {
+        ...request,
+        nest
+    };
+}
+function injectNestApplicationContextIntoRequest(nestContext, request) {
+    return {
+        ...request,
+        nestApplication: nestContext
+    };
+}
+
+/**
+ * Can be injected to retrieve information about the global prefix configured for the app.
+ */
+class GlobalRoutePrefixConfig {
+    globalApiRoutePrefix;
+}
+
+/**
+ * Middleware that verifies the X-Firebase-AppCheck header using admin.
+ *
+ * It ignores all webhook paths by default.
+ */
+exports.FirebaseAppCheckMiddleware = class FirebaseAppCheckMiddleware {
+    globalRoutePrefixConfig;
+    logger = new common.Logger('FirebaseAppCheckMiddleware');
+    _ignoredWebhookPath;
+    constructor(globalRoutePrefixConfig) {
+        this.globalRoutePrefixConfig = globalRoutePrefixConfig;
+        this._ignoredWebhookPath = this.globalRoutePrefixConfig?.globalApiRoutePrefix ? `${this.globalRoutePrefixConfig.globalApiRoutePrefix}${nestjs.DEFAULT_BASE_WEBHOOK_PATH}` : nestjs.DEFAULT_BASE_WEBHOOK_PATH;
+    }
+    async use(req, res, next) {
+        const isIgnoredRoute = this.isIgnoredRequest(req);
+        let error;
+        if (!isIgnoredRoute) {
+            error = await verifyAppCheckInRequest(req);
+            if (error) {
+                this.logger.error('app check token failed verify');
+            }
+        }
+        next(error);
+    }
+    isIgnoredRequest(req) {
+        const isIgnoredRoute = req.skipAppCheck || this.isIgnoredPath(req.baseUrl);
+        return isIgnoredRoute;
+    }
+    isIgnoredPath(path) {
+        return path.startsWith(this._ignoredWebhookPath);
+    }
+};
+exports.FirebaseAppCheckMiddleware = __decorate([
+    common.Injectable(),
+    __param(0, common.Optional()),
+    __param(0, common.Inject(GlobalRoutePrefixConfig)),
+    __metadata("design:paramtypes", [Object])
+], exports.FirebaseAppCheckMiddleware);
+/**
+ * Verifies the AppCheck parameter. If it fails, a value is returned.
+ *
+ * @param req
+ * @param res
+ * @param next
+ * @returns
+ */
+async function verifyAppCheckInRequest(req) {
+    const appCheckToken = req.header('X-Firebase-AppCheck');
+    let error;
+    if (!appCheckToken) {
+        error = new common.ForbiddenException();
+    }
+    else {
+        // verify the token
+        try {
+            await admin.appCheck().verifyToken(appCheckToken);
+        }
+        catch (e) {
+            error = new common.ForbiddenException();
+        }
+    }
+    return error;
+}
+
+/**
+ * Convenience class that mirrors the ConfigureAppCheckMiddlewareModule class in @dereekb/nestjs, but for Firebase apps.
+ */
+exports.ConfigureFirebaseAppCheckMiddlewareModule = class ConfigureFirebaseAppCheckMiddlewareModule {
+    logger = new common.Logger('ConfigureFirebaseAppCheckMiddlewareModule');
+    configure(consumer) {
+        consumer.apply(exports.FirebaseAppCheckMiddleware).forRoutes('*');
+        this.logger.debug('Configured firebase webhook routes with proper middleware.');
+    }
+};
+exports.ConfigureFirebaseAppCheckMiddlewareModule = __decorate([
+    common.Module({})
+], exports.ConfigureFirebaseAppCheckMiddlewareModule);
+
+/**
+ * nestjs decorator that will instruct FirebaseAppCheckMiddleware to skip AppCheck for related requests.
+ */
+const SkipAppCheck = common.createParamDecorator(async (_, context) => {
+    const req = context.switchToHttp().getRequest();
+    req.skipAppCheck = true;
+});
+
+exports.FirebaseRawBodyMiddleware = class FirebaseRawBodyMiddleware {
+    use(req, res, next) {
+        req.body = req.rawBody;
+        next();
+    }
+};
+exports.FirebaseRawBodyMiddleware = __decorate([
+    common.Injectable()
+], exports.FirebaseRawBodyMiddleware);
+
+/**
+ * Convenience class that mirrors the ConfigureWebhookMiddlewareModule class in @dereekb/nestjs, but for Firebase apps.
+ *
+ * Requests to /webhook/* have their request.body value set to the rawBody.
+ */
+exports.ConfigureFirebaseWebhookMiddlewareModule = class ConfigureFirebaseWebhookMiddlewareModule {
+    logger = new common.Logger('ConfigureFirebaseWebhookMiddlewareModule');
+    configure(consumer) {
+        consumer.apply(exports.FirebaseRawBodyMiddleware).forRoutes(nestjs.DEFAULT_WEBHOOK_MIDDLEWARE_ROUTE_INFO);
+        this.logger.debug('Configured firebase webhook routes with proper middleware.');
+    }
+};
+exports.ConfigureFirebaseWebhookMiddlewareModule = __decorate([
+    common.Module({})
+], exports.ConfigureFirebaseWebhookMiddlewareModule);
+
+const nestFirebaseDoesNotExistError = (firebaseContextGrantedModelRoles) => {
+    return modelNotAvailableError({
+        data: {
+            id: firebaseContextGrantedModelRoles.data?.document.key,
+            type: firebaseContextGrantedModelRoles.data?.document.modelType
+        }
+    });
+};
+const nestFirebaseForbiddenPermissionError = (firebaseContextGrantedModelRoles, roles) => {
+    return forbiddenError({
+        data: {
+            id: firebaseContextGrantedModelRoles.data?.document.key,
+            type: firebaseContextGrantedModelRoles.data?.document.modelType,
+            roles
+        }
+    });
+};
+
+function onCallSpecifierHandler(config) {
+    const map = util.objectToMap(config);
+    const fn = (request) => {
+        const { specifier = firebase.MODEL_FUNCTION_FIREBASE_CRUD_FUNCTION_SPECIFIER_DEFAULT } = request;
+        const handler = map.get(specifier);
+        if (handler != null) {
+            assertRequestRequiresAuthForFunction(handler, request);
+            return handler(request);
+        }
+        else {
+            throw unknownModelCrudFunctionSpecifierError(specifier);
+        }
+    };
+    fn._requireAuth = false;
+    return fn;
+}
+function unknownModelCrudFunctionSpecifierError(specifier) {
+    return badRequestError(util.serverError({
+        status: 400,
+        code: 'UNKNOWN_SPECIFIER_ERROR',
+        message: 'Invalid/unknown specifier for this function.',
+        data: {
+            specifier
+        }
+    }));
+}
+
+/**
+ * Creates a OnCallWithAuthorizedNestContext function for creating a model.
+ *
+ * @param map
+ * @returns
+ */
+function onCallModel(map, config = {}) {
+    const { preAssert = () => undefined } = config;
+    return (request) => {
+        const call = request.data?.call;
+        if (call) {
+            const callFn = map[call];
+            if (callFn) {
+                const { specifier, modelType } = request.data;
+                preAssert({ call, request, modelType, specifier });
+                return callFn(request);
+            }
+            else {
+                throw onCallModelUnknownCallTypeError(call);
+            }
+        }
+        else {
+            throw onCallModelMissingCallTypeError();
+        }
+    };
+}
+function onCallModelMissingCallTypeError() {
+    return badRequestError(util.serverError({
+        status: 400,
+        code: 'CALL_TYPE_MISSING_ERROR',
+        message: `The call type was missing from the request.`
+    }));
+}
+function onCallModelUnknownCallTypeError(call) {
+    return badRequestError(util.serverError({
+        status: 400,
+        code: 'UNKNOWN_CALL_TYPE_ERROR',
+        message: `Unknown call type "${call}".`,
+        data: {
+            call
+        }
+    }));
+}
+function _onCallWithCallTypeFunction(map, config) {
+    const { callType, crudType, preAssert = () => undefined, throwOnUnknownModelType } = config;
+    return (request) => {
+        const modelType = request.data?.modelType;
+        const crudFn = map[modelType];
+        if (crudFn) {
+            const specifier = request.data.specifier;
+            assertRequestRequiresAuthForFunction(crudFn, request);
+            preAssert({ call: callType, request, modelType, specifier });
+            return crudFn({
+                ...request,
+                specifier,
+                data: request.data.data
+            });
+        }
+        else {
+            throw throwOnUnknownModelType(modelType);
+        }
+    };
+}
+
+function onCallCreateModel(map, config = {}) {
+    const { preAssert } = config;
+    return _onCallWithCallTypeFunction(map, {
+        callType: 'create',
+        crudType: 'create',
+        preAssert,
+        throwOnUnknownModelType: createModelUnknownModelTypeError
+    });
+}
+function createModelUnknownModelTypeError(modelType) {
+    return badRequestError(util.serverError({
+        status: 400,
+        code: 'UNKNOWN_TYPE_ERROR',
+        message: `Invalid type "${modelType}" to create.`,
+        data: {
+            modelType
+        }
+    }));
+}
+
+function onCallReadModel(map, config = {}) {
+    const { preAssert } = config;
+    return _onCallWithCallTypeFunction(map, {
+        callType: 'read',
+        crudType: 'read',
+        preAssert,
+        throwOnUnknownModelType: readModelUnknownModelTypeError
+    });
+}
+function readModelUnknownModelTypeError(modelType) {
+    return badRequestError(util.serverError({
+        status: 400,
+        code: 'UNKNOWN_TYPE_ERROR',
+        message: 'Invalid type to read.',
+        data: {
+            modelType
+        }
+    }));
+}
+
+function onCallUpdateModel(map, config = {}) {
+    const { preAssert } = config;
+    return _onCallWithCallTypeFunction(map, {
+        callType: 'update',
+        crudType: 'update',
+        preAssert,
+        throwOnUnknownModelType: updateModelUnknownModelTypeError
+    });
+}
+function updateModelUnknownModelTypeError(modelType) {
+    return badRequestError(util.serverError({
+        status: 400,
+        code: 'UNKNOWN_TYPE_ERROR',
+        message: 'Invalid type to update.',
+        data: {
+            modelType
+        }
+    }));
+}
+
+function onCallDeleteModel(map, config = {}) {
+    const { preAssert } = config;
+    return _onCallWithCallTypeFunction(map, {
+        callType: 'delete',
+        crudType: 'delete',
+        preAssert,
+        throwOnUnknownModelType: deleteModelUnknownModelTypeError
+    });
+}
+function deleteModelUnknownModelTypeError(modelType) {
+    return badRequestError(util.serverError({
+        status: 400,
+        code: 'UNKNOWN_TYPE_ERROR',
+        message: 'Invalid type to delete.',
+        data: {
+            modelType
+        }
+    }));
+}
+
+function googleCloudStorageBucketForStorageFilePath(storage, path) {
+    return storage.bucket(path.bucketId);
+}
+function googleCloudStorageFileForStorageFilePath(storage, path) {
+    return googleCloudStorageBucketForStorageFilePath(storage, path).file(path.pathString);
+}
+function googleCloudFileMetadataToStorageMetadata(file, metadata) {
+    const fullPath = file.name;
+    const generation = String(metadata.generation ?? file.generation);
+    const metageneration = String(metadata.metageneration);
+    const size = Number(metadata.size);
+    const customMetadata = metadata.metadata;
+    return {
+        bucket: file.bucket.name,
+        fullPath,
+        generation,
+        metageneration,
+        name: file.name,
+        size,
+        timeCreated: metadata.timeCreated,
+        updated: metadata.updated,
+        md5Hash: metadata.md5Hash,
+        cacheControl: metadata.cacheControl,
+        contentDisposition: metadata.contentDisposition,
+        contentEncoding: metadata.contentEncoding,
+        contentLanguage: metadata.contentLanguage,
+        contentType: metadata.contentType,
+        customMetadata
+    };
+}
+function googleCloudStorageAccessorFile(storage$1, storagePath) {
+    const file = googleCloudStorageFileForStorageFilePath(storage$1, storagePath);
+    function makeDownloadOptions(maxDownloadSizeBytes) {
+        return {
+            ...(maxDownloadSizeBytes
+                ? {
+                    // end is inclusive
+                    end: maxDownloadSizeBytes - 1
+                }
+                : undefined)
+        };
+    }
+    function _configureMetadata(options) {
+        const customMetadata = util.filterUndefinedValues({
+            ...options.metadata?.customMetadata,
+            ...options?.customMetadata
+        });
+        return util.filterUndefinedValues({
+            cacheControl: options.metadata?.cacheControl,
+            contentDisposition: options.metadata?.contentDisposition,
+            contentEncoding: options.metadata?.contentEncoding,
+            contentLanguage: options.metadata?.contentLanguage,
+            contentType: options.metadata?.contentType,
+            metadata: !util.objectHasNoKeys(customMetadata) ? customMetadata : undefined
+        });
+    }
+    function makeUploadOptions(options) {
+        let metadata;
+        if (options != null) {
+            metadata = _configureMetadata({
+                metadata: {
+                    ...options.metadata,
+                    contentType: options.contentType ?? options.metadata?.contentType
+                },
+                customMetadata: options.customMetadata
+            });
+        }
+        return {
+            // non-resumable
+            resumable: false,
+            // add content type and other custom metadata
+            ...(metadata ? { metadata } : undefined)
+        };
+    }
+    function asFileMetadata(metadata) {
+        return _configureMetadata({ metadata });
+    }
+    function makeStoragePathForPath(newPath) {
+        let path;
+        if (typeof newPath === 'string') {
+            path = {
+                bucketId: file.bucket.name,
+                pathString: newPath
+            };
+        }
+        else {
+            path = newPath;
+        }
+        return path;
+    }
+    async function copy(newPath, options) {
+        const newStoragePath = makeStoragePathForPath(newPath);
+        const newFile = googleCloudStorageAccessorFile(storage$1, newStoragePath);
+        return _copyWithFile(newFile, options);
+    }
+    async function _copyWithFile(newFile, options) {
+        const copyOptions = {
+            ...options
+        };
+        await file.copy(newFile.reference, copyOptions);
+        return newFile;
+    }
+    /**
+     * Configuration for the public ACL.
+     */
+    const PUBLIC_ACL = {
+        entity: 'allUsers',
+        role: 'READER'
+    };
+    const accessorFile = {
+        reference: file,
+        storagePath,
+        exists: () => file.exists().then((x) => x[0]),
+        getDownloadUrl: () => file.getMetadata().then(() => file.publicUrl()),
+        getSignedUrl: async (input) => {
+            const expires = input?.expiresAt ??
+                (input?.expiresIn != null
+                    ? dateFns.addMilliseconds(new Date(), input.expiresIn) // use expiresIn if provided
+                    : dateFns.addHours(new Date(), 1)); // default expiration in 1 hour
+            const config = {
+                ...input,
+                action: input?.action ?? 'read',
+                expires,
+                expiresIn: undefined, // clear from input
+                expiresAt: undefined
+            };
+            return file
+                .getSignedUrl(config)
+                .then((x) => x[0])
+                .catch((e) => {
+                let publicUrlBackup;
+                if (e && e.name === 'SigningError' && (nestjs.isTestNodeEnv() || process.env.FIREBASE_STORAGE_EMULATOR_HOST)) {
+                    // NOTE: Signing does not behave properly in the emulator as it is not supported.
+                    // https://github.com/firebase/firebase-tools/issues/3400
+                    // we can return the public url instead.
+                    // This is fine, as in production this file url is protected by ACLs anyways.
+                    publicUrlBackup = file.publicUrl();
+                }
+                else {
+                    throw e;
+                }
+                return publicUrlBackup;
+            });
+        },
+        getMetadata: () => file.getMetadata().then((x) => googleCloudFileMetadataToStorageMetadata(file, x[0])),
+        setMetadata: (metadata) => file.setMetadata(asFileMetadata(metadata)).then((x) => googleCloudFileMetadataToStorageMetadata(file, x[0])),
+        getBytes: (maxDownloadSizeBytes) => file.download(makeDownloadOptions(maxDownloadSizeBytes)).then((x) => x[0]),
+        getStream: (maxDownloadSizeBytes) => file.createReadStream(makeDownloadOptions(maxDownloadSizeBytes)),
+        upload: async (input, options) => {
+            let dataToUpload;
+            if (typeof input === 'string') {
+                const parsedStringFormat = firebase.assertStorageUploadOptionsStringFormat(options);
+                const stringFormat = parsedStringFormat === 'raw' ? 'utf-8' : parsedStringFormat;
+                if (stringFormat === 'data_url') {
+                    // TODO(FUTURE): support this later if necessary. Server should really never see this type.
+                    throw new Error('"data_url" is unsupported.');
+                }
+                dataToUpload = Buffer.from(input, stringFormat);
+            }
+            else {
+                if (Buffer.isBuffer(input)) {
+                    dataToUpload = input;
+                }
+                else if (types.isUint8Array(input)) {
+                    dataToUpload = Buffer.from(input);
+                }
+                else {
+                    // NOTE: these values shouldn't ever be encountered in the NodeJS environment. May remove later.
+                    if (types.isArrayBuffer(input)) {
+                        dataToUpload = Buffer.from(input);
+                    }
+                    else {
+                        dataToUpload = input.arrayBuffer().then((x) => Buffer.from(x));
+                    }
+                }
+            }
+            const data = await dataToUpload;
+            return file.save(data, makeUploadOptions(options));
+        },
+        uploadStream: (options) => file.createWriteStream(makeUploadOptions(options)),
+        move: async (newPath, options) => {
+            const newStoragePath = makeStoragePathForPath(newPath);
+            const newFile = googleCloudStorageAccessorFile(storage$1, newStoragePath);
+            const moveOptions = {
+                ...options
+            };
+            await file.moveFileAtomic(newFile.reference, moveOptions).catch(async (e) => {
+                if (e instanceof storage.ApiError && e.response?.statusMessage === 'Not Implemented') {
+                    // NOTE: This is not implemented in storage emulator, so it will fail with this error in testing.
+                    // https://github.com/firebase/firebase-tools/issues/3751
+                    // we can perform the same task using copy and then deleting this file.
+                    await copy(newPath, moveOptions);
+                    await accessorFile.delete();
+                }
+                else {
+                    throw e;
+                }
+            });
+            return newFile;
+        },
+        copy,
+        delete: (options) => file.delete(options).then((x) => undefined),
+        isPublic: () => file.isPublic().then((x) => x[0]),
+        makePublic: (setPublic) => (setPublic !== false ? file.acl.add(PUBLIC_ACL) : file.acl.delete({ entity: PUBLIC_ACL.entity })).then(() => undefined),
+        makePrivate: (options) => file.makePrivate(options).then(() => undefined),
+        getAcls: (options) => file.acl.get(options).then((x) => ({ acls: x[0], metadata: x[1] }))
+    };
+    return accessorFile;
+}
+const googleCloudStorageListFilesResultFactory = firebase.storageListFilesResultFactory({
+    hasItems(result) {
+        return Boolean(result.apiResponse.items || result.apiResponse.prefixes);
+    },
+    hasNext: (result) => {
+        return result.nextQuery != null;
+    },
+    nextPageTokenFromResult(result) {
+        return result.nextQuery?.pageToken;
+    },
+    next(storage, options, folder, result) {
+        return folder.list({ ...options, ...result.nextQuery });
+    },
+    file(storage, fileResult) {
+        return googleCloudStorageAccessorFile(storage, fileResult.storagePath);
+    },
+    folder(storage, folderResult) {
+        return googleCloudStorageAccessorFolder(storage, folderResult.storagePath);
+    },
+    filesFromResult(result) {
+        const items = result.apiResponse?.items ?? [];
+        return items.map((x) => ({ raw: x, name: util.slashPathName(x.name), storagePath: { bucketId: x.bucket, pathString: x.name } }));
+    },
+    foldersFromResult(result, folder) {
+        const items = result.apiResponse?.prefixes ?? [];
+        return items.map((prefix) => ({ raw: prefix, name: util.slashPathName(prefix), storagePath: { bucketId: folder.storagePath.bucketId, pathString: prefix } }));
+    }
+});
+function googleCloudStorageAccessorFolder(storage, storagePath) {
+    const bucket = googleCloudStorageBucketForStorageFilePath(storage, storagePath);
+    const file = bucket.file(storagePath.pathString);
+    const folder = {
+        reference: file,
+        storagePath,
+        exists: async () => folder.list({ maxResults: 1 }).then((x) => x.hasItems()),
+        list: (options) => {
+            const { maxResults, pageToken, includeNestedResults: listAll } = options ?? {};
+            const listOptions = {
+                maxResults,
+                pageToken,
+                autoPaginate: false,
+                versions: false,
+                ...(listAll
+                    ? {
+                        prefix: util.toRelativeSlashPathStartType(util.fixMultiSlashesInSlashPath(storagePath.pathString + '/'))
+                    }
+                    : {
+                        // includeTrailingDelimiter: true,
+                        delimiter: util.SLASH_PATH_SEPARATOR,
+                        prefix: util.toRelativeSlashPathStartType(util.fixMultiSlashesInSlashPath(storagePath.pathString + '/')) // make sure the folder always ends with a slash
+                    })
+            };
+            return bucket.getFiles(listOptions).then((x) => {
+                const files = x[0];
+                const nextQuery = x[1];
+                const apiResponse = x[2];
+                const result = {
+                    files: files,
+                    nextQuery,
+                    apiResponse: apiResponse
+                };
+                return googleCloudStorageListFilesResultFactory(storage, folder, options, result);
+            });
+        }
+    };
+    return folder;
+}
+function googleCloudStorageFirebaseStorageAccessorDriver() {
+    return {
+        type: 'server',
+        file: (storage, path) => googleCloudStorageAccessorFile(storage, path),
+        folder: (storage, path) => googleCloudStorageAccessorFolder(storage, path)
+    };
+}
+
+function googleCloudFirebaseStorageDrivers() {
+    return {
+        storageDriverIdentifier: '@google-cloud/storage',
+        storageDriverType: 'production',
+        storageAccessorDriver: googleCloudStorageFirebaseStorageAccessorDriver()
+    };
+}
+
+/**
+ * Basic service that implements FirebaseStorageAccessor and provides a FirebaseStorageContext.
+ */
+class FirebaseServerStorageService {
+    _storageContext;
+    constructor(storageContext) {
+        this._storageContext = storageContext;
+    }
+    get storageContext() {
+        return this._storageContext;
+    }
+    defaultBucket() {
+        return this.storageContext.defaultBucket();
+    }
+    file(path) {
+        return this.storageContext.file(path);
+    }
+    folder(path) {
+        return this.storageContext.folder(path);
+    }
+}
+
+/**
+ * Creates a FirestoreContextFactory that uses the @google-cloud/storage package.
+ */
+const googleCloudFirebaseStorageContextFactory = firebase.firebaseStorageContextFactory(googleCloudFirebaseStorageDrivers());
+/**
+ * Retrieves the GoogleCloudStorage object from the input FirebaseAdmin Storage type.
+ *
+ * @param storage
+ * @returns
+ */
+function googleCloudStorageFromFirebaseAdminStorage(storage) {
+    return storage.storageClient;
+}
+
+// MARK: Tokens
+/**
+ * Token to access the Storage.
+ */
+const FIREBASE_STORAGE_TOKEN = 'FIREBASE_STORAGE_TOKEN';
+/**
+ * Token to access the root StorageContext for a server.
+ */
+const FIREBASE_STORAGE_CONTEXT_TOKEN = 'FIREBASE_STORAGE_CONTEXT_TOKEN';
+/**
+ * Token to the default bucket id string
+ */
+const FIREBASE_STORAGE_CONTEXT_FACTORY_CONFIG_TOKEN = 'FIREBASE_STORAGE_CONTEXT_FACTORY_CONFIG_TOKEN';
+/**
+ * Nest provider module for Firebase that provides a firestore, etc. from the firestore token.
+ */
+exports.FirebaseServerStorageModule = class FirebaseServerStorageModule {
+};
+exports.FirebaseServerStorageModule = __decorate([
+    common.Module({
+        providers: [
+            {
+                provide: FIREBASE_STORAGE_TOKEN,
+                useFactory: (app) => googleCloudStorageFromFirebaseAdminStorage(app.storage()),
+                inject: [FIREBASE_APP_TOKEN]
+            }
+        ],
+        exports: [FIREBASE_STORAGE_TOKEN]
+    })
+], exports.FirebaseServerStorageModule);
+/**
+ * Nest provider module for firebase that includes the FirebaseServerStorageModule and provides a value for STORAGE_CONTEXT_TOKEN using the googleCloudStorageContextFactory.
+ */
+exports.FirebaseServerStorageContextModule = class FirebaseServerStorageContextModule {
+};
+exports.FirebaseServerStorageContextModule = __decorate([
+    common.Module({
+        imports: [exports.FirebaseServerStorageModule],
+        providers: [
+            {
+                provide: FIREBASE_STORAGE_CONTEXT_TOKEN,
+                useFactory: googleCloudFirebaseStorageContextFactory,
+                inject: [FIREBASE_STORAGE_TOKEN, FIREBASE_STORAGE_CONTEXT_FACTORY_CONFIG_TOKEN]
+            }
+        ],
+        exports: [exports.FirebaseServerStorageModule, FIREBASE_STORAGE_CONTEXT_TOKEN]
+    })
+], exports.FirebaseServerStorageContextModule);
+// MARK: Token Configuration
+function firebaseServerStorageDefaultBucketIdTokenProvider(input) {
+    const config = typeof input === 'string' ? { defaultBucketId: input } : input;
+    if (!config.defaultBucketId) {
+        throw new Error('Non-empty defaultBucketId is required.');
+    }
+    return {
+        provide: FIREBASE_STORAGE_CONTEXT_FACTORY_CONFIG_TOKEN,
+        useValue: config
+    };
+}
+function defaultProvideFirebaseServerStorageServiceSimple() {
+    return {
+        provide: FirebaseServerStorageService,
+        useFactory: (context) => new FirebaseServerStorageService(context)
+    };
+}
+function provideFirebaseServerStorageService(provider) {
+    const providers = [
+        {
+            ...provider,
+            inject: provider.inject ?? [FIREBASE_STORAGE_CONTEXT_TOKEN]
+        }
+    ];
+    if (provider.provide !== FirebaseServerStorageService) {
+        providers.push({
+            provide: FirebaseServerStorageService,
+            useExisting: provider.provide
+        });
+    }
+    return providers;
+}
+/**
+ * Convenience function used to generate ModuleMetadata for an app's Auth related modules and FirebaseServerStorageService provider.
+ *
+ * @param provide
+ * @param useFactory
+ * @returns
+ */
+function firebaseServerStorageModuleMetadata(config) {
+    const serviceProvider = config && config.serviceProvider ? config.serviceProvider : defaultProvideFirebaseServerStorageServiceSimple();
+    const providers = provideFirebaseServerStorageService(serviceProvider);
+    const tokensToExport = nestjs.injectionTokensFromProviders(providers);
+    return nestjs.mergeModuleMetadata({
+        imports: [exports.FirebaseServerStorageContextModule],
+        exports: [exports.FirebaseServerStorageContextModule, ...tokensToExport],
+        providers
+    }, config);
+}
+
+class FirebaseNestServerRootModule {
+}
+function nestServerInstance(config) {
+    const { moduleClass, providers: additionalProviders, defaultStorageBucket: inputDefaultStorageBucket, forceStorageBucket, globalApiRoutePrefix, configureNestServerInstance } = config;
+    const serversCache = new Map();
+    const initNestServer = (firebaseApp, env) => {
+        const appName = firebaseApp.name;
+        const defaultStorageBucket = inputDefaultStorageBucket ?? firebaseApp.options.storageBucket;
+        let nestServer = serversCache.get(appName);
+        if (!nestServer) {
+            const server = express();
+            const createNestServer = async (expressInstance) => {
+                const providers = [firebaseServerAppTokenProvider(util.asGetter(firebaseApp))];
+                // configure environment providers
+                if (env?.environment != null) {
+                    providers.push(nestjs.serverEnvTokenProvider(env.environment));
+                    if (config.configureEnvService !== false) {
+                        providers.push({
+                            provide: FirebaseServerEnvService,
+                            useClass: exports.DefaultFirebaseServerEnvService
+                        }, {
+                            provide: nestjs.ServerEnvironmentService,
+                            useExisting: FirebaseServerEnvService
+                        });
+                    }
+                }
+                if (additionalProviders) {
+                    util.pushItemOrArrayItemsIntoArray(providers, additionalProviders);
+                }
+                const imports = [moduleClass];
+                // NOTE: https://cloud.google.com/functions/docs/writing/http#parsing_http_requests
+                const options = { bodyParser: false }; // firebase already parses the requests
+                if (config.configureWebhooks) {
+                    imports.push(exports.ConfigureFirebaseWebhookMiddlewareModule);
+                }
+                if (config.appCheckEnabled != false) {
+                    imports.push(exports.ConfigureFirebaseAppCheckMiddlewareModule);
+                }
+                if (defaultStorageBucket) {
+                    providers.push(firebaseServerStorageDefaultBucketIdTokenProvider({
+                        defaultBucketId: defaultStorageBucket,
+                        forceBucket: forceStorageBucket
+                    }));
+                }
+                // provide the global prefix config to the app
+                providers.push({
+                    provide: GlobalRoutePrefixConfig,
+                    useValue: {
+                        globalApiRoutePrefix
+                    }
+                });
+                const providersModule = {
+                    module: FirebaseNestServerRootModule,
+                    imports,
+                    providers,
+                    exports: providers,
+                    global: true
+                };
+                let nestApp = await core.NestFactory.create(providersModule, new platformExpress.ExpressAdapter(expressInstance), options);
+                if (globalApiRoutePrefix) {
+                    nestApp = nestApp.setGlobalPrefix(globalApiRoutePrefix);
+                }
+                if (configureNestServerInstance) {
+                    nestApp = configureNestServerInstance(nestApp) || nestApp;
+                }
+                return nestApp.init();
+            };
+            const nest = createNestServer(server).catch((err) => {
+                console.error('Nest failed startup.', err);
+                throw err;
+            });
+            nestServer = { server, nest: util.makeGetter(nest) };
+            serversCache.set(appName, nestServer);
+        }
+        return nestServer;
+    };
+    const removeNestServer = async (firebaseApp) => {
+        const appName = firebaseApp.name;
+        const nestServer = serversCache.get(appName);
+        let removed;
+        if (nestServer) {
+            removed = nestServer.nest().then((x) => {
+                serversCache.delete(appName);
+                return x.close().then(() => true);
+            });
+        }
+        else {
+            removed = Promise.resolve(false);
+        }
+        return removed;
+    };
+    return {
+        moduleClass,
+        initNestServer,
+        removeNestServer
+    };
+}
+
+/**
+ * Abstract class that wraps an INestApplicationContext value.
+ */
+class AbstractNestContext {
+    _nest;
+    constructor(nest) {
+        this._nest = nest;
+    }
+    get nest() {
+        return this._nest;
+    }
+}
+class AbstractFirebaseNestContext extends AbstractNestContext {
+    /**
+     * FirebasePermissionErrorContextErrorFunction to use with makeModelContext().
+     *
+     * Defaults to nestFirebaseForbiddenPermissionError().
+     */
+    makePermissionError = nestFirebaseForbiddenPermissionError;
+    /**
+     * FirebaseDoesNotExistErrorContextErrorFunction to use with makeModelContext().
+     *
+     * Defaults to nestFirebaseDoesNotExistError().
+     *
+     * Some configurations may prefer to use nestFirebaseForbiddenPermissionError instead, which returns a forbidden error instead.
+     * This prevents the leaking of information about the existence of an object.
+     */
+    makeDoesNotExistError = nestFirebaseDoesNotExistError;
+    get envService() {
+        return this.nest.get(FirebaseServerEnvService);
+    }
+    get storageService() {
+        return this.nest.get(FirebaseServerStorageService);
+    }
+    /**
+     * Creates a FirebaseAppModelContext instance.
+     *
+     * @param auth
+     * @param buildFn
+     * @returns
+     */
+    makeModelContext(auth, buildFn) {
+        const base = {
+            auth: this.authService.authContextInfo(auth),
+            app: this.app,
+            makePermissionError: this.makePermissionError,
+            makeDoesNotExistError: this.makeDoesNotExistError
+        };
+        return buildFn
+            ? util.build({
+                base,
+                build: buildFn
+            })
+            : base;
+    }
+    /**
+     * Creates a InContextFirebaseModelsService given the input context and parameters.
+     *
+     * @param context
+     * @param buildFn
+     * @returns
+     */
+    model(context, buildFn) {
+        const firebaseModelContext = this.makeModelContext(context, buildFn);
+        return firebase.inContextFirebaseModelsServiceFactory(this.firebaseModelsService)(firebaseModelContext);
+    }
+    async useModel(type, select) {
+        const context = this.makeModelContext(select.request, select.buildFn);
+        const usePromise = firebase.useFirebaseModelsService(this.firebaseModelsService, type, {
+            context,
+            key: select.key,
+            roles: select.roles,
+            rolesSetIncludes: select.rolesSetIncludes
+        });
+        const use = select.use ?? ((x) => x);
+        return usePromise(use);
+    }
+}
+
+exports.ALREADY_EXISTS_ERROR_CODE = ALREADY_EXISTS_ERROR_CODE;
+exports.AbstractFirebaseNestContext = AbstractFirebaseNestContext;
+exports.AbstractFirebaseServerActionsContext = AbstractFirebaseServerActionsContext;
+exports.AbstractFirebaseServerAuthContext = AbstractFirebaseServerAuthContext;
+exports.AbstractFirebaseServerAuthService = AbstractFirebaseServerAuthService;
+exports.AbstractFirebaseServerAuthUserContext = AbstractFirebaseServerAuthUserContext;
+exports.AbstractFirebaseServerNewUserService = AbstractFirebaseServerNewUserService;
+exports.AbstractNestContext = AbstractNestContext;
+exports.BAD_REQUEST_ERROR_CODE = BAD_REQUEST_ERROR_CODE;
+exports.CONFLICT_ERROR_CODE = CONFLICT_ERROR_CODE;
+exports.DEFAULT_FIREBASE_PASSWORD_NUMBER_GENERATOR = DEFAULT_FIREBASE_PASSWORD_NUMBER_GENERATOR;
+exports.DEFAULT_SETUP_COM_THROTTLE_TIME = DEFAULT_SETUP_COM_THROTTLE_TIME;
+exports.FIREBASE_APP_TOKEN = FIREBASE_APP_TOKEN;
+exports.FIREBASE_AUTH_TOKEN = FIREBASE_AUTH_TOKEN;
+exports.FIREBASE_FIRESTORE_CONTEXT_TOKEN = FIREBASE_FIRESTORE_CONTEXT_TOKEN;
+exports.FIREBASE_FIRESTORE_TOKEN = FIREBASE_FIRESTORE_TOKEN;
+exports.FIREBASE_SERVER_VALIDATION_ERROR_CODE = FIREBASE_SERVER_VALIDATION_ERROR_CODE;
+exports.FIREBASE_STORAGE_CONTEXT_FACTORY_CONFIG_TOKEN = FIREBASE_STORAGE_CONTEXT_FACTORY_CONFIG_TOKEN;
+exports.FIREBASE_STORAGE_CONTEXT_TOKEN = FIREBASE_STORAGE_CONTEXT_TOKEN;
+exports.FIREBASE_STORAGE_TOKEN = FIREBASE_STORAGE_TOKEN;
+exports.FIRESTORE_CLIENT_QUERY_CONSTRAINT_HANDLER_MAPPING = FIRESTORE_CLIENT_QUERY_CONSTRAINT_HANDLER_MAPPING;
+exports.FORBIDDEN_ERROR_CODE = FORBIDDEN_ERROR_CODE;
+exports.FirebaseNestServerRootModule = FirebaseNestServerRootModule;
+exports.FirebaseServerAuthNewUserSendSetupDetailsNoSetupConfigError = FirebaseServerAuthNewUserSendSetupDetailsNoSetupConfigError;
+exports.FirebaseServerAuthNewUserSendSetupDetailsSendOnceError = FirebaseServerAuthNewUserSendSetupDetailsSendOnceError;
+exports.FirebaseServerAuthNewUserSendSetupDetailsThrottleError = FirebaseServerAuthNewUserSendSetupDetailsThrottleError;
+exports.FirebaseServerAuthService = FirebaseServerAuthService;
+exports.FirebaseServerEnvService = FirebaseServerEnvService;
+exports.FirebaseServerStorageService = FirebaseServerStorageService;
+exports.INTERNAL_SERVER_ERROR_CODE = INTERNAL_SERVER_ERROR_CODE;
+exports.MODEL_NOT_AVAILABLE_ERROR_CODE = MODEL_NOT_AVAILABLE_ERROR_CODE;
+exports.NOT_FOUND_ERROR_CODE = NOT_FOUND_ERROR_CODE;
+exports.NO_RUN_NAME_SPECIFIED_FOR_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_CODE = NO_RUN_NAME_SPECIFIED_FOR_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_CODE;
+exports.NoSetupContentFirebaseServerNewUserService = NoSetupContentFirebaseServerNewUserService;
+exports.PERMISSION_DENIED_ERROR_CODE = PERMISSION_DENIED_ERROR_CODE;
+exports.PHONE_NUMBER_ALREADY_EXISTS_ERROR_CODE = PHONE_NUMBER_ALREADY_EXISTS_ERROR_CODE;
+exports.SkipAppCheck = SkipAppCheck;
+exports.UNAUTHENTICATED_ERROR_CODE = UNAUTHENTICATED_ERROR_CODE;
+exports.UNAVAILABLE_ERROR_CODE = UNAVAILABLE_ERROR_CODE;
+exports.UNAVAILABLE_OR_DEACTIVATED_FUNCTION_ERROR_CODE = UNAVAILABLE_OR_DEACTIVATED_FUNCTION_ERROR_CODE;
+exports.UNKNOWN_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_NAME_CODE = UNKNOWN_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_NAME_CODE;
+exports.UNKNOWN_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_TYPE_CODE = UNKNOWN_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_TYPE_CODE;
+exports._onCallWithCallTypeFunction = _onCallWithCallTypeFunction;
+exports.alreadyExistsError = alreadyExistsError;
+exports.appFirestoreModuleMetadata = appFirestoreModuleMetadata;
+exports.assertContextHasAuth = assertContextHasAuth;
+exports.assertDocumentExists = assertDocumentExists;
+exports.assertHasRolesInRequest = assertHasRolesInRequest;
+exports.assertHasSignedTosInRequest = assertHasSignedTosInRequest;
+exports.assertIsAdminInRequest = assertIsAdminInRequest;
+exports.assertIsAdminOrTargetUserInRequestData = assertIsAdminOrTargetUserInRequestData;
+exports.assertIsContextWithAuthData = assertIsContextWithAuthData;
+exports.assertRequestRequiresAuthForFunction = assertRequestRequiresAuthForFunction;
+exports.assertSnapshotData = assertSnapshotData;
+exports.assertSnapshotDataWithKey = assertSnapshotDataWithKey;
+exports.badRequestError = badRequestError;
+exports.blockingFunctionHandlerWithNestContextFactory = blockingFunctionHandlerWithNestContextFactory;
+exports.cloudEventHandlerWithNestContextFactory = cloudEventHandlerWithNestContextFactory;
+exports.collectionRefForPath = collectionRefForPath;
+exports.createModelUnknownModelTypeError = createModelUnknownModelTypeError;
+exports.defaultFirebaseServerActionsTransformFactoryLogErrorFunction = defaultFirebaseServerActionsTransformFactoryLogErrorFunction;
+exports.defaultProvideFirebaseServerStorageServiceSimple = defaultProvideFirebaseServerStorageServiceSimple;
+exports.deleteModelUnknownModelTypeError = deleteModelUnknownModelTypeError;
+exports.developmentUnknownSpecifierError = developmentUnknownSpecifierError;
+exports.docRefForPath = docRefForPath;
+exports.documentModelNotAvailableError = documentModelNotAvailableError;
+exports.firebaseAuthTokenFromDecodedIdToken = firebaseAuthTokenFromDecodedIdToken;
+exports.firebaseServerActionsContext = firebaseServerActionsContext;
+exports.firebaseServerActionsTransformContext = firebaseServerActionsTransformContext;
+exports.firebaseServerActionsTransformFactory = firebaseServerActionsTransformFactory;
+exports.firebaseServerAppTokenProvider = firebaseServerAppTokenProvider;
+exports.firebaseServerAuthModuleMetadata = firebaseServerAuthModuleMetadata;
+exports.firebaseServerDevFunctions = firebaseServerDevFunctions;
+exports.firebaseServerErrorInfo = firebaseServerErrorInfo;
+exports.firebaseServerErrorInfoCodePair = firebaseServerErrorInfoCodePair;
+exports.firebaseServerErrorInfoServerErrorCodePair = firebaseServerErrorInfoServerErrorCodePair;
+exports.firebaseServerErrorInfoServerErrorPair = firebaseServerErrorInfoServerErrorPair;
+exports.firebaseServerStorageDefaultBucketIdTokenProvider = firebaseServerStorageDefaultBucketIdTokenProvider;
+exports.firebaseServerStorageModuleMetadata = firebaseServerStorageModuleMetadata;
+exports.firebaseServerValidationError = firebaseServerValidationError;
+exports.firebaseServerValidationServerError = firebaseServerValidationServerError;
+exports.firestoreClientQueryConstraintFunctionsDriver = firestoreClientQueryConstraintFunctionsDriver;
+exports.firestoreServerIncrementUpdateToUpdateData = firestoreServerIncrementUpdateToUpdateData;
+exports.forbiddenError = forbiddenError;
+exports.getAuthUserOrUndefined = getAuthUserOrUndefined;
+exports.googleCloudFileMetadataToStorageMetadata = googleCloudFileMetadataToStorageMetadata;
+exports.googleCloudFirebaseStorageContextFactory = googleCloudFirebaseStorageContextFactory;
+exports.googleCloudFirebaseStorageDrivers = googleCloudFirebaseStorageDrivers;
+exports.googleCloudFirestoreAccessorDriver = googleCloudFirestoreAccessorDriver;
+exports.googleCloudFirestoreContextFactory = googleCloudFirestoreContextFactory;
+exports.googleCloudFirestoreDrivers = googleCloudFirestoreDrivers;
+exports.googleCloudFirestoreQueryDriver = googleCloudFirestoreQueryDriver;
+exports.googleCloudStorageAccessorFile = googleCloudStorageAccessorFile;
+exports.googleCloudStorageAccessorFolder = googleCloudStorageAccessorFolder;
+exports.googleCloudStorageBucketForStorageFilePath = googleCloudStorageBucketForStorageFilePath;
+exports.googleCloudStorageFileForStorageFilePath = googleCloudStorageFileForStorageFilePath;
+exports.googleCloudStorageFirebaseStorageAccessorDriver = googleCloudStorageFirebaseStorageAccessorDriver;
+exports.googleCloudStorageFromFirebaseAdminStorage = googleCloudStorageFromFirebaseAdminStorage;
+exports.googleCloudStorageListFilesResultFactory = googleCloudStorageListFilesResultFactory;
+exports.handleFirebaseAuthError = handleFirebaseAuthError;
+exports.handleFirebaseError = handleFirebaseError;
+exports.hasAuthRolesInRequest = hasAuthRolesInRequest;
+exports.hasNewUserSetupPasswordInRequest = hasNewUserSetupPasswordInRequest;
+exports.hasSignedTosInRequest = hasSignedTosInRequest;
+exports.inAuthContext = inAuthContext;
+exports.injectNestApplicationContextIntoRequest = injectNestApplicationContextIntoRequest;
+exports.injectNestIntoRequest = injectNestIntoRequest;
+exports.internalServerError = internalServerError;
+exports.isAdminInRequest = isAdminInRequest;
+exports.isAdminOrTargetUserInRequestData = isAdminOrTargetUserInRequestData;
+exports.isContextWithAuthData = isContextWithAuthData;
+exports.isFirebaseError = isFirebaseError;
+exports.isFirebaseHttpsError = isFirebaseHttpsError;
+exports.makeBlockingFunctionWithHandler = makeBlockingFunctionWithHandler;
+exports.makeOnScheduleHandlerWithNestApplicationRequest = makeOnScheduleHandlerWithNestApplicationRequest;
+exports.makeScheduledFunctionDevelopmentFunction = makeScheduledFunctionDevelopmentFunction;
+exports.modelNotAvailableError = modelNotAvailableError;
+exports.nestAppHasDevelopmentSchedulerEnabled = nestAppHasDevelopmentSchedulerEnabled;
+exports.nestAppIsProductionEnvironment = nestAppIsProductionEnvironment;
+exports.nestFirebaseDoesNotExistError = nestFirebaseDoesNotExistError;
+exports.nestFirebaseForbiddenPermissionError = nestFirebaseForbiddenPermissionError;
+exports.nestServerInstance = nestServerInstance;
+exports.noRunNameSpecifiedForScheduledFunctionDevelopmentFunction = noRunNameSpecifiedForScheduledFunctionDevelopmentFunction;
+exports.notFoundError = notFoundError;
+exports.onCallCreateModel = onCallCreateModel;
+exports.onCallDeleteModel = onCallDeleteModel;
+exports.onCallDevelopmentFunction = onCallDevelopmentFunction;
+exports.onCallHandlerWithNestApplicationFactory = onCallHandlerWithNestApplicationFactory;
+exports.onCallHandlerWithNestContextFactory = onCallHandlerWithNestContextFactory;
+exports.onCallModel = onCallModel;
+exports.onCallModelMissingCallTypeError = onCallModelMissingCallTypeError;
+exports.onCallModelUnknownCallTypeError = onCallModelUnknownCallTypeError;
+exports.onCallReadModel = onCallReadModel;
+exports.onCallSpecifierHandler = onCallSpecifierHandler;
+exports.onCallUpdateModel = onCallUpdateModel;
+exports.onScheduleHandlerWithNestApplicationFactory = onScheduleHandlerWithNestApplicationFactory;
+exports.onScheduleHandlerWithNestContextFactory = onScheduleHandlerWithNestContextFactory;
+exports.optionalAuthContext = optionalAuthContext;
+exports.permissionDeniedError = permissionDeniedError;
+exports.phoneNumberAlreadyExistsError = phoneNumberAlreadyExistsError;
+exports.preconditionConflictError = preconditionConflictError;
+exports.provideAppFirestoreCollections = provideAppFirestoreCollections;
+exports.provideFirebaseServerAuthService = provideFirebaseServerAuthService;
+exports.provideFirebaseServerStorageService = provideFirebaseServerStorageService;
+exports.readModelUnknownModelTypeError = readModelUnknownModelTypeError;
+exports.setNestContextOnRequest = setNestContextOnRequest;
+exports.setNestContextOnScheduleRequest = setNestContextOnScheduleRequest;
+exports.taskQueueFunctionHandlerWithNestContextFactory = taskQueueFunctionHandlerWithNestContextFactory;
+exports.unauthenticatedContextHasNoAuthData = unauthenticatedContextHasNoAuthData;
+exports.unauthenticatedContextHasNoUidError = unauthenticatedContextHasNoUidError;
+exports.unauthenticatedError = unauthenticatedError;
+exports.unavailableError = unavailableError;
+exports.unavailableOrDeactivatedFunctionError = unavailableOrDeactivatedFunctionError;
+exports.unknownModelCrudFunctionSpecifierError = unknownModelCrudFunctionSpecifierError;
+exports.unknownScheduledFunctionDevelopmentFunctionName = unknownScheduledFunctionDevelopmentFunctionName;
+exports.unknownScheduledFunctionDevelopmentFunctionType = unknownScheduledFunctionDevelopmentFunctionType;
+exports.updateModelUnknownModelTypeError = updateModelUnknownModelTypeError;
+exports.userContextFromUid = userContextFromUid;
+exports.verifyAppCheckInRequest = verifyAppCheckInRequest;