@dereekb/firebase-server 13.0.0 → 13.0.2

package/index.cjs.js

@@ -5,8 +5,6 @@ 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');
@@ -14,152 +12,141 @@ 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
-  });
+    return unauthenticatedError({
+        message: 'expected auth',
+        code: firebase.DBX_FIREBASE_SERVER_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
-  });
+    return unauthenticatedError({
+        message: 'no user uid',
+        code: firebase.DBX_FIREBASE_SERVER_NO_AUTH_ERROR_CODE
+    });
 }
 // MARK: General Errors
 const UNAUTHENTICATED_ERROR_CODE = 'UNAUTHENTICATED';
 function unauthenticatedError(messageOrError) {
-  const serverError = util.partialServerError(messageOrError);
-  return new https.HttpsError('unauthenticated', serverError?.message || 'unauthenticated', {
-    status: 401,
-    code: UNAUTHENTICATED_ERROR_CODE,
-    ...serverError,
-    _error: undefined
-  });
+    const 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 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 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 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 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 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 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 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 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 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
-  });
+    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;
+    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;
+    return typeof input === 'object' && input.code != null && input.message != null && input.toJSON != null;
 }
 /**
  * Creates a FirebaseServerErrorInfo from the input.
@@ -168,73 +155,74 @@ function isFirebaseError(input) {
  * @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
-  };
+    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];
+    const info = firebaseServerErrorInfo(e);
+    return [info.firebaseErrorCode, info];
 }
 function firebaseServerErrorInfoServerErrorPair(e) {
-  const info = firebaseServerErrorInfo(e);
-  return [info.httpsErrorDetailsServerError, info];
+    const info = firebaseServerErrorInfo(e);
+    return [info.httpsErrorDetailsServerError, info];
 }
 function firebaseServerErrorInfoServerErrorCodePair(e) {
-  const info = firebaseServerErrorInfo(e);
-  return [info.serverErrorCode, info];
+    const info = firebaseServerErrorInfo(e);
+    return [info.serverErrorCode, info];
 }
 function handleFirebaseError(e, handleFirebaseErrorFn) {
-  const firebaseError = e.code ? e : undefined;
-  if (firebaseError) {
-    handleFirebaseErrorFn(firebaseError);
-  }
+    const firebaseError = e.code ? e : undefined;
+    if (firebaseError) {
+        handleFirebaseErrorFn(firebaseError);
+    }
 }
 
 function isContextWithAuthData(context) {
-  return Boolean(context.auth !== null && context.auth?.uid);
+    return Boolean(context.auth !== null && context.auth?.uid);
 }
 function assertIsContextWithAuthData(context) {
-  if (!isContextWithAuthData(context)) {
-    throw unauthenticatedContextHasNoAuthData();
-  }
+    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()
-  };
+    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()
+    };
 }
 
 /**
@@ -243,483 +231,458 @@ function firebaseAuthTokenFromDecodedIdToken(token) {
  * @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;
+    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.`);
-  }
+    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;
-  }
+    lastSentAt;
+    constructor(lastSentAt) {
+        super(`This user was recently sent details. Try again later.`);
+        this.lastSentAt = lastSentAt;
+    }
 }
 /**
  * Thrown by sendSetupDetails() if the user was recently sent details.
  */
 class FirebaseServerAuthNewUserSendSetupDetailsSendOnceError extends makeError.BaseError {
-  constructor() {
-    super(`The user has been sent details before and the sendSetupDetailsOnce configuration was true.`);
-  }
+    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
+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
-    });
-  }
+    _service;
+    _uid;
+    _loadRecord = util.cachedGetter(() => this._service.auth.getUser(this._uid));
+    constructor(service, uid) {
+        this._service = service;
+        this._uid = uid;
+    }
+    get service() {
+        return this._service;
+    }
+    get uid() {
+        return this._uid;
+    }
+    async exists() {
+        return getAuthUserOrUndefined(this._loadRecord()).then((x) => Boolean(x));
+    }
+    loadRecord() {
+        return this._loadRecord();
+    }
+    loadDetails() {
+        return this.loadRecord().then((record) => this.service.authDetailsForRecord(record));
+    }
+    _generateResetPasswordKey() {
+        return String(DEFAULT_FIREBASE_PASSWORD_NUMBER_GENERATOR());
+    }
+    async beginResetPassword() {
+        const password = this._generateResetPasswordKey();
+        const passwordClaimsData = {
+            [firebase.FIREBASE_SERVER_AUTH_CLAIMS_RESET_PASSWORD_KEY]: password,
+            [firebase.FIREBASE_SERVER_AUTH_CLAIMS_RESET_LAST_COM_DATE_KEY]: date.toISODateString(new Date())
+        };
+        // set the claims
+        await this.updateClaims(passwordClaimsData);
+        // update the user
+        await this.updateUser({ password });
+        return passwordClaimsData;
+    }
+    async loadResetPasswordClaims() {
+        const claims = await this.loadClaims();
+        if (claims.resetPassword != null) {
+            return claims;
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * Sets the user's password.
+     */
+    async setPassword(password) {
+        const record = await this.updateUser({ password });
+        // clear password reset claims
+        await this.updateClaims({
+            [firebase.FIREBASE_SERVER_AUTH_CLAIMS_RESET_PASSWORD_KEY]: null,
+            [firebase.FIREBASE_SERVER_AUTH_CLAIMS_RESET_LAST_COM_DATE_KEY]: null
+        });
+        return record;
+    }
+    async updateUser(template) {
+        return this.service.auth.updateUser(this.uid, template);
+    }
+    async loadRoles() {
+        const claims = await this.loadClaims();
+        return this.service.readRoles(claims);
+    }
+    async addRoles(roles) {
+        const claims = this._claimsForRolesChange(roles);
+        return this.updateClaims(claims);
+    }
+    async removeRoles(roles) {
+        const baseClaims = this._claimsForRolesChange(roles);
+        const claims = {};
+        util.forEachKeyValue(baseClaims, {
+            forEach: ([key]) => {
+                claims[key] = null; // set null on every key
+            },
+            filter: util.KeyValueTypleValueFilter.NONE // don't skip any key/value
+        });
+        return this.updateClaims(claims);
+    }
+    /**
+     * Sets the claims using the input roles and roles set.
+     *
+     * All other claims are cleared.
+     *
+     * Use the claimsToRetain input to retain other claims that are outside of the roles.
+     *
+     * @param roles
+     * @param claimsToRetain
+     * @returns
+     */
+    async setRoles(roles, claimsToRetain) {
+        const claims = {
+            ...claimsToRetain,
+            ...this._claimsForRolesChange(Array.from(roles))
+        };
+        return this.setClaims(claims);
+    }
+    _claimsForRolesChange(roles) {
+        // filter null/undefined since the claims will contain null values for claims that are not related.
+        return util.filterNullAndUndefinedValues(this.service.claimsForRoles(util.asSet(roles)));
+    }
+    loadClaims() {
+        return this.loadRecord().then((x) => (x.customClaims ?? {}));
+    }
+    async updateClaims(claims) {
+        const currentClaims = await this.loadClaims();
+        let newClaims;
+        if (currentClaims) {
+            newClaims = {
+                ...currentClaims,
+                ...util.filterUndefinedValues(claims, false)
+            };
+            newClaims = util.filterNullAndUndefinedValues(newClaims);
+        }
+        else {
+            newClaims = claims;
+        }
+        return this.setClaims(newClaims);
+    }
+    clearClaims() {
+        return this.setClaims(null);
+    }
+    setClaims(claims) {
+        return this.service.auth.setCustomUserClaims(this.uid, claims).then(() => {
+            this._loadRecord.reset(); // reset the cache
+        });
+    }
 }
 class AbstractFirebaseServerAuthContext {
-  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;
-  }
+    _service;
+    _context;
+    _authRoles = util.cachedGetter(() => this.service.readRoles(this.claims));
+    _isAdmin = util.cachedGetter(() => this.service.isAdminInRoles(this._authRoles()));
+    _hasSignedTos = util.cachedGetter(() => this.service.hasSignedTosInRoles(this._authRoles()));
+    _userContext = util.cachedGetter(() => this.service.userContext(this.context.auth.uid));
+    constructor(service, context) {
+        this._service = service;
+        this._context = context;
+    }
+    get service() {
+        return this._service;
+    }
+    get context() {
+        return this._context;
+    }
+    get userContext() {
+        return this._userContext();
+    }
+    get isAdmin() {
+        return this._isAdmin();
+    }
+    get hasSignedTos() {
+        return this._hasSignedTos();
+    }
+    get authRoles() {
+        return this._authRoles();
+    }
+    get token() {
+        return this.context.auth.token;
+    }
+    get claims() {
+        return this.context.auth.token;
+    }
+    // MARK: FirebaseServerAuthUserContext
+    get uid() {
+        return this.userContext.uid;
+    }
 }
 /**
  * 1 hour
  */
 const DEFAULT_SETUP_COM_THROTTLE_TIME = date.hoursToMs(1);
 function userContextFromUid(authService, userContextOrUid) {
-  const userContext = typeof userContextOrUid === 'string' ? authService.userContext(userContextOrUid) : userContextOrUid;
-  return userContext;
+    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
-    });
-  }
+    _authService;
+    setupThrottleTime = DEFAULT_SETUP_COM_THROTTLE_TIME;
+    constructor(authService) {
+        this._authService = authService;
+    }
+    get authService() {
+        return this._authService;
+    }
+    async initializeNewUser(input) {
+        const { uid, email, phone, sendSetupContent, sendSetupContentIfUserExists, sendSetupDetailsOnce, sendSetupIgnoreThrottle, sendSetupThrowErrors, data, sendDetailsInTestEnvironment } = input;
+        let userRecordPromise;
+        if (uid) {
+            userRecordPromise = this.authService.auth.getUser(uid);
+        }
+        else if (email) {
+            userRecordPromise = this.authService.auth.getUserByEmail(email);
+        }
+        else if (phone) {
+            userRecordPromise = this.authService.auth.getUserByPhoneNumber(phone);
+        }
+        else {
+            throw new Error('email or phone is required to initialize a new user.');
+        }
+        let userRecord = await getAuthUserOrUndefined(userRecordPromise);
+        let userRecordId;
+        let createdUser = false;
+        if (!userRecord) {
+            const createResult = await this.createNewUser(input);
+            // add the setup password to the user's credentials
+            const userContext = this.authService.userContext(createResult.user.uid);
+            await this.addNewUserSetupClaims(userContext, createResult.password);
+            createdUser = true;
+            userRecordId = userContext.uid;
+            userRecord = await userContext.loadRecord();
+        }
+        else {
+            userRecordId = userRecord.uid;
+        }
+        // send content if necessary
+        if ((createdUser && sendSetupContent === true) || sendSetupContentIfUserExists) {
+            const sentEmail = await this.sendSetupContent(userRecordId, { data, sendSetupDetailsOnce, ignoreSendThrottleTime: sendSetupIgnoreThrottle, throwErrors: sendSetupThrowErrors, sendDetailsInTestEnvironment });
+            // reload the user record
+            if (sentEmail) {
+                const userContext = this.authService.userContext(userRecordId);
+                userRecord = await userContext.loadRecord();
+            }
+        }
+        return userRecord;
+    }
+    async addNewUserSetupClaims(userContextOrUid, setupPassword) {
+        const password = setupPassword ?? this.generateRandomSetupPassword();
+        const userContext = userContextFromUid(this.authService, userContextOrUid);
+        await userContext.updateClaims({
+            [firebase.FIREBASE_SERVER_AUTH_CLAIMS_SETUP_PASSWORD_KEY]: password
+        });
+        return userContext;
+    }
+    async sendSetupContent(userContextOrUid, config) {
+        const setupDetails = await this.loadSetupDetails(userContextOrUid, config);
+        let sentContent = false;
+        if (setupDetails) {
+            const { setupCommunicationAt } = setupDetails.claims;
+            const hasSentCommunication = Boolean(setupCommunicationAt);
+            if (config?.sendSetupDetailsOnce && hasSentCommunication) {
+                // do not send.
+                if (config?.throwErrors) {
+                    throw new FirebaseServerAuthNewUserSendSetupDetailsSendOnceError();
+                }
+            }
+            else {
+                const lastSentAt = setupCommunicationAt ? new Date(setupCommunicationAt) : undefined;
+                const sendIsThrottled = hasSentCommunication && !config?.ignoreSendThrottleTime && util.isThrottled(this.setupThrottleTime, lastSentAt);
+                if (!sendIsThrottled) {
+                    await this.sendSetupContentToUser(setupDetails);
+                    await this.updateSetupContentSentTime(setupDetails);
+                    sentContent = true;
+                }
+                else if (config?.throwErrors) {
+                    throw new FirebaseServerAuthNewUserSendSetupDetailsThrottleError(lastSentAt);
+                }
+            }
+        }
+        else if (config?.throwErrors) {
+            throw new FirebaseServerAuthNewUserSendSetupDetailsNoSetupConfigError();
+        }
+        return sentContent;
+    }
+    async loadSetupDetails(userContextOrUid, config) {
+        const userContext = userContextFromUid(this.authService, userContextOrUid);
+        const userExists = await userContext.exists();
+        let details;
+        if (userExists) {
+            details = await this.loadSetupDetailsForUserContext(userContext, config);
+        }
+        return details;
+    }
+    async loadSetupDetailsForUserContext(userContext, config) {
+        let details;
+        const { setupPassword, setupCommunicationAt } = await userContext.loadClaims();
+        if (setupPassword) {
+            details = {
+                userContext,
+                claims: {
+                    setupPassword,
+                    setupCommunicationAt
+                },
+                data: config?.data,
+                sendDetailsInTestEnvironment: config?.sendDetailsInTestEnvironment
+            };
+        }
+        return details;
+    }
+    async updateSetupContentSentTime(details) {
+        const setupCommunicationAt = date.toISODateString(new Date());
+        await details.userContext.updateClaims({
+            setupCommunicationAt
+        });
+    }
+    /**
+     * Update a user's claims to clear any setup-related content.
+     *
+     * Returns true if a user was updated.
+     *
+     * @param uid
+     */
+    async markUserSetupAsComplete(uid) {
+        const userContext = this.authService.userContext(uid);
+        const userExists = await userContext.exists();
+        if (userExists) {
+            await this.updateClaimsToClearUser(userContext);
+        }
+        return userExists;
+    }
+    async createNewUser(input) {
+        const { uid, displayName, email, phone: phoneNumber, setupPassword: inputPassword } = input;
+        const password = inputPassword ?? this.generateRandomSetupPassword();
+        const user = await this.authService.auth.createUser({
+            uid,
+            displayName,
+            email,
+            phoneNumber,
+            password
+        });
+        return {
+            user,
+            password
+        };
+    }
+    generateRandomSetupPassword() {
+        return `${DEFAULT_FIREBASE_PASSWORD_NUMBER_GENERATOR()}`;
+    }
+    async updateClaimsToClearUser(userContext) {
+        await userContext.updateClaims({
+            [firebase.FIREBASE_SERVER_AUTH_CLAIMS_SETUP_PASSWORD_KEY]: null,
+            [firebase.FIREBASE_SERVER_AUTH_CLAIMS_SETUP_LAST_COM_DATE_KEY]: null
+        });
+    }
 }
 class NoSetupContentFirebaseServerNewUserService extends AbstractFirebaseServerNewUserService {
-  async sendSetupContentToUser(user) {
-    // send nothing.
-  }
+    async sendSetupContentToUser(user) {
+        // send nothing.
+    }
 }
 /**
  * FirebaseServer auth service that provides accessors to auth-related components.
  */
