@dereekb/firebase-server 12.6.21 → 13.0.0

package/index.cjs.js

@@ -0,0 +1,2937 @@
+'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');
+require('core-js/modules/es.iterator.constructor.js');
+require('core-js/modules/es.iterator.for-each.js');
+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');
+require('core-js/modules/es.iterator.map.js');
+var storage = require('@google-cloud/storage');
+var dateFns = require('date-fns');
+var types = require('util/types');
+require('core-js/modules/es.map.get-or-insert.js');
+require('core-js/modules/es.map.get-or-insert-computed.js');
+var core = require('@nestjs/core');
+var platformExpress = require('@nestjs/platform-express');
+var express = require('express');
+
+/**
+ * @deprecated use DBX_FIREBASE_SERVER_NO_AUTH_ERROR_CODE instead
+ */
+const NO_AUTH_ERROR_CODE = firebase.DBX_FIREBASE_SERVER_NO_AUTH_ERROR_CODE;
+function unauthenticatedContextHasNoAuthData() {
+  return unauthenticatedError({
+    message: 'expected auth',
+    code: NO_AUTH_ERROR_CODE
+  });
+}
+/**
+ * @deprecated use DBX_FIREBASE_SERVER_NO_UID_ERROR_CODE instead
+ */
+const NO_UID_ERROR_CODE = firebase.DBX_FIREBASE_SERVER_NO_AUTH_ERROR_CODE;
+function unauthenticatedContextHasNoUidError() {
+  return unauthenticatedError({
+    message: 'no user uid',
+    code: NO_UID_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 {
+  constructor(lastSentAt) {
+    super(`This user was recently sent details. Try again later.`);
+    this.lastSentAt = void 0;
+    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 {
+  constructor(service, uid) {
+    this._service = void 0;
+    this._uid = void 0;
+    this._loadRecord = util.cachedGetter(() => this._service.auth.getUser(this._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 {
+  constructor(service, context) {
+    this._service = void 0;
+    this._context = void 0;
+    this._authRoles = util.cachedGetter(() => this.service.readRoles(this.claims));
+    this._isAdmin = util.cachedGetter(() => this.service.isAdminInRoles(this._authRoles()));
+    this._hasSignedTos = util.cachedGetter(() => this.service.hasSignedTosInRoles(this._authRoles()));
+    this._userContext = util.cachedGetter(() => this.service.userContext(this.context.auth.uid));
+    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 {
+  constructor(authService) {
+    this._authService = void 0;
+    this.setupThrottleTime = DEFAULT_SETUP_COM_THROTTLE_TIME;
+    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 {
+  constructor(auth) {
+    this._auth = void 0;
+    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 {
+  constructor(batch, documentRef) {
+    this.documentRef = void 0;
+    this._batch = void 0;
+    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 {
+  constructor(batch) {
+    this._batch = void 0;
+    this.contextType = firebase.FirestoreDocumentContextType.BATCH;
+    this.accessorFactory = void 0;
+    this._batch = batch;
+    this.accessorFactory = writeBatchAccessorFactory(batch);
+  }
+  get batch() {
+    return this._batch;
+  }
+}
+function writeBatchDocumentContext(batch) {
+  return new WriteBatchFirestoreDocumentContext(batch);
+}
+
+// MARK: Accessor
+class DefaultFirestoreDocumentDataAccessor {
+  constructor(documentRef) {
+    this._documentRef = void 0;
+    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 {
+  constructor(transaction, documentRef) {
+    this._transaction = void 0;
+    this._documentRef = void 0;
+    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 {
+  constructor(transaction) {
+    this._transaction = void 0;
+    this.contextType = firebase.FirestoreDocumentContextType.TRANSACTION;
+    this.accessorFactory = void 0;
+    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 {
+  constructor() {
+    this.globalApiRoutePrefix = void 0;
+  }
+}
+
+/**
+ * Middleware that verifies the X-Firebase-AppCheck header using admin.
+ *
+ * It ignores all webhook paths by default.
+ */
+exports.FirebaseAppCheckMiddleware = class FirebaseAppCheckMiddleware {
+  constructor(globalRoutePrefixConfig) {
+    this.globalRoutePrefixConfig = void 0;
+    this.logger = new common.Logger('FirebaseAppCheckMiddleware');
+    this._ignoredWebhookPath = void 0;
+    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 {
+  constructor() {
+    this.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 {
+  constructor() {
+    this.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 {
+  constructor(storageContext) {
+    this._storageContext = void 0;
+    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 {
+  constructor(nest) {
+    this._nest = void 0;
+    this._nest = nest;
+  }
+  get nest() {
+    return this._nest;
+  }
+}
+class AbstractFirebaseNestContext extends AbstractNestContext {
+  constructor(...args) {
+    super(...args);
+    /**
+     * FirebasePermissionErrorContextErrorFunction to use with makeModelContext().
+     *
+     * Defaults to nestFirebaseForbiddenPermissionError().
+     */
+    this.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.
+     */
+    this.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_AUTH_ERROR_CODE = NO_AUTH_ERROR_CODE;
+exports.NO_RUN_NAME_SPECIFIED_FOR_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_CODE = NO_RUN_NAME_SPECIFIED_FOR_SCHEDULED_FUNCTION_DEVELOPMENT_FUNCTION_CODE;
+exports.NO_UID_ERROR_CODE = NO_UID_ERROR_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;