-class FirebaseServerAuthService {}
+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
-    };
-  }
+    _auth;
+    constructor(auth) {
+        this._auth = auth;
+    }
+    get auth() {
+        return this._auth;
+    }
+    context(context) {
+        assertIsContextWithAuthData(context);
+        return this._context(context);
+    }
+    isAdmin(claims) {
+        return this.isAdminInRoles(this.readRoles(claims));
+    }
+    isAdminInRoles(roles) {
+        return roles.has(util.AUTH_ADMIN_ROLE);
+    }
+    hasSignedTos(claims) {
+        return this.hasSignedTosInRoles(this.readRoles(claims));
+    }
+    hasSignedTosInRoles(roles) {
+        return roles.has(util.AUTH_TOS_SIGNED_ROLE);
+    }
+    newUser() {
+        return new NoSetupContentFirebaseServerNewUserService(this);
+    }
+    authContextInfo(context) {
+        const { auth } = context;
+        let result;
+        if (auth) {
+            const _roles = util.cachedGetter(() => this.readRoles(auth.token));
+            const getClaims = () => auth.token;
+            result = {
+                uid: auth.uid,
+                isAdmin: () => this.isAdminInRoles(_roles()),
+                getClaims,
+                getAuthRoles: _roles,
+                token: firebaseAuthTokenFromDecodedIdToken(auth.token)
+            };
+        }
+        return result;
+    }
+    authDetailsForRecord(record) {
+        return {
+            uid: record.uid,
+            email: record.email,
+            emailVerified: record.emailVerified,
+            phoneNumber: record.phoneNumber,
+            disabled: record.disabled,
+            displayName: record.displayName,
+            photoURL: record.photoURL,
+            creationTime: record.metadata.creationTime ? new Date(record.metadata.creationTime).toISOString() : undefined,
+            lastSignInTime: record.metadata.lastSignInTime ? new Date(record.metadata.lastSignInTime).toISOString() : undefined,
+            lastRefreshTime: record.metadata.lastRefreshTime ? new Date(record.metadata.lastRefreshTime).toISOString() : undefined
+        };
+    }
 }
 
-class FirebaseServerEnvService {}
+class FirebaseServerEnvService {
+}
 
 /**
  * Creates UpdateData corresponding to the input increment update.
@@ -728,9 +691,9 @@ class FirebaseServerEnvService {}
  * @returns
  */
 function firestoreServerIncrementUpdateToUpdateData(input) {
-  return util.mapObjectMap(input, incrementValue => {
-    return firestore.FieldValue.increment(incrementValue ?? 0);
-  });
+    return util.mapObjectMap(input, (incrementValue) => {
+        return firestore.FieldValue.increment(incrementValue ?? 0);
+    });
 }
 
 /**
@@ -740,26 +703,26 @@ function firestoreServerIncrementUpdateToUpdateData(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 => {
+    const union = input?.union;
+    const remove = input?.remove;
+    function createUpdatesWithArrayFunction(fieldUpdate, arrayUpdateFunction) {
         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
+        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;
-      });
     }
-    return result;
-  }
-  const updateData = {
-    ...createUpdatesWithArrayFunction(union, firestore.FieldValue.arrayUnion),
-    ...createUpdatesWithArrayFunction(remove, firestore.FieldValue.arrayRemove)
-  };
-  return updateData;
+    const updateData = {
+        ...createUpdatesWithArrayFunction(union, firestore.FieldValue.arrayUnion),
+        ...createUpdatesWithArrayFunction(remove, firestore.FieldValue.arrayRemove)
+    };
+    return updateData;
 }
 
 // MARK: Accessor
@@ -767,53 +730,54 @@ function firestoreServerArrayUpdateToUpdateData(input) {
  * 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();
-  }
+    documentRef;
+    _batch;
+    constructor(batch, documentRef) {
+        this.documentRef = documentRef;
+        this._batch = batch;
+    }
+    get batch() {
+        return this._batch;
+    }
+    stream() {
+        return rxjs.from(this.get()); // todo
+    }
+    create(data) {
+        this.batch.create(this.documentRef, data);
+        return Promise.resolve();
+    }
+    exists() {
+        return this.get().then((x) => x.exists);
+    }
+    get() {
+        return this.documentRef.get();
+    }
+    getWithConverter(converter) {
+        return this.documentRef.withConverter(converter).get();
+    }
+    delete(params) {
+        this.batch.delete(this.documentRef, params?.precondition);
+        return Promise.resolve();
+    }
+    set(data) {
+        this.batch.set(this.documentRef, data);
+        return Promise.resolve();
+    }
+    increment(data, params) {
+        return this.update(firestoreServerIncrementUpdateToUpdateData(data), params);
+    }
+    arrayUpdate(data, params) {
+        return this.update(firestoreServerArrayUpdateToUpdateData(data), params);
+    }
+    update(data, params) {
+        if (params?.precondition != null) {
+            this.batch.update(this.documentRef, data, params?.precondition);
+        }
+        else {
+            this.batch.update(this.documentRef, data);
+        }
+        return Promise.resolve();
+    }
 }
 /**
  * Creates a new FirestoreDocumentDataAccessorFactory for a Batch.
@@ -822,81 +786,78 @@ class WriteBatchFirestoreDocumentDataAccessor {
  * @returns
  */
 function writeBatchAccessorFactory(writeBatch) {
-  return {
-    accessorFor: ref => new WriteBatchFirestoreDocumentDataAccessor(writeBatch, ref)
-  };
+    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;
-  }
+    _batch;
+    contextType = firebase.FirestoreDocumentContextType.BATCH;
+    accessorFactory;
+    constructor(batch) {
+        this._batch = batch;
+        this.accessorFactory = writeBatchAccessorFactory(batch);
+    }
+    get batch() {
+        return this._batch;
+    }
 }
 function writeBatchDocumentContext(batch) {
-  return new WriteBatchFirestoreDocumentContext(batch);
+    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);
-  }
+    _documentRef;
+    constructor(documentRef) {
+        this._documentRef = documentRef;
+    }
+    get documentRef() {
+        return this._documentRef;
+    }
+    stream() {
+        return firebase.streamFromOnSnapshot(({ next, error }) => this.documentRef.onSnapshot(next, error));
+    }
+    create(data) {
+        return this.documentRef.create(data);
+    }
+    exists() {
+        return this.get().then((x) => x.exists);
+    }
+    get() {
+        return this.documentRef.get();
+    }
+    getWithConverter(converter) {
+        return this.documentRef.withConverter(converter).get();
+    }
+    delete(params) {
+        return this.documentRef.delete(params?.precondition);
+    }
+    set(data, options) {
+        return options ? this.documentRef.set(data, options) : this.documentRef.set(data);
+    }
+    increment(data, params) {
+        return this.update(firestoreServerIncrementUpdateToUpdateData(data), params);
+    }
+    arrayUpdate(data, params) {
+        return this.update(firestoreServerArrayUpdateToUpdateData(data), params);
+    }
+    update(data, params) {
+        return params?.precondition ? this.documentRef.update(data, params.precondition) : this.documentRef.update(data);
+    }
 }
 function defaultFirestoreAccessorFactory() {
-  return {
-    accessorFor: ref => new DefaultFirestoreDocumentDataAccessor(ref)
-  };
+    return {
+        accessorFor: (ref) => new DefaultFirestoreDocumentDataAccessor(ref)
+    };
 }
 // MARK: Context
 function defaultFirestoreDocumentContext() {
-  return {
-    contextType: firebase.FirestoreDocumentContextType.NONE,
-    accessorFactory: defaultFirestoreAccessorFactory()
-  };
+    return {
+        contextType: firebase.FirestoreDocumentContextType.NONE,
+        accessorFactory: defaultFirestoreAccessorFactory()
+    };
 }
 
 // MARK: Accessor
@@ -904,56 +865,57 @@ function defaultFirestoreDocumentContext() {
  * 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();
-  }
+    _transaction;
+    _documentRef;
+    constructor(transaction, documentRef) {
+        this._transaction = transaction;
+        this._documentRef = documentRef;
+    }
+    get transaction() {
+        return this._transaction;
+    }
+    get documentRef() {
+        return this._documentRef;
+    }
+    stream() {
+        return rxjs.from(this.get());
+    }
+    create(data) {
+        this.transaction.create(this.documentRef, data);
+        return Promise.resolve();
+    }
+    exists() {
+        return this.get().then((x) => x.exists);
+    }
+    get() {
+        return this.transaction.get(this.documentRef);
+    }
+    getWithConverter(converter) {
+        return this.transaction.get(this.documentRef.withConverter(converter));
+    }
+    delete() {
+        this.transaction.delete(this.documentRef);
+        return Promise.resolve();
+    }
+    set(data, options) {
+        this.transaction.set(this.documentRef, data, options);
+        return Promise.resolve();
+    }
+    increment(data, params) {
+        return this.update(firestoreServerIncrementUpdateToUpdateData(data), params);
+    }
+    arrayUpdate(data, params) {
+        return this.update(firestoreServerArrayUpdateToUpdateData(data), params);
+    }
+    update(data, params) {
+        if (params?.precondition) {
+            this.transaction.update(this.documentRef, data, params?.precondition);
+        }
+        else {
+            this.transaction.update(this.documentRef, data);
+        }
+        return Promise.resolve();
+    }
 }
 /**
  * Creates a new FirestoreDocumentDataAccessorFactory for a Transaction.
@@ -962,122 +924,123 @@ class TransactionFirestoreDocumentDataAccessor {
  * @returns
  */
 function transactionAccessorFactory(transaction) {
-  return {
-    accessorFor: ref => new TransactionFirestoreDocumentDataAccessor(transaction, ref)
-  };
+    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;
-  }
+    _transaction;
+    contextType = firebase.FirestoreDocumentContextType.TRANSACTION;
+    accessorFactory;
+    constructor(transaction) {
+        this._transaction = transaction;
+        this.accessorFactory = transactionAccessorFactory(transaction);
+    }
+    get transaction() {
+        return this._transaction;
+    }
 }
 function transactionDocumentContext(transaction) {
-  return new TransactionFirestoreDocumentContext(transaction);
+    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;
+    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;
+    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
-  };
+    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)
+    [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()
-  });
+    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));
-    }
-  };
+    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()
-  };
+    return {
+        firestoreDriverIdentifier: '@google-cloud/firestore',
+        firestoreDriverType: 'production',
+        firestoreAccessorDriver: googleCloudFirestoreAccessorDriver(),
+        firestoreQueryDriver: googleCloudFirestoreQueryDriver()
+    };
 }
 
 /**
@@ -1086,9 +1049,9 @@ function googleCloudFirestoreDrivers() {
 const googleCloudFirestoreContextFactory = firebase.firestoreContextFactory(googleCloudFirestoreDrivers());
 
 function assertContextHasAuth(context) {
-  if (!isContextWithAuthData(context)) {
-    throw unauthenticatedContextHasNoUidError();
-  }
+    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).
@@ -1098,13 +1061,13 @@ function assertContextHasAuth(context) {
  * @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;
+    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.
@@ -1114,8 +1077,8 @@ async function assertSnapshotData(document, message) {
  * @returns
  */
 async function assertSnapshotDataWithKey(document, message) {
-  const data = await assertSnapshotData(document, message);
-  return firebase.setIdAndKeyFromKeyIdRefOnDocumentData(data, document);
+    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.
@@ -1125,10 +1088,10 @@ async function assertSnapshotDataWithKey(document, message) {
  * @returns
  */
 async function assertDocumentExists(document, message) {
-  const exists = await document.exists();
-  if (!exists) {
-    throw documentModelNotAvailableError(document, message);
-  }
+    const exists = await document.exists();
+    if (!exists) {
+        throw documentModelNotAvailableError(document, message);
+    }
 }
 /**
  * Error thrown by assertDocumentExists().
@@ -1138,28 +1101,28 @@ async function assertDocumentExists(document, message) {
  * @returns
  */
 function documentModelNotAvailableError(document, message) {
-  return modelNotAvailableError({
-    message: message ?? `The ${document.modelType} was unavailable.`
-  });
+    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.'
-  });
+    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;
-    }
-  });
+    handleFirebaseError(e, (firebaseError) => {
+        switch (firebaseError.code) {
+            case 'auth/phone-number-already-exists':
+                throw phoneNumberAlreadyExistsError();
+            default:
+                handleUnknownCode?.(firebaseError);
+                break;
+        }
+    });
 }
 
 /******************************************************************************
@@ -1206,10 +1169,10 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 const FIREBASE_APP_TOKEN = 'FIREBASE_APP_TOKEN';
 // MARK: Firebase Admin Provider
 function firebaseServerAppTokenProvider(useFactory) {
-  return {
-    provide: FIREBASE_APP_TOKEN,
-    useFactory
-  };
+    return {
+        provide: FIREBASE_APP_TOKEN,
+        useFactory
+    };
 }
 
 // MARK: Tokens
@@ -1220,23 +1183,31 @@ 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);
+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
-  }];
+    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.
@@ -1246,58 +1217,58 @@ function provideFirebaseServerAuthService(provider) {
  * @returns
  */
 function firebaseServerAuthModuleMetadata(config) {
-  return nestjs.mergeModuleMetadata({
-    imports: [exports.FirebaseServerAuthModule],
-    exports: [exports.FirebaseServerAuthModule, config.serviceProvider.provide],
-    providers: provideFirebaseServerAuthService(config.serviceProvider)
-  }, 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();
-  }
+    if (!isAdminInRequest(request)) {
+        throw forbiddenError();
+    }
 }
 function isAdminInRequest(request) {
-  return request.nest.authService.context(request).isAdmin;
+    return request.nest.authService.context(request).isAdmin;
 }
 function assertIsAdminOrTargetUserInRequestData(request, requireUid) {
-  if (!isAdminOrTargetUserInRequestData(request, requireUid)) {
-    throw forbiddenError();
-  }
-  return request.data.uid ?? request.auth?.uid;
+    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;
+    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.'
-    });
-  }
+    if (!hasSignedTosInRequest(request)) {
+        throw forbiddenError({
+            message: 'ToS has not been signed.'
+        });
+    }
 }
 function hasSignedTosInRequest(request) {
-  return request.nest.authService.context(request).hasSignedTos;
+    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)
-      }
-    });
-  }
+    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);
+    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.
@@ -1307,8 +1278,8 @@ function hasAuthRolesInRequest(request, authRoles) {
  * @param request
  */
 function hasNewUserSetupPasswordInRequest(request) {
-  const claims = request.nest.authService.context(request).claims;
-  return claims[firebase.FIREBASE_SERVER_AUTH_CLAIMS_SETUP_PASSWORD_KEY] != null;
+    const claims = request.nest.authService.context(request).claims;
+    return claims[firebase.FIREBASE_SERVER_AUTH_CLAIMS_SETUP_PASSWORD_KEY] != null;
 }
 
 /**
@@ -1318,123 +1289,114 @@ function hasNewUserSetupPasswordInRequest(request) {
  * @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);
-    }
-  };
+    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
-    }
-  }));
+    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.`
-  });
+    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
-    }
-  });
+    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
-    }
-  });
+    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()
+    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 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 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);
         }
-        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;
+    request.nest = makeNestContext(request.nestApplication);
+    return request;
 }
 /**
  * Wraps the input OnCallWithNestContext function to flag it as optional to have auth data.
@@ -1443,9 +1405,9 @@ function setNestContextOnRequest(makeNestContext, request) {
  * @returns
  */
 function optionalAuthContext(fn) {
-  const fnWithOptionalAuth = request => fn(request);
-  fnWithOptionalAuth._requireAuth = false;
-  return fnWithOptionalAuth;
+    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.
@@ -1454,9 +1416,9 @@ function optionalAuthContext(fn) {
  * @param request
  */
 function assertRequestRequiresAuthForFunction(fn, request) {
-  if (fn._requireAuth !== false) {
-    assertIsContextWithAuthData(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.
@@ -1465,64 +1427,59 @@ function assertRequestRequiresAuthForFunction(fn, request) {
  * @returns
  */
 function inAuthContext(fn) {
-  return request => {
-    assertIsContextWithAuthData(request);
-    return fn(request);
-  };
+    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
+    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
     };
-    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;
-  }
+    /**
+     * 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);
+exports.DefaultFirebaseServerEnvService = __decorate([
+    common.Injectable()
+], exports.DefaultFirebaseServerEnvService);
 
 function nestAppIsProductionEnvironment(nest) {
-  return () => nest().then(x => x.get(FirebaseServerEnvService).isProduction);
+    return () => nest().then((x) => x.get(FirebaseServerEnvService).isProduction);
 }
 function nestAppHasDevelopmentSchedulerEnabled(nest) {
-  return () => nest().then(x => x.get(FirebaseServerEnvService).developmentSchedulerEnabled);
+    return () => nest().then((x) => x.get(FirebaseServerEnvService).developmentSchedulerEnabled);
 }
 
 // MARK: Tokens
@@ -1537,28 +1494,38 @@ 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);
+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);
+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.
  *
@@ -1566,15 +1533,14 @@ exports.FirebaseServerFirestoreContextModule = __decorate([common.Module({
  * @param useFactory
  * @returns
  */
-function provideAppFirestoreCollections({
-  provide,
-  useFactory
-}) {
-  return [{
-    provide,
-    useFactory,
-    inject: [FIREBASE_FIRESTORE_CONTEXT_TOKEN]
-  }];
+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
@@ -1584,11 +1550,11 @@ function provideAppFirestoreCollections({
  * @returns
  */
 function appFirestoreModuleMetadata(config) {
-  return {
-    imports: [exports.FirebaseServerFirestoreContextModule, ...(config.imports ?? [])],
-    exports: [exports.FirebaseServerFirestoreContextModule, config.provide, ...(config.exports ?? [])],
-    providers: [...provideAppFirestoreCollections(config), ...(config.providers ?? [])]
-  };
+    return {
+        imports: [exports.FirebaseServerFirestoreContextModule, ...(config.imports ?? [])],
+        exports: [exports.FirebaseServerFirestoreContextModule, config.provide, ...(config.exports ?? [])],
+        providers: [...provideAppFirestoreCollections(config), ...(config.providers ?? [])]
+    };
 }
 
 /**
@@ -1599,9 +1565,9 @@ function appFirestoreModuleMetadata(config) {
  * @returns
  */
 function makeBlockingFunctionWithHandler(blockingFunctionBuilder, handler, opts) {
-  const blockingFn = opts != null ? blockingFunctionBuilder(opts, handler) : blockingFunctionBuilder(handler);
-  blockingFn.__handler = handler;
-  return blockingFn;
+    const blockingFn = opts != null ? blockingFunctionBuilder(opts, handler) : blockingFunctionBuilder(handler);
+    blockingFn.__handler = handler;
+    return blockingFn;
 }
 /**
  * Creates a BlockingFunctionHandlerWithNestContextFactory.
@@ -1611,18 +1577,18 @@ function makeBlockingFunctionWithHandler(blockingFunctionBuilder, handler, opts)
  * @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);
+    return (fn) => {
+        return (nestAppPromiseGetter) => {
+            const handlerBuilder = (handler) => {
+                const fnHandler = (event) => nestAppPromiseGetter().then((nestApplication) => handler({
+                    ...event,
+                    nest: makeNestContext(nestApplication)
+                }));
+                return fnHandler;
+            };
+            return fn(handlerBuilder);
+        };
     };
-  };
 }
 
 /**
@@ -1632,15 +1598,12 @@ function blockingFunctionHandlerWithNestContextFactory(makeNestContext) {
  * @returns
  */
 function onCallHandlerWithNestApplicationFactory(defaultOpts = {}) {
-  return (fn, opts) => {
-    return nestAppPromiseGetter => v2.https.onCall({
-      ...defaultOpts,
-      ...opts
-    }, request => nestAppPromiseGetter().then(nestApplication => fn({
-      ...request,
-      nestApplication
-    })));
-  };
+    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.
@@ -1650,7 +1613,7 @@ function onCallHandlerWithNestApplicationFactory(defaultOpts = {}) {
  * @returns
  */
 function onCallHandlerWithNestContextFactory(appFactory, makeNestContext) {
-  return (fn, opts) => appFactory(request => fn(setNestContextOnRequest(makeNestContext, request)), opts);
+    return (fn, opts) => appFactory((request) => fn(setNestContextOnRequest(makeNestContext, request)), opts);
 }
 
 /**
@@ -1661,30 +1624,30 @@ function onCallHandlerWithNestContextFactory(appFactory, 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);
+    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;
+    request.nest = makeNestContext(request.nestApplication);
+    return request;
 }
 
 function makeOnScheduleHandlerWithNestApplicationRequest(nestApplication, scheduleContext) {
-  return {
-    nestApplication,
-    scheduleContext
-  };
+    return {
+        nestApplication,
+        scheduleContext
+    };
 }
 /**
  * Creates a factory for generating OnCallWithNestApplication functions.
@@ -1693,27 +1656,29 @@ function makeOnScheduleHandlerWithNestApplicationRequest(nestApplication, schedu
  * @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;
+    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.
@@ -1723,7 +1688,7 @@ function onScheduleHandlerWithNestApplicationFactory(baseScheduleConfig) {
  * @returns
  */
 function onScheduleHandlerWithNestContextFactory(appFactory, makeNestContext) {
-  return (schedule, fn) => appFactory(schedule, request => fn(setNestContextOnScheduleRequest(makeNestContext, request)));
+    return (schedule, fn) => appFactory(schedule, (request) => fn(setNestContextOnScheduleRequest(makeNestContext, request)));
 }
 
 /**
@@ -1734,37 +1699,38 @@ function onScheduleHandlerWithNestContextFactory(appFactory, 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);
+    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 {}
+class AbstractFirebaseServerActionsContext {
+}
 function firebaseServerActionsContext(options) {
-  return {
-    ...firebaseServerActionsTransformContext(options)
-  };
+    return {
+        ...firebaseServerActionsTransformContext(options)
+    };
 }
-const defaultFirebaseServerActionsTransformFactoryLogErrorFunction = details => {
-  console.log('firebaseServerActionsTransformFactory() encountered validation error: ', details);
+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 firebaseServerActionTransformFactory = firebaseServerActionsTransformFactory(options);
+    const firebaseServerActionTransformFunctionFactory = model.toTransformAndValidateFunctionResultFactory(firebaseServerActionTransformFactory);
+    return {
+        firebaseServerActionTransformFactory,
+        firebaseServerActionTransformFunctionFactory
+    };
 }
 const FIREBASE_SERVER_VALIDATION_ERROR_CODE = 'VALIDATION_ERROR';
 /**
@@ -1773,16 +1739,16 @@ const FIREBASE_SERVER_VALIDATION_ERROR_CODE = 'VALIDATION_ERROR';
  * @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
-  };
+    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.
@@ -1791,48 +1757,41 @@ function firebaseServerValidationServerError(validationError) {
  * @returns
  */
 function firebaseServerValidationError(validationError) {
-  const serverError = firebaseServerValidationServerError(validationError);
-  return badRequestError(serverError);
+    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
-  });
+    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
-  };
+    return {
+        ...request,
+        nest
+    };
 }
 function injectNestApplicationContextIntoRequest(nestContext, request) {
-  return {
-    ...request,
-    nestApplication: nestContext
-  };
+    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;
-  }
+    globalApiRoutePrefix;
 }
 
 /**
@@ -1841,33 +1800,38 @@ class GlobalRoutePrefixConfig {
  * 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);
-  }
+    globalRoutePrefixConfig;
+    logger = new common.Logger('FirebaseAppCheckMiddleware');
+    _ignoredWebhookPath;
+    constructor(globalRoutePrefixConfig) {
+        this.globalRoutePrefixConfig = globalRoutePrefixConfig;
+        this._ignoredWebhookPath = this.globalRoutePrefixConfig?.globalApiRoutePrefix ? `${this.globalRoutePrefixConfig.globalApiRoutePrefix}${nestjs.DEFAULT_BASE_WEBHOOK_PATH}` : nestjs.DEFAULT_BASE_WEBHOOK_PATH;
+    }
+    async use(req, res, next) {
+        const isIgnoredRoute = this.isIgnoredRequest(req);
+        let error;
+        if (!isIgnoredRoute) {
+            error = await verifyAppCheckInRequest(req);
+            if (error) {
+                this.logger.error('app check token failed verify');
+            }
+        }
+        next(error);
+    }
+    isIgnoredRequest(req) {
+        const isIgnoredRoute = req.skipAppCheck || this.isIgnoredPath(req.baseUrl);
+        return isIgnoredRoute;
+    }
+    isIgnoredPath(path) {
+        return path.startsWith(this._ignoredWebhookPath);
+    }
 };
-exports.FirebaseAppCheckMiddleware = __decorate([common.Injectable(), __param(0, common.Optional()), __param(0, common.Inject(GlobalRoutePrefixConfig)), __metadata("design:paramtypes", [Object])], exports.FirebaseAppCheckMiddleware);
+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.
  *
@@ -1877,50 +1841,54 @@ exports.FirebaseAppCheckMiddleware = __decorate([common.Injectable(), __param(0,
  * @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();
+    const appCheckToken = req.header('X-Firebase-AppCheck');
+    let error;
+    if (!appCheckToken) {
+        error = new common.ForbiddenException();
     }
-  }
-  return error;
+    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.');
-  }
+    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);
+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;
+    const req = context.switchToHttp().getRequest();
+    req.skipAppCheck = true;
 });
 
 exports.FirebaseRawBodyMiddleware = class FirebaseRawBodyMiddleware {
-  use(req, res, next) {
-    req.body = req.rawBody;
-    next();
-  }
+    use(req, res, next) {
+        req.body = req.rawBody;
+        next();
+    }
 };
-exports.FirebaseRawBodyMiddleware = __decorate([common.Injectable()], exports.FirebaseRawBodyMiddleware);
+exports.FirebaseRawBodyMiddleware = __decorate([
+    common.Injectable()
+], exports.FirebaseRawBodyMiddleware);
 
 /**
  * Convenience class that mirrors the ConfigureWebhookMiddlewareModule class in @dereekb/nestjs, but for Firebase apps.
@@ -1928,60 +1896,59 @@ exports.FirebaseRawBodyMiddleware = __decorate([common.Injectable()], exports.Fi
  * 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.');
-  }
+    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);
+exports.ConfigureFirebaseWebhookMiddlewareModule = __decorate([
+    common.Module({})
+], exports.ConfigureFirebaseWebhookMiddlewareModule);
 
-const nestFirebaseDoesNotExistError = firebaseContextGrantedModelRoles => {
-  return modelNotAvailableError({
-    data: {
-      id: firebaseContextGrantedModelRoles.data?.document.key,
-      type: firebaseContextGrantedModelRoles.data?.document.modelType
-    }
-  });
+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
-    }
-  });
+    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;
+    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
-    }
-  }));
+    return badRequestError(util.serverError({
+        status: 400,
+        code: 'UNKNOWN_SPECIFIER_ERROR',
+        message: 'Invalid/unknown specifier for this function.',
+        data: {
+            specifier
+        }
+    }));
 }
 
 /**
@@ -1991,497 +1958,455 @@ function unknownModelCrudFunctionSpecifierError(specifier) {
  * @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();
-    }
-  };
+    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.`
-  }));
+    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
-    }
-  }));
+    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);
-    }
-  };
+    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
-  });
+    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
-    }
-  }));
+    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
-  });
+    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
-    }
-  }));
+    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
-  });
+    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
-    }
-  }));
+    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
-  });
+    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
-    }
-  }));
+    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);
+    return storage.bucket(path.bucketId);
 }
 function googleCloudStorageFileForStorageFilePath(storage, path) {
-  return googleCloudStorageBucketForStorageFilePath(storage, path).file(path.pathString);
+    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) {
+    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 {
-      ...(maxDownloadSizeBytes ? {
-        // end is inclusive
-        end: maxDownloadSizeBytes - 1
-      } : undefined)
+        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 _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
-      });
+}
+function googleCloudStorageAccessorFile(storage$1, storagePath) {
+    const file = googleCloudStorageFileForStorageFilePath(storage$1, storagePath);
+    function makeDownloadOptions(maxDownloadSizeBytes) {
+        return {
+            ...(maxDownloadSizeBytes
+                ? {
+                    // end is inclusive
+                    end: maxDownloadSizeBytes - 1
+                }
+                : undefined)
+        };
     }
-    return {
-      // non-resumable
-      resumable: false,
-      // add content type and other custom metadata
-      ...(metadata ? {
-        metadata
-      } : 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'
     };
-  }
-  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
+    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] }))
     };
-    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;
-      });
+    return accessorFile;
+}
+const googleCloudStorageListFilesResultFactory = firebase.storageListFilesResultFactory({
+    hasItems(result) {
+        return Boolean(result.apiResponse.items || result.apiResponse.prefixes);
     },
-    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));
+    hasNext: (result) => {
+        return result.nextQuery != null;
     },
-    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;
+    nextPageTokenFromResult(result) {
+        return result.nextQuery?.pageToken;
     },
-    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
-      }
-    }));
-  }
+    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;
+    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)
-  };
+    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()
-  };
+    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);
-  }
+    _storageContext;
+    constructor(storageContext) {
+        this._storageContext = storageContext;
+    }
+    get storageContext() {
+        return this._storageContext;
+    }
+    defaultBucket() {
+        return this.storageContext.defaultBucket();
+    }
+    file(path) {
+        return this.storageContext.file(path);
+    }
+    folder(path) {
+        return this.storageContext.folder(path);
+    }
 }
 
 /**
@@ -2495,7 +2420,7 @@ const googleCloudFirebaseStorageContextFactory = firebase.firebaseStorageContext
  * @returns
  */
 function googleCloudStorageFromFirebaseAdminStorage(storage) {
-  return storage.storageClient;
+    return storage.storageClient;
 }
 
 // MARK: Tokens
@@ -2514,59 +2439,69 @@ const FIREBASE_STORAGE_CONTEXT_FACTORY_CONFIG_TOKEN = 'FIREBASE_STORAGE_CONTEXT_
 /**
  * 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);
+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);
+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
-  };
+    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)
-  };
+    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;
+    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.
@@ -2576,145 +2511,133 @@ function provideFirebaseServerStorageService(provider) {
  * @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);
+    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 {}
+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
+    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;
             });
-          }
-        }
-        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);
+            nestServer = { server, nest: util.makeGetter(nest) };
+            serversCache.set(appName, nestServer);
         }
-        if (config.appCheckEnabled != false) {
-          imports.push(exports.ConfigureFirebaseAppCheckMiddlewareModule);
+        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);
+            });
         }
-        if (defaultStorageBucket) {
-          providers.push(firebaseServerStorageDefaultBucketIdTokenProvider({
-            defaultBucketId: defaultStorageBucket,
-            forceBucket: forceStorageBucket
-          }));
+        else {
+            removed = Promise.resolve(false);
         }
-        // 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
-  };
+        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;
-  }
+    _nest;
+    constructor(nest) {
+        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;
+    makePermissionError = nestFirebaseForbiddenPermissionError;
     /**
      * FirebaseDoesNotExistErrorContextErrorFunction to use with makeModelContext().
      *
@@ -2723,55 +2646,56 @@ class AbstractFirebaseNestContext extends AbstractNestContext {
      * 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);
-  }
+    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;
@@ -2806,9 +2730,7 @@ 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;