@dereekb/firebase 13.0.6 → 13.1.0

package/index.cjs.js

@@ -8,8 +8,7 @@ var model = require('@dereekb/model');
 var date = require('@dereekb/date');
 var functions = require('firebase/functions');
 var storage = require('firebase/storage');
-var classTransformer = require('class-transformer');
-var classValidator = require('class-validator');
+var arktype = require('arktype');
 var fetch = require('@dereekb/util/fetch');
 var makeError = require('make-error');
 var dateFns = require('date-fns');
@@ -1093,6 +1092,61 @@ function documentReferenceFromDocument(document) {
 function documentReferencesFromDocuments(documents) {
     return documents.map(documentReferenceFromDocument);
 }
+/**
+ * Creates a {@link LimitedFirestoreDocumentAccessorSnapshotCache} that wraps the given accessor
+ * with an in-memory {@link Map} cache so that repeated loads for the same key return the cached
+ * promise instead of re-reading from Firestore.
+ *
+ * The cache stores the promise itself (not the resolved value), which means concurrent requests
+ * for the same key that arrive before the first read completes will also be deduplicated.
+ *
+ * The cache lives for the lifetime of the returned object and is never invalidated, so this is
+ * best suited for short-lived scopes (e.g. a single request or batch operation) where stale reads
+ * are acceptable.
+ *
+ * @param accessor - The accessor to wrap with caching behavior
+ * @returns A {@link LimitedFirestoreDocumentAccessorSnapshotCache} backed by the given accessor
+ *
+ * @example
+ * ```typescript
+ * const cache = limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+ *
+ * // First call reads from Firestore; second call returns cached result
+ * const pair = await cache.getDocumentSnapshotDataPairForKey('users/abc123');
+ * const samePair = await cache.getDocumentSnapshotDataPairForKey('users/abc123');
+ *
+ * // Batch fetch with automatic deduplication
+ * const pairs = await cache.getDocumentSnapshotDataPairsWithDataForKeys(['users/abc', 'users/def']);
+ *
+ * // Access the underlying accessor directly
+ * const doc = cache.accessor.loadDocumentForKey('users/xyz');
+ * ```
+ */
+function limitedFirestoreDocumentAccessorSnapshotCache(accessor) {
+    const cache = new Map();
+    function getDocumentSnapshotDataPairForKey(key) {
+        let cached = cache.get(key);
+        if (!cached) {
+            const document = accessor.loadDocumentForKey(key);
+            cached = getDocumentSnapshotDataPair(document);
+            cache.set(key, cached);
+        }
+        return cached;
+    }
+    async function getDocumentSnapshotDataPairsForKeys(keys) {
+        return Promise.all(keys.map((key) => getDocumentSnapshotDataPairForKey(key)));
+    }
+    async function getDocumentSnapshotDataPairsWithDataForKeys(keys) {
+        const pairs = await getDocumentSnapshotDataPairsForKeys(keys);
+        return util.filterMaybeArrayValues(pairs.map((pair) => (pair.data != null ? pair : undefined)));
+    }
+    return {
+        accessor,
+        getDocumentSnapshotDataPairForKey,
+        getDocumentSnapshotDataPairsForKeys,
+        getDocumentSnapshotDataPairsWithDataForKeys
+    };
+}
 
 /**
  * Creates an Observable that emits arrays of document snapshots for multiple documents.
@@ -1142,7 +1196,7 @@ function mapLatestSnapshotsFromDocuments(documents, operator) {
  * @param documents - Array of document instances to stream data for
  * @returns Observable that emits arrays of document data whenever any document changes
  */
-function latestDataFromDocuments(documents) {
+function streamDocumentSnapshotsData(documents) {
     return latestSnapshotsFromDocuments(documents).pipe(dataFromDocumentSnapshots());
 }
 /**
@@ -1200,6 +1254,11 @@ function streamDocumentSnapshotDataPairs(documents) {
 function streamDocumentSnapshotDataPairsWithData(documents) {
     return streamDocumentSnapshotDataPairs(documents).pipe(rxjs$1.map((pairs) => pairs.filter((pair) => pair.data != null)));
 }
+// MARK: Compat
+/**
+ * @deprecated Use {@link streamDocumentSnapshotsData} instead.
+ */
+const latestDataFromDocuments = streamDocumentSnapshotsData;
 
 // A set of copied types from @google-cloud/firestore and firebase/firestore to allow cross-compatability.
 /* eslint-disable */
@@ -2355,20 +2414,14 @@ function firebaseQueryItemAccumulator(iteration, mapItem) {
 }
 
 /**
- * Creates a Firestore query constraint.
+ * Creates a {@link FirestoreQueryConstraint} with the given type identifier and data.
  *
- * @template T - Type of data stored in the constraint
- * @param type - The constraint type identifier
- * @param data - The constraint data
- * @returns A Firestore query constraint object
- */
-/**
- * Creates a Firestore query constraint.
+ * This is the low-level factory used by all constraint builder functions (e.g., {@link where},
+ * {@link limit}, {@link orderBy}). Most callers should use those typed builders instead.
  *
- * @template T - Type of data stored in the constraint
- * @param type - The constraint type identifier
- * @param data - The constraint data
- * @returns A Firestore query constraint object
+ * @param type - The constraint type identifier (e.g., 'where', 'limit')
+ * @param data - The constraint-specific configuration data
+ * @returns A typed constraint object
  */
 function firestoreQueryConstraint(type, data) {
     return {
@@ -2868,6 +2921,17 @@ function filterDisallowedFirestoreItemPageIteratorInputConstraints(constraints)
  * This value is used when no itemsPerPage is explicitly specified in the configuration.
  */
 const DEFAULT_FIRESTORE_ITEM_PAGE_ITERATOR_ITEMS_PER_PAGE = 50;
+/**
+ * Creates a {@link FirestoreItemPageIteratorDelegate} that handles cursor-based Firestore pagination.
+ *
+ * The delegate implements `loadItemsForPage` by:
+ * 1. Retrieving the cursor document from the previous page's results
+ * 2. Building a query with the configured constraints, `startAfter` cursor, and `limit`
+ * 3. Executing the query and wrapping the results in a {@link FirestoreItemPageQueryResult}
+ *    with `reload()` and `stream()` capabilities
+ *
+ * @returns A delegate instance for use with {@link ItemPageIterator}
+ */
 function makeFirestoreItemPageIteratorDelegate() {
     return {
         loadItemsForPage: (request) => {
@@ -3025,7 +3089,14 @@ function _firestoreItemPageIterationWithSnapshotIteration(snapshotIteration) {
     return result;
 }
 /**
- * Creates a FirestoreFixedItemPageIterationFactoryFunction.
+ * Creates a factory function for generating fixed-set Firestore pagination instances.
+ *
+ * The returned factory takes an array of document references and an optional filter,
+ * producing a pagination instance that iterates over those specific documents in pages.
+ *
+ * @param baseConfig - Base pagination configuration (query reference, driver, page size)
+ * @param documentAccessor - Accessor used to load document snapshots from the references
+ * @returns A factory function that creates fixed-set pagination instances
  */
 function firestoreFixedItemPageIterationFactory(baseConfig, documentAccessor) {
     return (items, filter) => {
@@ -3042,7 +3113,17 @@ function firestoreFixedItemPageIterationFactory(baseConfig, documentAccessor) {
     };
 }
 /**
- * Creates a FirestoreItemPageIterationInstance that iterates over the fixed
+ * Creates a pagination instance that iterates over a fixed set of document references.
+ *
+ * Unlike {@link firestoreItemPageIteration} which queries Firestore dynamically, this function
+ * paginates through a pre-determined list of document references. Each page loads the next
+ * slice of references via the document accessor and produces a synthetic {@link QuerySnapshot}.
+ *
+ * This is useful for paginating over known document sets (e.g., from a pre-computed list
+ * of references) without executing Firestore queries.
+ *
+ * @param config - Configuration including the document references, accessor, and pagination settings
+ * @returns A pagination instance that pages through the fixed reference set
  */
 function firestoreFixedItemPageIteration(config) {
     const { items, documentAccessor } = config;
@@ -3259,24 +3340,47 @@ function readFirestoreModelKeyFromDocumentSnapshot(snapshot) {
 /**
  * @module Firestore Query Iteration
  *
- * This module provides a comprehensive system for iterating through Firestore query results
- * with support for pagination, batching, and parallelism. It enables efficient processing of
- * large result sets by using cursor-based pagination (via "checkpoints") and various iteration
- * strategies.
+ * Provides a layered system for iterating through Firestore query results using
+ * cursor-based pagination ("checkpoints"). Each layer adds convenience on top of the
+ * one below:
+ *
+ * 1. **Checkpoints** ({@link iterateFirestoreDocumentSnapshotCheckpoints}) — core pagination engine
+ * 2. **Batches** ({@link iterateFirestoreDocumentSnapshotBatches}) — subdivides checkpoints into fixed-size batches
+ * 3. **Snapshots** ({@link iterateFirestoreDocumentSnapshots}) — processes individual snapshots
+ * 4. **Pairs** ({@link iterateFirestoreDocumentSnapshotPairs}) — loads typed document wrappers per snapshot
+ *
+ * Batch variants with document pairs are also available:
+ * - {@link iterateFirestoreDocumentSnapshotPairBatches} — batch processing with typed document access
+ *
+ * All functions support configurable limits (`limitPerCheckpoint`, `totalSnapshotsLimit`),
+ * concurrency (`maxParallelCheckpoints`), rate limiting (`waitBetweenCheckpoints`),
+ * snapshot filtering, and repeat cursor detection.
  */
 /**
- * Iterates through the results of a Firestore query by each FirestoreDocumentSnapshotDataPairWithData.
+ * Iterates through Firestore query results, loading each snapshot as a
+ * {@link FirestoreDocumentSnapshotDataPairWithData} before processing.
  *
- * This function efficiently handles pagination through potentially large result sets by using
- * the checkpoint system to load documents in batches. For each document snapshot, it loads the
- * associated data using the provided document accessor, then passes the combined pair to the
- * processing function.
+ * Built on {@link iterateFirestoreDocumentSnapshots}, this adds an automatic document
+ * loading step: each raw snapshot is resolved through the `documentAccessor` to produce
+ * a pair containing both the typed {@link FirestoreDocument} and its snapshot data.
+ * This is the highest-level iteration function — use it when your callback needs
+ * document-level operations (updates, deletes) alongside the snapshot data.
  *
- * @template T - The document data type
- * @template R - The result type of processing each snapshot pair
- * @template D - The FirestoreDocument implementation type (defaults to FirestoreDocument<T>)
- * @param config - Configuration for the iteration, including the document accessor and processing function
- * @returns A promise that resolves to the result of the iteration, including statistics about checkpoints and snapshots processed
+ * @param config - Iteration config including the document accessor and per-pair callback
+ * @returns Checkpoint-level statistics (total checkpoints, snapshots visited, limit status)
+ *
+ * @example
+ * ```typescript
+ * const result = await iterateFirestoreDocumentSnapshotPairs({
+ *   queryFactory,
+ *   constraintsFactory: [where('status', '==', 'pending')],
+ *   limitPerCheckpoint: 100,
+ *   documentAccessor: collection.documentAccessor(),
+ *   iterateSnapshotPair: async (pair) => {
+ *     await pair.document.accessor.set({ ...pair.data, status: 'processed' });
+ *   }
+ * });
+ * ```
  */
 async function iterateFirestoreDocumentSnapshotPairs(config) {
     const { iterateSnapshotPair, documentAccessor } = config;
@@ -3290,16 +3394,32 @@ async function iterateFirestoreDocumentSnapshotPairs(config) {
     });
 }
 /**
- * Iterates through the results of a Firestore query by each document snapshot by itself.
+ * Iterates through Firestore query results, processing each document snapshot individually.
  *
- * This function efficiently handles pagination through potentially large result sets by using
- * the checkpoint system to load documents in batches. Each document snapshot is then processed
- * individually using the provided processing function.
+ * Built on {@link iterateFirestoreDocumentSnapshotBatches} with `maxParallelCheckpoints: 1`,
+ * this unwraps each checkpoint's snapshots and processes them one-by-one via
+ * {@link performAsyncTasks} (sequential by default). Use `snapshotsPerformTasksConfig`
+ * to enable parallel snapshot processing within each checkpoint.
  *
- * @template T - The document data type
- * @template R - The result type of processing each snapshot
- * @param config - Configuration for the iteration, including the snapshot processing function
- * @returns A promise that resolves to the result of the iteration, including statistics about checkpoints and snapshots processed
+ * For document-level operations (needing the typed {@link FirestoreDocument} wrapper),
+ * use {@link iterateFirestoreDocumentSnapshotPairs} instead.
+ *
+ * @param config - Iteration config including the per-snapshot callback
+ * @returns Checkpoint-level statistics (total checkpoints, snapshots visited, limit status)
+ *
+ * @example
+ * ```typescript
+ * const result = await iterateFirestoreDocumentSnapshots({
+ *   queryFactory,
+ *   constraintsFactory: [where('active', '==', true)],
+ *   limitPerCheckpoint: 200,
+ *   totalSnapshotsLimit: 1000,
+ *   iterateSnapshot: async (snapshot) => {
+ *     const data = snapshot.data();
+ *     await externalApi.sync(data);
+ *   }
+ * });
+ * ```
  */
 async function iterateFirestoreDocumentSnapshots(config) {
     const { iterateSnapshot, performTasksConfig, snapshotsPerformTasksConfig } = config;
@@ -3316,10 +3436,32 @@ async function iterateFirestoreDocumentSnapshots(config) {
     });
 }
 /**
- * Iterates through the results of a Firestore query by each FirestoreDocumentSnapshotDataPair.
+ * Iterates through Firestore query results in batches, loading each batch as
+ * {@link FirestoreDocumentSnapshotDataPairWithData} instances before processing.
  *
- * @param config
- * @returns
+ * Built on {@link iterateFirestoreDocumentSnapshotBatches} with `maxParallelCheckpoints: 1`.
+ * Each batch of raw snapshots is resolved through the `documentAccessor` to produce
+ * typed document-snapshot pairs. Use this when you need batch-level operations with
+ * typed document access (e.g., bulk updates, batch writes).
+ *
+ * @param config - Iteration config including the document accessor and per-batch callback
+ * @returns Checkpoint-level statistics (total checkpoints, snapshots visited, limit status)
+ *
+ * @example
+ * ```typescript
+ * const result = await iterateFirestoreDocumentSnapshotPairBatches({
+ *   queryFactory,
+ *   constraintsFactory: [where('needsMigration', '==', true)],
+ *   limitPerCheckpoint: 500,
+ *   batchSize: 50,
+ *   documentAccessor: collection.documentAccessor(),
+ *   iterateSnapshotPairsBatch: async (pairs, batchIndex) => {
+ *     const writeBatch = firestore.batch();
+ *     pairs.forEach((pair) => writeBatch.update(pair.document.documentRef, { migrated: true }));
+ *     await writeBatch.commit();
+ *   }
+ * });
+ * ```
  */
 async function iterateFirestoreDocumentSnapshotPairBatches(config) {
     const { iterateSnapshotPairsBatch, documentAccessor } = config;
@@ -3340,10 +3482,32 @@ async function iterateFirestoreDocumentSnapshotPairBatches(config) {
  */
 const DEFAULT_ITERATE_FIRESTORE_DOCUMENT_SNAPSHOT_BATCHES_BATCH_SIZE = 25;
 /**
- * Iterates through the results of a Firestore query by each document snapshot.
+ * Iterates through Firestore query results by subdividing each checkpoint into smaller batches.
  *
- * @param config
- * @returns
+ * Built on {@link iterateFirestoreDocumentSnapshotCheckpoints}, this function takes each
+ * checkpoint's snapshots and splits them into batches (default size: 25). Batches are
+ * processed via {@link performAsyncTasks}, sequential by default. Use this when operations
+ * have size limits (e.g., Firestore batch writes) or benefit from controlled chunk sizes.
+ *
+ * For per-snapshot processing, use {@link iterateFirestoreDocumentSnapshots}.
+ * For batch processing with typed document pairs, use {@link iterateFirestoreDocumentSnapshotPairBatches}.
+ *
+ * @param config - Iteration config including batch size and per-batch callback
+ * @returns Checkpoint-level statistics (total checkpoints, snapshots visited, limit status)
+ *
+ * @example
+ * ```typescript
+ * const result = await iterateFirestoreDocumentSnapshotBatches({
+ *   queryFactory,
+ *   constraintsFactory: [where('type', '==', 'order')],
+ *   limitPerCheckpoint: 500,
+ *   batchSize: 100,
+ *   iterateSnapshotBatch: async (snapshots, batchIndex) => {
+ *     const data = snapshots.map((s) => s.data());
+ *     await analytics.trackBatch(data);
+ *   }
+ * });
+ * ```
  */
 async function iterateFirestoreDocumentSnapshotBatches(config) {
     const { iterateSnapshotBatch, batchSizeForSnapshots: inputBatchSizeForSnapshots, performTasksConfig, batchSize: inputBatchSize } = config;
@@ -3369,29 +3533,75 @@ async function iterateFirestoreDocumentSnapshotBatches(config) {
     });
 }
 /**
- * Creates a IterateFirestoreDocumentSnapshotCheckpointsFilterCheckpointSnapshotsFunction that filters out any repeat documents.
+ * Creates a checkpoint filter that deduplicates documents across checkpoints.
+ *
+ * Repeat documents can appear when a document is updated during iteration and
+ * re-matches the query in a subsequent checkpoint. This factory returns a stateful
+ * filter that tracks seen document keys and removes duplicates.
  *
- * Repeat documents can occur in cases where the document is updated and the query matches it again for a different reason.
- * This utility function creates a filter that prevents processing the same document multiple times.
+ * The filter maintains state across checkpoints — use a single instance for the
+ * entire iteration run. Pair with `handleRepeatCursor: false` to also terminate
+ * iteration when cursor-level repeats are detected.
  *
- * @param readKeyFunction - Function that extracts a unique key from a document snapshot, defaults to document ID
- * @returns A filter function that prevents duplicate document processing
+ * @param readKeyFunction - Extracts a unique key from each snapshot; defaults to `snapshot.id`
+ * @returns A stateful filter function suitable for `filterCheckpointSnapshots`
+ *
+ * @example
+ * ```typescript
+ * const result = await iterateFirestoreDocumentSnapshotCheckpoints({
+ *   queryFactory,
+ *   constraintsFactory: [orderBy('updatedAt')],
+ *   limitPerCheckpoint: 100,
+ *   filterCheckpointSnapshots: filterRepeatCheckpointSnapshots(),
+ *   handleRepeatCursor: false,
+ *   iterateCheckpoint: async (snapshots) => {
+ *     return snapshots.map((s) => s.data());
+ *   }
+ * });
+ * ```
  */
 function filterRepeatCheckpointSnapshots(readKeyFunction = (x) => x.id) {
     const allowOnceFilter = util.allowValueOnceFilter(readKeyFunction);
     return async (snapshots) => snapshots.filter(allowOnceFilter);
 }
 /**
- * Iterates through the results of a Firestore query in several batches.
+ * Core cursor-based pagination engine for iterating through Firestore query results.
  *
- * This is the core pagination function that handles cursor-based iteration through
- * potentially large Firestore query results. It manages cursor documents, checkpoint
- * processing, parallel execution, and various limit controls.
+ * This is the foundational function in the Firestore iteration hierarchy. It drives
+ * sequential cursor-based pagination: each "checkpoint" executes a Firestore query,
+ * uses the last document as a `startAfter` cursor for the next query, and passes
+ * results to the `iterateCheckpoint` callback.
  *
- * @template T - The document data type
- * @template R - The result type of the iteration
- * @param config - Complete configuration for the pagination and processing behavior
- * @returns Promise resolving to statistics about the iteration
+ * The iteration loop continues until one of these conditions is met:
+ * - A query returns no results (no more matching documents)
+ * - The `totalSnapshotsLimit` is reached
+ * - A repeat cursor is detected and `handleRepeatCursor` returns `false`
+ * - The effective `limitPerCheckpoint` calculates to 0 remaining
+ *
+ * Higher-level functions build on this:
+ * - {@link iterateFirestoreDocumentSnapshotBatches} — subdivides checkpoints into smaller batches
+ * - {@link iterateFirestoreDocumentSnapshots} — processes one snapshot at a time
+ * - {@link iterateFirestoreDocumentSnapshotPairs} — loads typed document wrappers per snapshot
+ *
+ * @param config - Complete configuration for pagination, processing, and termination behavior
+ * @returns Statistics including total checkpoints executed, snapshots visited, and whether the limit was hit
+ *
+ * @example
+ * ```typescript
+ * const result = await iterateFirestoreDocumentSnapshotCheckpoints({
+ *   queryFactory,
+ *   constraintsFactory: [where('createdAt', '<=', cutoffDate), orderBy('createdAt')],
+ *   limitPerCheckpoint: 200,
+ *   totalSnapshotsLimit: 5000,
+ *   handleRepeatCursor: false,
+ *   iterateCheckpoint: async (snapshots, querySnapshot) => {
+ *     return snapshots.map((s) => ({ id: s.id, data: s.data() }));
+ *   },
+ *   useCheckpointResult: (result) => {
+ *     console.log(`Checkpoint ${result.i}: processed ${result.docSnapshots.length} docs`);
+ *   }
+ * });
+ * ```
  */
 async function iterateFirestoreDocumentSnapshotCheckpoints(config) {
     const { iterateCheckpoint, filterCheckpointSnapshots: inputFilterCheckpointSnapshot, handleRepeatCursor: inputHandleRepeatCursor, waitBetweenCheckpoints, useCheckpointResult, constraintsFactory: inputConstraintsFactory, dynamicConstraints: inputDynamicConstraints, queryFactory, maxParallelCheckpoints = 1, limitPerCheckpoint: inputLimitPerCheckpoint, totalSnapshotsLimit: inputTotalSnapshotsLimit } = config;
@@ -3494,13 +3704,20 @@ async function iterateFirestoreDocumentSnapshotCheckpoints(config) {
 }
 // MARK: Utility
 /**
- * Creates a filter that allows each document snapshot to be processed only once based on its path.
+ * Creates a stateful filter that allows each document snapshot through only once,
+ * keyed by its full Firestore model path.
  *
- * This utility helps prevent duplicate processing of documents by tracking which ones have
- * already been seen based on their path.
+ * Unlike {@link filterRepeatCheckpointSnapshots} which uses document ID by default,
+ * this filter uses the full document path ({@link readFirestoreModelKeyFromDocumentSnapshot}),
+ * making it suitable for cross-collection iteration where document IDs alone may collide.
  *
- * @template T - The document snapshot type
- * @returns A filter function that only allows each unique document to pass once
+ * @returns A reusable filter function that passes each unique document path exactly once
+ *
+ * @example
+ * ```typescript
+ * const onceFilter = allowDocumentSnapshotWithPathOnceFilter();
+ * const uniqueSnapshots = allSnapshots.filter(onceFilter);
+ * ```
  */
 function allowDocumentSnapshotWithPathOnceFilter() {
     return util.allowValueOnceFilter(readFirestoreModelKeyFromDocumentSnapshot);
@@ -5226,62 +5443,15 @@ const DBX_FIREBASE_SERVER_NO_AUTH_ERROR_CODE = 'NO_AUTH';
  */
 const DBX_FIREBASE_SERVER_NO_UID_ERROR_CODE = 'NO_USER_UID';
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-function __metadata(metadataKey, metadataValue) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 exports.ScheduledFunctionDevelopmentFunctionTypeEnum = void 0;
 (function (ScheduledFunctionDevelopmentFunctionTypeEnum) {
     ScheduledFunctionDevelopmentFunctionTypeEnum["LIST"] = "list";
     ScheduledFunctionDevelopmentFunctionTypeEnum["RUN"] = "run";
 })(exports.ScheduledFunctionDevelopmentFunctionTypeEnum || (exports.ScheduledFunctionDevelopmentFunctionTypeEnum = {}));
-class ScheduledFunctionDevelopmentFirebaseFunctionParams {
-    type;
-    /**
-     * Name of function to run.
-     */
-    run;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsEnum(exports.ScheduledFunctionDevelopmentFunctionTypeEnum),
-    __metadata("design:type", String)
-], ScheduledFunctionDevelopmentFirebaseFunctionParams.prototype, "type", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsString(),
-    classValidator.IsOptional(),
-    __metadata("design:type", String)
-], ScheduledFunctionDevelopmentFirebaseFunctionParams.prototype, "run", void 0);
+const scheduledFunctionDevelopmentFirebaseFunctionParamsType = arktype.type({
+    type: "'list' | 'run'",
+    'run?': 'string'
+});
 class ScheduledFunctionDevelopmentFirebaseFunctionListEntry {
     name;
 }
@@ -5308,101 +5478,30 @@ function firebaseModelLoader(getFirestoreCollection) {
 }
 
 /**
- * isFirestoreModelKey validator
- */
-function IsFirestoreModelKey(validationOptions) {
-    return function (object, propertyName) {
-        classValidator.registerDecorator({
-            name: 'isFirestoreModelKey',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate: isFirestoreModelKey,
-                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a FirestoreModelKey.`, validationOptions)
-            }
-        });
-    };
-}
+ * ArkType schema for a FirestoreModelKey (full path like "collection/12345").
+ */
+const firestoreModelKeyType = arktype.type('string > 0').narrow((val, ctx) => isFirestoreModelKey(val) || ctx.mustBe('a valid FirestoreModelKey'));
 /**
- * isFirestoreModelId validator
+ * ArkType schema for a FirestoreModelId (document ID like "12345").
  */
-function IsFirestoreModelId(validationOptions) {
-    return function (object, propertyName) {
-        classValidator.registerDecorator({
-            name: 'isFirestoreModelId',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate: isFirestoreModelId,
-                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a FirestoreModelId.`, validationOptions)
-            }
-        });
-    };
-}
+const firestoreModelIdType = arktype.type('string > 0').narrow((val, ctx) => isFirestoreModelId(val) || ctx.mustBe('a valid FirestoreModelId'));
 /**
- * isFirestoreModelIdOrKey validator
+ * ArkType schema for a FirestoreModelId or FirestoreModelKey.
  */
-function IsFirestoreModelIdOrKey(validationOptions) {
-    return function (object, propertyName) {
-        classValidator.registerDecorator({
-            name: 'isFirestoreModelIdOrKey',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate: isFirestoreModelIdOrKey,
-                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a FirestoreModelId or FirestoreModelKey.`, validationOptions)
-            }
-        });
-    };
-}
+const firestoreModelIdOrKeyType = arktype.type('string > 0').narrow((val, ctx) => isFirestoreModelIdOrKey(val) || ctx.mustBe('a valid FirestoreModelId or FirestoreModelKey'));
 
-/**
- * Simple annotated params that implements FirestoreModelKeyRef.
- */
-class TargetModelParams {
-    key;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsNotEmpty(),
-    IsFirestoreModelKey(),
-    __metadata("design:type", String)
-], TargetModelParams.prototype, "key", void 0);
-class InferredTargetModelParams {
-    key;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsNotEmpty(),
-    IsFirestoreModelKey(),
-    __metadata("design:type", String)
-], InferredTargetModelParams.prototype, "key", void 0);
-/**
- * Simple annotated params that implements FirestoreModelKeyRef but key is a FirestoreModelId.
- */
-class TargetModelIdParams {
-    key;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsNotEmpty(),
-    IsFirestoreModelId(),
-    __metadata("design:type", String)
-], TargetModelIdParams.prototype, "key", void 0);
-class InferredTargetModelIdParams {
-    key;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsNotEmpty(),
-    IsFirestoreModelId(),
-    __metadata("design:type", String)
-], InferredTargetModelIdParams.prototype, "key", void 0);
+const targetModelParamsType = arktype.type({
+    key: firestoreModelKeyType
+});
+const inferredTargetModelParamsType = arktype.type({
+    'key?': firestoreModelKeyType
+});
+const targetModelIdParamsType = arktype.type({
+    key: firestoreModelIdType
+});
+const inferredTargetModelIdParamsType = arktype.type({
+    'key?': firestoreModelIdType
+});
 
 /**
  * Abstract AbstractModelPermissionService implementation for FirebaseModelsPermissionService.
@@ -6775,582 +6874,95 @@ const NOTIFICATION_SUBJECT_MIN_LENGTH = 2;
 const NOTIFICATION_SUBJECT_MAX_LENGTH = 100;
 const NOTIFICATION_MESSAGE_MIN_LENGTH = 2;
 const NOTIFICATION_MESSAGE_MAX_LENGTH = 1000;
-/**
- * Config entries are inserted, unless marked as remove.
- */
-class NotificationBoxRecipientTemplateConfigArrayEntryParam {
-    type;
-    sd;
-    se;
-    st;
-    sp;
-    sn;
-    /**
-     * If true, removes this configuration
-     */
-    remove;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsString(),
-    __metadata("design:type", String)
-], NotificationBoxRecipientTemplateConfigArrayEntryParam.prototype, "type", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], NotificationBoxRecipientTemplateConfigArrayEntryParam.prototype, "sd", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], NotificationBoxRecipientTemplateConfigArrayEntryParam.prototype, "se", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], NotificationBoxRecipientTemplateConfigArrayEntryParam.prototype, "st", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], NotificationBoxRecipientTemplateConfigArrayEntryParam.prototype, "sp", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], NotificationBoxRecipientTemplateConfigArrayEntryParam.prototype, "sn", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], NotificationBoxRecipientTemplateConfigArrayEntryParam.prototype, "remove", void 0);
-/**
- * Used for creating a new NotificationUser for a user.
- */
-class CreateNotificationUserParams {
-    /**
-     * UID of the user to create the NotificationUser for.
-     */
-    uid;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    IsFirestoreModelId(),
-    __metadata("design:type", String)
-], CreateNotificationUserParams.prototype, "uid", void 0);
-/**
- * Used for updating the global or default config on a NotificationUser.
- */
-class UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams {
-    /**
-     * NotificationBox recipient to update. Is ignored if UID is provided and matches a user. Used for external recipients/users.
-     */
-    i;
-    /**
-     * Override email address
-     */
-    e;
-    /**
-     * Override phone number
-     */
-    t;
-    /**
-     * Array of configs that correspond with "c"
-     */
-    configs;
-    lk;
-    bk;
-    f;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsNumber(),
-    __metadata("design:type", Object)
-], UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams.prototype, "i", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsEmail(),
-    __metadata("design:type", Object)
-], UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams.prototype, "e", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    model.IsE164PhoneNumber(),
-    __metadata("design:type", Object)
-], UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams.prototype, "t", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsArray(),
-    classValidator.ValidateNested({ each: true }),
-    classTransformer.Type(() => NotificationBoxRecipientTemplateConfigArrayEntryParam),
-    __metadata("design:type", Object)
-], UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams.prototype, "configs", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsBoolean(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Object)
-], UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams.prototype, "lk", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsBoolean(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Object)
-], UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams.prototype, "bk", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsEnum(exports.NotificationBoxRecipientFlag),
-    __metadata("design:type", Object)
-], UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams.prototype, "f", void 0);
-class UpdateNotificationBoxRecipientLikeParams {
-    /**
-     * Override email address
-     */
-    e;
-    /**
-     * Override phone number
-     */
-    t;
-    /**
-     * Notification summary id
-     */
-    s;
-    /**
-     * Array of configs
-     */
-    configs;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsEmail(),
-    __metadata("design:type", Object)
-], UpdateNotificationBoxRecipientLikeParams.prototype, "e", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    model.IsE164PhoneNumber(),
-    __metadata("design:type", Object)
-], UpdateNotificationBoxRecipientLikeParams.prototype, "t", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsPhoneNumber(),
-    __metadata("design:type", Object)
-], UpdateNotificationBoxRecipientLikeParams.prototype, "s", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsArray(),
-    classValidator.ValidateNested({ each: true }),
-    classTransformer.Type(() => NotificationBoxRecipientTemplateConfigArrayEntryParam),
-    __metadata("design:type", Object)
-], UpdateNotificationBoxRecipientLikeParams.prototype, "configs", void 0);
-/**
- * Used for updating the target NotificationUserNotificationBoxRecipientConfig.
- */
-class UpdateNotificationUserNotificationBoxRecipientParams extends UpdateNotificationBoxRecipientLikeParams {
-    /**
-     * NotificationBox config to update
-     */
-    nb;
-    rm;
-    lk;
-    bk;
-    f;
-    /**
-     * Whether or not to delete this configuration entirely.
-     *
-     * Will only delete if rm is true and ns is false. Is ignored otherwise.
-     */
-    deleteRemovedConfig;
-}
-__decorate([
-    classTransformer.Expose(),
-    IsFirestoreModelId(),
-    __metadata("design:type", String)
-], UpdateNotificationUserNotificationBoxRecipientParams.prototype, "nb", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], UpdateNotificationUserNotificationBoxRecipientParams.prototype, "rm", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], UpdateNotificationUserNotificationBoxRecipientParams.prototype, "lk", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], UpdateNotificationUserNotificationBoxRecipientParams.prototype, "bk", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsEnum(() => exports.NotificationBoxRecipientFlag),
-    __metadata("design:type", Object)
-], UpdateNotificationUserNotificationBoxRecipientParams.prototype, "f", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], UpdateNotificationUserNotificationBoxRecipientParams.prototype, "deleteRemovedConfig", void 0);
-/**
- * Used for updating the NotificationUser.
- */
-class UpdateNotificationUserParams extends TargetModelParams {
-    // TODO: update configs...
-    gc;
-    dc;
-    bc;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.ValidateNested(),
-    classTransformer.Type(() => UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams),
-    __metadata("design:type", Object)
-], UpdateNotificationUserParams.prototype, "gc", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.ValidateNested(),
-    classTransformer.Type(() => UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams),
-    __metadata("design:type", Object)
-], UpdateNotificationUserParams.prototype, "dc", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsArray(),
-    classValidator.ValidateNested({ each: true }),
-    classTransformer.Type(() => UpdateNotificationUserNotificationBoxRecipientParams),
-    __metadata("design:type", Object)
-], UpdateNotificationUserParams.prototype, "bc", void 0);
-class ResyncNotificationUserParams extends TargetModelParams {
-}
-class ResyncAllNotificationUserParams {
-}
-/**
- * Used for creating a new NotificationSummary for a model.
- */
-class CreateNotificationSummaryParams {
-    /**
-     * Model to create the NotificationSummary for.
-     */
-    model;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsNotEmpty(),
-    IsFirestoreModelKey(),
-    __metadata("design:type", String)
-], CreateNotificationSummaryParams.prototype, "model", void 0);
-/**
- * Used for updating the NotificationSummary.
- */
-class UpdateNotificationSummaryParams extends TargetModelParams {
-    /**
-     * Updates the "rat" time to now.
-     */
-    flagAllRead;
-    /**
-     * Sets the "rat" time to the given date, or clears it.
-     */
-    setReadAtTime;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], UpdateNotificationSummaryParams.prototype, "flagAllRead", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsDate(),
-    classTransformer.Type(() => Date),
-    __metadata("design:type", Object)
-], UpdateNotificationSummaryParams.prototype, "setReadAtTime", void 0);
-/**
- * Used for creating or initializing a new NotificationBox for a model.
- *
- * Mainly used for testing. Not exposed to the API.
- *
- * The preferred way is to create a NotificationBox through a Notification.
- */
-class CreateNotificationBoxParams {
-    model;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsNotEmpty(),
-    IsFirestoreModelKey(),
-    __metadata("design:type", String)
-], CreateNotificationBoxParams.prototype, "model", void 0);
-/**
- * Used for initializing an uninitialized model like NotificationBox or NotificationSummary.
- */
-class InitializeNotificationModelParams extends TargetModelParams {
-    /**
-     * Whether or not to throw an error if the notification has already been sent or is being sent.
-     */
-    throwErrorIfAlreadyInitialized;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsBoolean(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Boolean)
-], InitializeNotificationModelParams.prototype, "throwErrorIfAlreadyInitialized", void 0);
-class InitializeAllApplicableNotificationBoxesParams {
-}
-class InitializeAllApplicableNotificationSummariesParams {
-}
-/**
- * Used for updating the NotificationBox.
- */
-class UpdateNotificationBoxParams extends TargetModelParams {
-}
-/**
- * Used to create/update a notification box recipient.
- */
-class UpdateNotificationBoxRecipientParams extends UpdateNotificationBoxRecipientLikeParams {
-    /**
-     * NotificationBox key to update.
-     */
-    key;
-    /**
-     * NotificationBox recipient to update. Is ignored if UID is provided and matches a user. Used for external recipients/users.
-     */
-    i;
-    /**
-     * Notification recipient to update by UID, if applicable.
-     */
-    uid;
-    /**
-     * Whether or not to create the user if they currently do not exist. Defaults to false.
-     */
-    insert;
-    /**
-     * Whether or not to enable/disable the recipient from recieving items from this box.
-     */
-    enabled;
-    /**
-     * Whether or not to remove the user if they exist. Defaults to false.
-     */
-    remove;
-    /**
-     * If true, the target recipient will have this NotificationBox added to their exclusion list.
-     * If false, the target recipient will have this NotificationBox removed from their exclusion list.
-     *
-     * If set, the other functions are ignored.
-     *
-     * If targeting the user by the index, the NotificationBox must exist, and the user must have a uid, otherwise an error will be thrown.
-     */
-    setExclusion;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsNotEmpty(),
-    IsFirestoreModelKey(),
-    __metadata("design:type", String)
-], UpdateNotificationBoxRecipientParams.prototype, "key", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsNumber(),
-    __metadata("design:type", Object)
-], UpdateNotificationBoxRecipientParams.prototype, "i", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    IsFirestoreModelId(),
-    __metadata("design:type", Object)
-], UpdateNotificationBoxRecipientParams.prototype, "uid", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], UpdateNotificationBoxRecipientParams.prototype, "insert", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], UpdateNotificationBoxRecipientParams.prototype, "enabled", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], UpdateNotificationBoxRecipientParams.prototype, "remove", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], UpdateNotificationBoxRecipientParams.prototype, "setExclusion", void 0);
-class NotificationRecipientParams {
-    /**
-     * User to send the notification to.
-     */
-    uid;
-    /**
-     * Recipient Name
-     */
-    un;
-    /**
-     * Email address
-     */
-    e;
-    /**
-     * Phone number
-     */
-    p;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    IsFirestoreModelId(),
-    __metadata("design:type", Object)
-], NotificationRecipientParams.prototype, "uid", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsString(),
-    classValidator.MinLength(NOTIFICATION_RECIPIENT_NAME_MIN_LENGTH),
-    classValidator.MaxLength(NOTIFICATION_RECIPIENT_NAME_MAX_LENGTH),
-    __metadata("design:type", Object)
-], NotificationRecipientParams.prototype, "un", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsEmail(),
-    __metadata("design:type", Object)
-], NotificationRecipientParams.prototype, "e", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsPhoneNumber(),
-    __metadata("design:type", Object)
-], NotificationRecipientParams.prototype, "p", void 0);
-/**
- * Used for sending the notification immediately, if it has not already been sent.
- */
-class SendNotificationParams extends TargetModelParams {
-    /**
-     * Whether or not to ignore the send at time. Defaults to false.
-     *
-     * If true, the send at time will be ignored and the notification will be sent immediately.
-     */
-    ignoreSendAtThrottle;
-    /**
-     * Whether or not to throw an error if the notification has already been sent or is being sent.
-     *
-     * Defaults to false.
-     */
-    throwErrorIfSent;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], SendNotificationParams.prototype, "ignoreSendAtThrottle", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], SendNotificationParams.prototype, "throwErrorIfSent", void 0);
-/**
- * Params class used for subscribing a system user to a NotificationBox for a model.
- */
-class AbstractSubscribeToNotificationBoxParams extends TargetModelParams {
-    /**
-     * Notification recipient to subscribe to notifications
-     */
-    uid;
-}
-__decorate([
-    classTransformer.Expose(),
-    IsFirestoreModelId(),
-    __metadata("design:type", String)
-], AbstractSubscribeToNotificationBoxParams.prototype, "uid", void 0);
-class AbstractSubscribeOrUnsubscribeToNotificationBoxParams extends AbstractSubscribeToNotificationBoxParams {
-    /**
-     * If true, unsubscribes from the notification box instead.
-     */
-    unsubscribe;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsBoolean(),
-    __metadata("design:type", Object)
-], AbstractSubscribeOrUnsubscribeToNotificationBoxParams.prototype, "unsubscribe", void 0);
-/**
- * Used for sending queued notifications in the system.
- */
-class SendQueuedNotificationsParams {
-    /**
-     * The max number of send loops to run.
-     *
-     * No limit by default.
-     */
-    maxSendNotificationLoops;
-    /**
-     * The max number of parallel send tasks to run.
-     *
-     * Defaults to 5.
-     */
-    maxParellelSendTasks;
-    /**
-     * The threshold to use when to log a warning for an excessive of notification loops.
-     */
-    sendNotificationLoopsTaskExcessThreshold;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsNumber(),
-    __metadata("design:type", Object)
-], SendQueuedNotificationsParams.prototype, "maxSendNotificationLoops", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsNumber(),
-    __metadata("design:type", Object)
-], SendQueuedNotificationsParams.prototype, "maxParellelSendTasks", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsNumber(),
-    __metadata("design:type", Object)
-], SendQueuedNotificationsParams.prototype, "sendNotificationLoopsTaskExcessThreshold", void 0);
-/**
- * Used for sending queued notifications in the system.
- */
-class CleanupSentNotificationsParams {
-}
+const notificationBoxRecipientTemplateConfigArrayEntryParamType = arktype.type({
+    type: 'string > 0',
+    'sd?': model.clearable('boolean'),
+    'se?': model.clearable('boolean'),
+    'st?': model.clearable('boolean'),
+    'sp?': model.clearable('boolean'),
+    'sn?': model.clearable('boolean'),
+    'remove?': model.clearable('boolean')
+});
+const createNotificationUserParamsType = arktype.type({
+    uid: firestoreModelIdType
+});
+const updateNotificationUserDefaultNotificationBoxRecipientConfigParamsType = arktype.type({
+    'i?': model.clearable('number'),
+    'e?': model.clearable('string.email'),
+    't?': model.clearable(model.e164PhoneNumberType),
+    'configs?': model.clearable(notificationBoxRecipientTemplateConfigArrayEntryParamType.array()),
+    'lk?': model.clearable('boolean'),
+    'bk?': model.clearable('boolean'),
+    'f?': model.clearable(arktype.type.enumerated(exports.NotificationBoxRecipientFlag.ENABLED, exports.NotificationBoxRecipientFlag.DISABLED, exports.NotificationBoxRecipientFlag.OPT_OUT))
+});
+const updateNotificationBoxRecipientLikeParamsType = arktype.type({
+    'e?': model.clearable('string.email'),
+    't?': model.clearable(model.e164PhoneNumberType),
+    's?': model.clearable('string'),
+    'configs?': model.clearable(notificationBoxRecipientTemplateConfigArrayEntryParamType.array())
+});
+const updateNotificationUserNotificationBoxRecipientParamsType = updateNotificationBoxRecipientLikeParamsType.merge({
+    nb: firestoreModelIdType,
+    'rm?': model.clearable('boolean'),
+    'lk?': model.clearable('boolean'),
+    'bk?': model.clearable('boolean'),
+    'f?': model.clearable(arktype.type.enumerated(exports.NotificationBoxRecipientFlag.ENABLED, exports.NotificationBoxRecipientFlag.DISABLED, exports.NotificationBoxRecipientFlag.OPT_OUT)),
+    'deleteRemovedConfig?': model.clearable('boolean')
+});
+const updateNotificationUserParamsType = targetModelParamsType.merge({
+    'gc?': model.clearable(updateNotificationUserDefaultNotificationBoxRecipientConfigParamsType),
+    'dc?': model.clearable(updateNotificationUserDefaultNotificationBoxRecipientConfigParamsType),
+    'bc?': model.clearable(updateNotificationUserNotificationBoxRecipientParamsType.array())
+});
+const resyncNotificationUserParamsType = targetModelParamsType;
+const resyncAllNotificationUserParamsType = arktype.type({});
+const createNotificationSummaryParamsType = arktype.type({
+    model: firestoreModelKeyType
+});
+const updateNotificationSummaryParamsType = targetModelParamsType.merge({
+    'flagAllRead?': model.clearable('boolean'),
+    'setReadAtTime?': model.clearable('string.date.parse')
+});
+const createNotificationBoxParamsType = arktype.type({
+    model: firestoreModelKeyType
+});
+const initializeNotificationModelParamsType = targetModelParamsType.merge({
+    'throwErrorIfAlreadyInitialized?': 'boolean'
+});
+const initializeAllApplicableNotificationBoxesParamsType = arktype.type({});
+const initializeAllApplicableNotificationSummariesParamsType = arktype.type({});
+const updateNotificationBoxParamsType = targetModelParamsType;
+const updateNotificationBoxRecipientParamsType = updateNotificationBoxRecipientLikeParamsType.merge({
+    key: firestoreModelKeyType,
+    'i?': model.clearable('number'),
+    'uid?': model.clearable(firestoreModelIdType),
+    'insert?': model.clearable('boolean'),
+    'enabled?': model.clearable('boolean'),
+    'remove?': model.clearable('boolean'),
+    'setExclusion?': model.clearable('boolean')
+});
+const notificationRecipientParamsType = arktype.type({
+    'uid?': model.clearable(firestoreModelIdType),
+    'un?': model.clearable(`string >= ${NOTIFICATION_RECIPIENT_NAME_MIN_LENGTH} & string <= ${NOTIFICATION_RECIPIENT_NAME_MAX_LENGTH}`),
+    'e?': model.clearable('string.email'),
+    'p?': model.clearable('string')
+});
+const sendNotificationParamsType = targetModelParamsType.merge({
+    'ignoreSendAtThrottle?': model.clearable('boolean'),
+    'throwErrorIfSent?': model.clearable('boolean')
+});
+const abstractSubscribeToNotificationBoxParamsType = targetModelParamsType.merge({
+    uid: firestoreModelIdType
+});
+const abstractSubscribeOrUnsubscribeToNotificationBoxParamsType = abstractSubscribeToNotificationBoxParamsType.merge({
+    'unsubscribe?': model.clearable('boolean')
+});
+const sendQueuedNotificationsParamsType = arktype.type({
+    'maxSendNotificationLoops?': model.clearable('number'),
+    'maxParellelSendTasks?': model.clearable('number'),
+    'sendNotificationLoopsTaskExcessThreshold?': model.clearable('number')
+});
+const cleanupSentNotificationsParamsType = arktype.type({});
 const notificationFunctionTypeConfigMap = {};
 const notificationBoxModelCrudFunctionsConfig = {
     notificationUser: ['update:_,resync'],
@@ -8281,325 +7893,61 @@ const STORAGE_FILE_GROUP_QUEUED_FOR_INITIALIZATION_ERROR_CODE = 'STORAGE_FILE_GR
  */
 const STORAGE_FILE_GROUP_CREATE_INPUT_ERROR_CODE = 'STORAGE_FILE_GROUP_CREATE_INPUT_ERROR';
 
-/**
- * Used for directly create a new StorageFile.
- */
-class CreateStorageFileParams {
-}
-/**
- * Initializes all StorageFiles in the uploads folder.
- */
-class InitializeAllStorageFilesFromUploadsParams {
-    /**
-     * The maximum number of files to initialize at once.
-     */
-    maxFilesToInitialize;
-    /**
-     * The specific folder under the uploads folder to search for files and initialize
-     */
-    folderPath;
-    /**
-     * Overrides the default uploads folder path.
-     */
-    overrideUploadsFolderPath;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsNumber(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Object)
-], InitializeAllStorageFilesFromUploadsParams.prototype, "maxFilesToInitialize", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsString(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Object)
-], InitializeAllStorageFilesFromUploadsParams.prototype, "folderPath", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsString(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Object)
-], InitializeAllStorageFilesFromUploadsParams.prototype, "overrideUploadsFolderPath", void 0);
-/**
- * Initializes a StorageFile from the document at the given path.
- */
-class InitializeStorageFileFromUploadParams {
-    /**
-     * Specific bucketId to use.
-     *
-     * If not defined, the default bucket will be used.
-     */
-    bucketId;
-    pathString;
-    /**
-     * Whether or not to attempt to expedite the processing of the created StorageFile, if it is queued for processing.
-     *
-     * If it cannot be processed, this argument will have no effect.
-     */
-    expediteProcessing;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsString(),
-    __metadata("design:type", Object)
-], InitializeStorageFileFromUploadParams.prototype, "bucketId", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsString(),
-    __metadata("design:type", String)
-], InitializeStorageFileFromUploadParams.prototype, "pathString", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsBoolean(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Boolean)
-], InitializeStorageFileFromUploadParams.prototype, "expediteProcessing", void 0);
-class ProcessStorageFileParams extends TargetModelParams {
-    /**
-     * If set, will start/run the processing immediately instead of waiting for the next scheduled run.
-     */
-    runImmediately;
-    /**
-     * If set, will check and retry processing if the StorageFile is in a failed processing state.
-     */
-    checkRetryProcessing;
-    /**
-     * Used with checkRetryProcessing.
-     *
-     * If set, will forcibly create a new processing task even if the existing processing task appears to be ok, or if processing was already marked complete.
-     */
-    forceRestartProcessing;
-    /**
-     * If set, will start the processing again if the StorageFile is in a successful processing state.
-     */
-    processAgainIfSuccessful;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsBoolean(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Object)
-], ProcessStorageFileParams.prototype, "runImmediately", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsBoolean(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Object)
-], ProcessStorageFileParams.prototype, "checkRetryProcessing", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsBoolean(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Object)
-], ProcessStorageFileParams.prototype, "forceRestartProcessing", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsBoolean(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Object)
-], ProcessStorageFileParams.prototype, "processAgainIfSuccessful", void 0);
-/**
- * Processes all StorageFiles that are queued for processing.
- */
-class ProcessAllQueuedStorageFilesParams {
-}
-class UpdateStorageFileParams extends TargetModelParams {
-    /**
-     * Sets the delete at time for the given StorageFileDocument, and queues the file for deletion.
-     */
-    sdat;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsDate(),
-    classValidator.IsOptional(),
-    classTransformer.Type(() => Date),
-    __metadata("design:type", Object)
-], UpdateStorageFileParams.prototype, "sdat", void 0);
-class DeleteStorageFileParams extends TargetModelParams {
-    /**
-     * If true, will force the deletion of the StorageFile even if it is not queued for deletion.
-     */
-    force;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsBoolean(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Object)
-], DeleteStorageFileParams.prototype, "force", void 0);
-/**
- * Processes all StorageFiles that are queued for processing.
- */
-class DeleteAllQueuedStorageFilesParams {
-}
-class DownloadStorageFileParams extends TargetModelParams {
-    /**
-     * Date to expire the download URL.
-     */
-    expiresAt;
-    /**
-     * Duration in milliseconds to expire the download URL from now.
-     */
-    expiresIn;
-    /**
-     * The content disposition for the response to use.
-     */
-    responseDisposition;
-    /**
-     * The content type for the response to use.
-     *
-     * Only available to admins.
-     */
-    responseContentType;
-    /**
-     * Whether or not an admin is creating the link.
-     *
-     * Allows a longer expiration.
-     */
-    asAdmin;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsDate(),
-    classValidator.IsOptional(),
-    classTransformer.Type(() => Date),
-    __metadata("design:type", Object)
-], DownloadStorageFileParams.prototype, "expiresAt", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.Min(0),
-    classValidator.IsNumber(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Object)
-], DownloadStorageFileParams.prototype, "expiresIn", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsString(),
-    __metadata("design:type", Object)
-], DownloadStorageFileParams.prototype, "responseDisposition", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsString(),
-    classValidator.IsMimeType(),
-    __metadata("design:type", Object)
-], DownloadStorageFileParams.prototype, "responseContentType", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsBoolean(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Object)
-], DownloadStorageFileParams.prototype, "asAdmin", void 0);
-/**
- * Used for creating or initializing a new StorageFileGroup for a StorageFile.
- *
- * Mainly used for testing. Not exposed to the API.
- *
- * The preferred way is to create a StorageFileGroup through a StorageFile.
- */
-class CreateStorageFileGroupParams {
-    /**
-     * ModelKey to use for creating the StorageFileGroup.
-     */
-    model;
-    /**
-     * StorageFileId to use for creating the StorageFileGroup.
-     */
-    storageFileId;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsOptional(),
-    classValidator.IsNotEmpty(),
-    IsFirestoreModelKey(),
-    __metadata("design:type", Object)
-], CreateStorageFileGroupParams.prototype, "model", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsNotEmpty(),
-    IsFirestoreModelId(),
-    __metadata("design:type", Object)
-], CreateStorageFileGroupParams.prototype, "storageFileId", void 0);
-class SyncStorageFileWithGroupsParams extends TargetModelParams {
-    /**
-     * If true, will force syncing even if the StorageFile is not flagged for a resync.
-     */
-    force;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsBoolean(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Boolean)
-], SyncStorageFileWithGroupsParams.prototype, "force", void 0);
-class SyncAllFlaggedStorageFilesWithGroupsParams {
-}
-class UpdateStorageFileGroupParams extends TargetModelParams {
-    /**
-     * Entries to update, if selected.
-     */
-    entries;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsArray(),
-    classValidator.IsOptional(),
-    classTransformer.Type(() => UpdateStorageFileGroupEntryParams),
-    classValidator.ValidateNested({ each: true }),
-    __metadata("design:type", Object)
-], UpdateStorageFileGroupParams.prototype, "entries", void 0);
-class UpdateStorageFileGroupEntryParams {
-    s;
-    n;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsNotEmpty(),
-    IsFirestoreModelId(),
-    __metadata("design:type", String)
-], UpdateStorageFileGroupEntryParams.prototype, "s", void 0);
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsString(),
-    classValidator.IsOptional(),
-    classValidator.IsNotEmpty(),
-    __metadata("design:type", Object)
-], UpdateStorageFileGroupEntryParams.prototype, "n", void 0);
-class RegenerateStorageFileGroupContentParams extends TargetModelParams {
-    /**
-     * If true, will force syncing even if the StorageFile is not flagged for a resync.
-     */
-    force;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsBoolean(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Boolean)
-], RegenerateStorageFileGroupContentParams.prototype, "force", void 0);
-class RegenerateAllFlaggedStorageFileGroupsContentParams {
-}
-/**
- * Used for initializing an uninitialized model like NotificationBox or NotificationSummary.
- */
-class InitializeStorageFileModelParams extends TargetModelParams {
-    /**
-     * Whether or not to throw an error if the notification has already been sent or is being sent.
-     */
-    throwErrorIfAlreadyInitialized;
-}
-__decorate([
-    classTransformer.Expose(),
-    classValidator.IsBoolean(),
-    classValidator.IsOptional(),
-    __metadata("design:type", Boolean)
-], InitializeStorageFileModelParams.prototype, "throwErrorIfAlreadyInitialized", void 0);
-class InitializeAllApplicableStorageFileGroupsParams {
-}
+const createStorageFileParamsType = arktype.type({});
+const initializeAllStorageFilesFromUploadsParamsType = arktype.type({
+    'maxFilesToInitialize?': model.clearable('number'),
+    'folderPath?': model.clearable('string'),
+    'overrideUploadsFolderPath?': model.clearable('string')
+});
+const initializeStorageFileFromUploadParamsType = arktype.type({
+    'bucketId?': model.clearable('string'),
+    pathString: 'string > 0',
+    'expediteProcessing?': 'boolean'
+});
+const processStorageFileParamsType = targetModelParamsType.merge({
+    'runImmediately?': model.clearable('boolean'),
+    'checkRetryProcessing?': model.clearable('boolean'),
+    'forceRestartProcessing?': model.clearable('boolean'),
+    'processAgainIfSuccessful?': model.clearable('boolean')
+});
+const processAllQueuedStorageFilesParamsType = arktype.type({});
+const updateStorageFileParamsType = targetModelParamsType.merge({
+    'sdat?': model.clearable('string.date.parse')
+});
+const deleteStorageFileParamsType = targetModelParamsType.merge({
+    'force?': model.clearable('boolean')
+});
+const deleteAllQueuedStorageFilesParamsType = arktype.type({});
+const downloadStorageFileParamsType = targetModelParamsType.merge({
+    'expiresAt?': model.clearable('string.date.parse'),
+    'expiresIn?': model.clearable('number >= 0'),
+    'responseDisposition?': model.clearable('string'),
+    'responseContentType?': model.clearable('string'),
+    'asAdmin?': model.clearable('boolean')
+});
+const createStorageFileGroupParamsType = arktype.type({
+    'model?': model.clearable(firestoreModelKeyType),
+    'storageFileId?': model.clearable(firestoreModelIdType)
+});
+const syncStorageFileWithGroupsParamsType = targetModelParamsType.merge({
+    'force?': 'boolean'
+});
+const syncAllFlaggedStorageFilesWithGroupsParamsType = arktype.type({});
+const updateStorageFileGroupEntryParamsType = arktype.type({
+    s: firestoreModelIdType,
+    'n?': model.clearable('string > 0')
+});
+const updateStorageFileGroupParamsType = targetModelParamsType.merge({
+    'entries?': model.clearable(updateStorageFileGroupEntryParamsType.array())
+});
+const regenerateStorageFileGroupContentParamsType = targetModelParamsType.merge({
+    'force?': 'boolean'
+});
+const regenerateAllFlaggedStorageFileGroupsContentParamsType = arktype.type({});
+const initializeStorageFileModelParamsType = targetModelParamsType.merge({
+    'throwErrorIfAlreadyInitialized?': 'boolean'
+});
+const initializeAllApplicableStorageFileGroupsParamsType = arktype.type({});
 const storageFileFunctionTypeConfigMap = {};
 const storageFileModelCrudFunctionsConfig = {
     storageFile: ['create:_,fromUpload,allFromUpload', 'update:_,process,syncWithGroups', 'delete:_', 'read:download'],
@@ -9463,20 +8811,12 @@ exports.ALL_USER_UPLOADS_FOLDER_PATH = ALL_USER_UPLOADS_FOLDER_PATH;
 exports.AbstractFirestoreDocument = AbstractFirestoreDocument;
 exports.AbstractFirestoreDocumentDataAccessorWrapper = AbstractFirestoreDocumentDataAccessorWrapper;
 exports.AbstractFirestoreDocumentWithParent = AbstractFirestoreDocumentWithParent;
-exports.AbstractSubscribeOrUnsubscribeToNotificationBoxParams = AbstractSubscribeOrUnsubscribeToNotificationBoxParams;
-exports.AbstractSubscribeToNotificationBoxParams = AbstractSubscribeToNotificationBoxParams;
 exports.AppNotificationTemplateTypeInfoRecordService = AppNotificationTemplateTypeInfoRecordService;
 exports.BASE_MODEL_STORAGE_FILE_PATH = BASE_MODEL_STORAGE_FILE_PATH;
 exports.CALL_MODEL_APP_FUNCTION_KEY = CALL_MODEL_APP_FUNCTION_KEY;
 exports.COPY_USER_RELATED_DATA_ACCESSOR_FACTORY_FUNCTION = COPY_USER_RELATED_DATA_ACCESSOR_FACTORY_FUNCTION;
 exports.CREATE_NOTIFICATION_ID_REQUIRED_ERROR_CODE = CREATE_NOTIFICATION_ID_REQUIRED_ERROR_CODE;
-exports.CleanupSentNotificationsParams = CleanupSentNotificationsParams;
 exports.ContextGrantedModelRolesReaderInstance = ContextGrantedModelRolesReaderInstance;
-exports.CreateNotificationBoxParams = CreateNotificationBoxParams;
-exports.CreateNotificationSummaryParams = CreateNotificationSummaryParams;
-exports.CreateNotificationUserParams = CreateNotificationUserParams;
-exports.CreateStorageFileGroupParams = CreateStorageFileGroupParams;
-exports.CreateStorageFileParams = CreateStorageFileParams;
 exports.DBX_FIREBASE_SERVER_NO_AUTH_ERROR_CODE = DBX_FIREBASE_SERVER_NO_AUTH_ERROR_CODE;
 exports.DBX_FIREBASE_SERVER_NO_UID_ERROR_CODE = DBX_FIREBASE_SERVER_NO_UID_ERROR_CODE;
 exports.DEFAULT_DATE_CELL_RANGE_VALUE = DEFAULT_DATE_CELL_RANGE_VALUE;
@@ -9494,9 +8834,6 @@ exports.DEFAULT_QUERY_CHANGE_WATCHER_DELAY = DEFAULT_QUERY_CHANGE_WATCHER_DELAY;
 exports.DEFAULT_SINGLE_ITEM_FIRESTORE_COLLECTION_DOCUMENT_IDENTIFIER = DEFAULT_SINGLE_ITEM_FIRESTORE_COLLECTION_DOCUMENT_IDENTIFIER;
 exports.DEFAULT_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL = DEFAULT_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL;
 exports.DEFAULT_WEBSITE_LINK = DEFAULT_WEBSITE_LINK;
-exports.DeleteAllQueuedStorageFilesParams = DeleteAllQueuedStorageFilesParams;
-exports.DeleteStorageFileParams = DeleteStorageFileParams;
-exports.DownloadStorageFileParams = DownloadStorageFileParams;
 exports.EMPTY_STORAGE_FILE_PURPOSE_SUBGROUP = EMPTY_STORAGE_FILE_PURPOSE_SUBGROUP;
 exports.EXACT_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL = EXACT_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL;
 exports.FIREBASE_AUTH_NETWORK_REQUEST_ERROR = FIREBASE_AUTH_NETWORK_REQUEST_ERROR;
@@ -9539,18 +8876,6 @@ exports.FirebaseDevelopmentFunctions = FirebaseDevelopmentFunctions;
 exports.FirebaseModelPermissionServiceInstance = FirebaseModelPermissionServiceInstance;
 exports.FirebaseServerError = FirebaseServerError;
 exports.HIGH_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL = HIGH_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL;
-exports.InferredTargetModelIdParams = InferredTargetModelIdParams;
-exports.InferredTargetModelParams = InferredTargetModelParams;
-exports.InitializeAllApplicableNotificationBoxesParams = InitializeAllApplicableNotificationBoxesParams;
-exports.InitializeAllApplicableNotificationSummariesParams = InitializeAllApplicableNotificationSummariesParams;
-exports.InitializeAllApplicableStorageFileGroupsParams = InitializeAllApplicableStorageFileGroupsParams;
-exports.InitializeAllStorageFilesFromUploadsParams = InitializeAllStorageFilesFromUploadsParams;
-exports.InitializeNotificationModelParams = InitializeNotificationModelParams;
-exports.InitializeStorageFileFromUploadParams = InitializeStorageFileFromUploadParams;
-exports.InitializeStorageFileModelParams = InitializeStorageFileModelParams;
-exports.IsFirestoreModelId = IsFirestoreModelId;
-exports.IsFirestoreModelIdOrKey = IsFirestoreModelIdOrKey;
-exports.IsFirestoreModelKey = IsFirestoreModelKey;
 exports.LOW_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL = LOW_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL;
 exports.MAX_FIRESTORE_MAP_ZOOM_LEVEL_VALUE = MAX_FIRESTORE_MAP_ZOOM_LEVEL_VALUE;
 exports.MIN_FIRESTORE_MAP_ZOOM_LEVEL_VALUE = MIN_FIRESTORE_MAP_ZOOM_LEVEL_VALUE;
@@ -9579,21 +8904,13 @@ exports.NOTIFICATION_USER_INVALID_UID_FOR_CREATE_ERROR_CODE = NOTIFICATION_USER_
 exports.NOTIFICATION_USER_LOCKED_CONFIG_FROM_BEING_UPDATED_ERROR_CODE = NOTIFICATION_USER_LOCKED_CONFIG_FROM_BEING_UPDATED_ERROR_CODE;
 exports.NOTIFICATION_WEEK_NOTIFICATION_ITEM_LIMIT = NOTIFICATION_WEEK_NOTIFICATION_ITEM_LIMIT;
 exports.NotificationBoxDocument = NotificationBoxDocument;
-exports.NotificationBoxRecipientTemplateConfigArrayEntryParam = NotificationBoxRecipientTemplateConfigArrayEntryParam;
 exports.NotificationDocument = NotificationDocument;
 exports.NotificationFirestoreCollections = NotificationFirestoreCollections;
 exports.NotificationFunctions = NotificationFunctions;
-exports.NotificationRecipientParams = NotificationRecipientParams;
 exports.NotificationSummaryDocument = NotificationSummaryDocument;
 exports.NotificationUserDocument = NotificationUserDocument;
 exports.NotificationWeekDocument = NotificationWeekDocument;
-exports.ProcessAllQueuedStorageFilesParams = ProcessAllQueuedStorageFilesParams;
-exports.ProcessStorageFileParams = ProcessStorageFileParams;
 exports.RUN_DEV_FUNCTION_APP_FUNCTION_KEY = RUN_DEV_FUNCTION_APP_FUNCTION_KEY;
-exports.RegenerateAllFlaggedStorageFileGroupsContentParams = RegenerateAllFlaggedStorageFileGroupsContentParams;
-exports.RegenerateStorageFileGroupContentParams = RegenerateStorageFileGroupContentParams;
-exports.ResyncAllNotificationUserParams = ResyncAllNotificationUserParams;
-exports.ResyncNotificationUserParams = ResyncNotificationUserParams;
 exports.SCHEDULED_FUNCTION_DEV_FUNCTION_SPECIFIER = SCHEDULED_FUNCTION_DEV_FUNCTION_SPECIFIER;
 exports.STORAGEFILE_RELATED_FILE_METADATA_KEY = STORAGEFILE_RELATED_FILE_METADATA_KEY;
 exports.STORAGE_FILE_ALREADY_PROCESSED_ERROR_CODE = STORAGE_FILE_ALREADY_PROCESSED_ERROR_CODE;
@@ -9615,36 +8932,21 @@ exports.STORAGE_FILE_PROCESSING_NOT_QUEUED_FOR_PROCESSING_ERROR_CODE = STORAGE_F
 exports.STORAGE_FILE_PROCESSING_STUCK_THROTTLE_CHECK_MS = STORAGE_FILE_PROCESSING_STUCK_THROTTLE_CHECK_MS;
 exports.STORAGE_FILE_UPLOAD_USER_ROLE = STORAGE_FILE_UPLOAD_USER_ROLE;
 exports.ScheduledFunctionDevelopmentFirebaseFunctionListEntry = ScheduledFunctionDevelopmentFirebaseFunctionListEntry;
-exports.ScheduledFunctionDevelopmentFirebaseFunctionParams = ScheduledFunctionDevelopmentFirebaseFunctionParams;
-exports.SendNotificationParams = SendNotificationParams;
-exports.SendQueuedNotificationsParams = SendQueuedNotificationsParams;
 exports.StorageFileDocument = StorageFileDocument;
 exports.StorageFileFirestoreCollections = StorageFileFirestoreCollections;
 exports.StorageFileFunctions = StorageFileFunctions;
 exports.StorageFileGroupDocument = StorageFileGroupDocument;
 exports.StorageFileUploadStreamUnsupportedError = StorageFileUploadStreamUnsupportedError;
-exports.SyncAllFlaggedStorageFilesWithGroupsParams = SyncAllFlaggedStorageFilesWithGroupsParams;
-exports.SyncStorageFileWithGroupsParams = SyncStorageFileWithGroupsParams;
 exports.SystemStateDocument = SystemStateDocument;
 exports.SystemStateFirestoreCollections = SystemStateFirestoreCollections;
-exports.TargetModelIdParams = TargetModelIdParams;
-exports.TargetModelParams = TargetModelParams;
 exports.UPLOADED_FILE_DOES_NOT_EXIST_ERROR_CODE = UPLOADED_FILE_DOES_NOT_EXIST_ERROR_CODE;
 exports.UPLOADED_FILE_INITIALIZATION_DISCARDED_ERROR_CODE = UPLOADED_FILE_INITIALIZATION_DISCARDED_ERROR_CODE;
 exports.UPLOADED_FILE_INITIALIZATION_FAILED_ERROR_CODE = UPLOADED_FILE_INITIALIZATION_FAILED_ERROR_CODE;
 exports.UPLOADED_FILE_NOT_ALLOWED_TO_BE_INITIALIZED_ERROR_CODE = UPLOADED_FILE_NOT_ALLOWED_TO_BE_INITIALIZED_ERROR_CODE;
 exports.UPLOADS_FOLDER_PATH = UPLOADS_FOLDER_PATH;
-exports.UpdateNotificationBoxParams = UpdateNotificationBoxParams;
-exports.UpdateNotificationBoxRecipientLikeParams = UpdateNotificationBoxRecipientLikeParams;
-exports.UpdateNotificationBoxRecipientParams = UpdateNotificationBoxRecipientParams;
-exports.UpdateNotificationSummaryParams = UpdateNotificationSummaryParams;
-exports.UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams = UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams;
-exports.UpdateNotificationUserNotificationBoxRecipientParams = UpdateNotificationUserNotificationBoxRecipientParams;
-exports.UpdateNotificationUserParams = UpdateNotificationUserParams;
-exports.UpdateStorageFileGroupEntryParams = UpdateStorageFileGroupEntryParams;
-exports.UpdateStorageFileGroupParams = UpdateStorageFileGroupParams;
-exports.UpdateStorageFileParams = UpdateStorageFileParams;
 exports._createNotificationDocumentFromPair = _createNotificationDocumentFromPair;
+exports.abstractSubscribeOrUnsubscribeToNotificationBoxParamsType = abstractSubscribeOrUnsubscribeToNotificationBoxParamsType;
+exports.abstractSubscribeToNotificationBoxParamsType = abstractSubscribeToNotificationBoxParamsType;
 exports.addConstraintToBuilder = addConstraintToBuilder;
 exports.addOrReplaceLimitInConstraints = addOrReplaceLimitInConstraints;
 exports.allChildDocumentsUnderParent = allChildDocumentsUnderParent;
@@ -9673,6 +8975,7 @@ exports.canQueueStorageFileForProcessing = canQueueStorageFileForProcessing;
 exports.childFirestoreModelKey = childFirestoreModelKey;
 exports.childFirestoreModelKeyPath = childFirestoreModelKeyPath;
 exports.childFirestoreModelKeys = childFirestoreModelKeys;
+exports.cleanupSentNotificationsParamsType = cleanupSentNotificationsParamsType;
 exports.clientFirebaseFirestoreContextFactory = clientFirebaseFirestoreContextFactory;
 exports.clientFirebaseStorageContextFactory = clientFirebaseStorageContextFactory;
 exports.combineUploadFileTypeDeterminers = combineUploadFileTypeDeterminers;
@@ -9686,16 +8989,23 @@ exports.copyDocumentIdToFieldModifierFunction = copyDocumentIdToFieldModifierFun
 exports.copyStoragePath = copyStoragePath;
 exports.copyUserRelatedDataAccessorFactoryFunction = copyUserRelatedDataAccessorFactoryFunction;
 exports.copyUserRelatedDataModifierConfig = copyUserRelatedDataModifierConfig;
+exports.createNotificationBoxParamsType = createNotificationBoxParamsType;
 exports.createNotificationDocument = createNotificationDocument;
 exports.createNotificationDocumentIfSending = createNotificationDocumentIfSending;
 exports.createNotificationDocumentPair = createNotificationDocumentPair;
+exports.createNotificationSummaryParamsType = createNotificationSummaryParamsType;
 exports.createNotificationTaskTemplate = createNotificationTaskTemplate;
 exports.createNotificationTemplate = createNotificationTemplate;
+exports.createNotificationUserParamsType = createNotificationUserParamsType;
 exports.createStorageFileDocumentPair = createStorageFileDocumentPair;
 exports.createStorageFileDocumentPairFactory = createStorageFileDocumentPairFactory;
+exports.createStorageFileGroupParamsType = createStorageFileGroupParamsType;
+exports.createStorageFileParamsType = createStorageFileParamsType;
 exports.dataFromDocumentSnapshots = dataFromDocumentSnapshots;
 exports.dataFromSnapshotStream = dataFromSnapshotStream;
 exports.delayCompletion = delayCompletion;
+exports.deleteAllQueuedStorageFilesParamsType = deleteAllQueuedStorageFilesParamsType;
+exports.deleteStorageFileParamsType = deleteStorageFileParamsType;
 exports.determineByFileName = determineByFileName;
 exports.determineByFilePath = determineByFilePath;
 exports.determineByFolderName = determineByFolderName;
@@ -9710,6 +9020,7 @@ exports.documentDataWithIdAndKey = documentDataWithIdAndKey;
 exports.documentReferenceFromDocument = documentReferenceFromDocument;
 exports.documentReferencesFromDocuments = documentReferencesFromDocuments;
 exports.documentReferencesFromSnapshot = documentReferencesFromSnapshot;
+exports.downloadStorageFileParamsType = downloadStorageFileParamsType;
 exports.effectiveNotificationBoxRecipientConfig = effectiveNotificationBoxRecipientConfig;
 exports.effectiveNotificationBoxRecipientTemplateConfig = effectiveNotificationBoxRecipientTemplateConfig;
 exports.endAt = endAt;
@@ -9791,7 +9102,9 @@ exports.firestoreModelIdFromDocument = firestoreModelIdFromDocument;
 exports.firestoreModelIdFromEmail = firestoreModelIdFromEmail;
 exports.firestoreModelIdGrantedRoleArrayMap = firestoreModelIdGrantedRoleArrayMap;
 exports.firestoreModelIdGrantedRoleMap = firestoreModelIdGrantedRoleMap;
+exports.firestoreModelIdOrKeyType = firestoreModelIdOrKeyType;
 exports.firestoreModelIdString = firestoreModelIdString;
+exports.firestoreModelIdType = firestoreModelIdType;
 exports.firestoreModelIdentity = firestoreModelIdentity;
 exports.firestoreModelIdentityTypeMap = firestoreModelIdentityTypeMap;
 exports.firestoreModelIdsFromDocuments = firestoreModelIdsFromDocuments;
@@ -9817,6 +9130,7 @@ exports.firestoreModelKeyPartPairsKeyPath = firestoreModelKeyPartPairsKeyPath;
 exports.firestoreModelKeyPartPairsPaths = firestoreModelKeyPartPairsPaths;
 exports.firestoreModelKeyPath = firestoreModelKeyPath;
 exports.firestoreModelKeyString = firestoreModelKeyString;
+exports.firestoreModelKeyType = firestoreModelKeyType;
 exports.firestoreModelKeyTypePair = firestoreModelKeyTypePair;
 exports.firestoreModelKeys = firestoreModelKeys;
 exports.firestoreModelKeysFromDocuments = firestoreModelKeysFromDocuments;
@@ -9881,6 +9195,15 @@ exports.incrementUpdateWithAccessorFunction = incrementUpdateWithAccessorFunctio
 exports.inferKeyFromTwoWayFlatFirestoreModelKey = inferKeyFromTwoWayFlatFirestoreModelKey;
 exports.inferNotificationBoxRelatedModelKey = inferNotificationBoxRelatedModelKey;
 exports.inferStorageFileGroupRelatedModelKey = inferStorageFileGroupRelatedModelKey;
+exports.inferredTargetModelIdParamsType = inferredTargetModelIdParamsType;
+exports.inferredTargetModelParamsType = inferredTargetModelParamsType;
+exports.initializeAllApplicableNotificationBoxesParamsType = initializeAllApplicableNotificationBoxesParamsType;
+exports.initializeAllApplicableNotificationSummariesParamsType = initializeAllApplicableNotificationSummariesParamsType;
+exports.initializeAllApplicableStorageFileGroupsParamsType = initializeAllApplicableStorageFileGroupsParamsType;
+exports.initializeAllStorageFilesFromUploadsParamsType = initializeAllStorageFilesFromUploadsParamsType;
+exports.initializeNotificationModelParamsType = initializeNotificationModelParamsType;
+exports.initializeStorageFileFromUploadParamsType = initializeStorageFileFromUploadParamsType;
+exports.initializeStorageFileModelParamsType = initializeStorageFileModelParamsType;
 exports.interceptAccessorFactoryFunction = interceptAccessorFactoryFunction;
 exports.isAdminInFirebaseModelContext = isAdminInFirebaseModelContext;
 exports.isClientFirebaseError = isClientFirebaseError;
@@ -9907,6 +9230,7 @@ exports.limit = limit;
 exports.limitToLast = limitToLast;
 exports.limitUploadFileTypeDeterminer = limitUploadFileTypeDeterminer;
 exports.limitedFirestoreDocumentAccessorFactory = limitedFirestoreDocumentAccessorFactory;
+exports.limitedFirestoreDocumentAccessorSnapshotCache = limitedFirestoreDocumentAccessorSnapshotCache;
 exports.loadAllFirestoreDocumentSnapshot = loadAllFirestoreDocumentSnapshot;
 exports.loadAllFirestoreDocumentSnapshotPairs = loadAllFirestoreDocumentSnapshotPairs;
 exports.loadDocumentsForDocumentReferences = loadDocumentsForDocumentReferences;
@@ -9948,6 +9272,7 @@ exports.notificationBoxFirestoreCollection = notificationBoxFirestoreCollection;
 exports.notificationBoxIdForModel = notificationBoxIdForModel;
 exports.notificationBoxIdentity = notificationBoxIdentity;
 exports.notificationBoxModelCrudFunctionsConfig = notificationBoxModelCrudFunctionsConfig;
+exports.notificationBoxRecipientTemplateConfigArrayEntryParamType = notificationBoxRecipientTemplateConfigArrayEntryParamType;
 exports.notificationBoxRecipientTemplateConfigArrayToRecord = notificationBoxRecipientTemplateConfigArrayToRecord;
 exports.notificationBoxRecipientTemplateConfigRecordToArray = notificationBoxRecipientTemplateConfigRecordToArray;
 exports.notificationBoxesFlaggedForNeedsInitializationQuery = notificationBoxesFlaggedForNeedsInitializationQuery;
@@ -9961,6 +9286,7 @@ exports.notificationFunctionMap = notificationFunctionMap;
 exports.notificationFunctionTypeConfigMap = notificationFunctionTypeConfigMap;
 exports.notificationIdentity = notificationIdentity;
 exports.notificationMessageFunction = notificationMessageFunction;
+exports.notificationRecipientParamsType = notificationRecipientParamsType;
 exports.notificationSendExclusionCanSendFunction = notificationSendExclusionCanSendFunction;
 exports.notificationSendFlagsImplyIsComplete = notificationSendFlagsImplyIsComplete;
 exports.notificationSubtaskComplete = notificationSubtaskComplete;
@@ -10015,10 +9341,19 @@ exports.optionalFirestoreUnitedStatesAddress = optionalFirestoreUnitedStatesAddr
 exports.optionalFirestoreUnixDateTimeSecondsNumber = optionalFirestoreUnixDateTimeSecondsNumber;
 exports.orderBy = orderBy;
 exports.orderByDocumentId = orderByDocumentId;
+exports.processAllQueuedStorageFilesParamsType = processAllQueuedStorageFilesParamsType;
+exports.processStorageFileParamsType = processStorageFileParamsType;
 exports.readFirestoreModelKey = readFirestoreModelKey;
 exports.readFirestoreModelKeyFromDocumentSnapshot = readFirestoreModelKeyFromDocumentSnapshot;
+exports.regenerateAllFlaggedStorageFileGroupsContentParamsType = regenerateAllFlaggedStorageFileGroupsContentParamsType;
+exports.regenerateStorageFileGroupContentParamsType = regenerateStorageFileGroupContentParamsType;
 exports.replaceConstraints = replaceConstraints;
+exports.resyncAllNotificationUserParamsType = resyncAllNotificationUserParamsType;
+exports.resyncNotificationUserParamsType = resyncNotificationUserParamsType;
+exports.scheduledFunctionDevelopmentFirebaseFunctionParamsType = scheduledFunctionDevelopmentFirebaseFunctionParamsType;
 exports.selectFromFirebaseModelsService = selectFromFirebaseModelsService;
+exports.sendNotificationParamsType = sendNotificationParamsType;
+exports.sendQueuedNotificationsParamsType = sendQueuedNotificationsParamsType;
 exports.separateConstraints = separateConstraints;
 exports.setIdAndKeyFromKeyIdRefOnDocumentData = setIdAndKeyFromKeyIdRefOnDocumentData;
 exports.setIdAndKeyFromSnapshotOnDocumentData = setIdAndKeyFromSnapshotOnDocumentData;
@@ -10064,20 +9399,35 @@ exports.storagePathFactory = storagePathFactory;
 exports.storedFileReaderFactory = storedFileReaderFactory;
 exports.streamDocumentSnapshotDataPairs = streamDocumentSnapshotDataPairs;
 exports.streamDocumentSnapshotDataPairsWithData = streamDocumentSnapshotDataPairsWithData;
+exports.streamDocumentSnapshotsData = streamDocumentSnapshotsData;
 exports.streamFromOnSnapshot = streamFromOnSnapshot;
+exports.syncAllFlaggedStorageFilesWithGroupsParamsType = syncAllFlaggedStorageFilesWithGroupsParamsType;
+exports.syncStorageFileWithGroupsParamsType = syncStorageFileWithGroupsParamsType;
 exports.systemStateCollectionReference = systemStateCollectionReference;
 exports.systemStateConverter = systemStateConverter;
 exports.systemStateFirestoreCollection = systemStateFirestoreCollection;
 exports.systemStateIdentity = systemStateIdentity;
+exports.targetModelIdParamsType = targetModelIdParamsType;
+exports.targetModelParamsType = targetModelParamsType;
 exports.twoWayFlatFirestoreModelKey = twoWayFlatFirestoreModelKey;
 exports.unreadNotificationItems = unreadNotificationItems;
 exports.unsupportedFirestoreDriverFunctionError = unsupportedFirestoreDriverFunctionError;
+exports.updateNotificationBoxParamsType = updateNotificationBoxParamsType;
+exports.updateNotificationBoxRecipientLikeParamsType = updateNotificationBoxRecipientLikeParamsType;
+exports.updateNotificationBoxRecipientParamsType = updateNotificationBoxRecipientParamsType;
 exports.updateNotificationBoxRecipientTemplateConfigRecord = updateNotificationBoxRecipientTemplateConfigRecord;
 exports.updateNotificationRecipient = updateNotificationRecipient;
+exports.updateNotificationSummaryParamsType = updateNotificationSummaryParamsType;
 exports.updateNotificationUserDefaultNotificationBoxRecipientConfig = updateNotificationUserDefaultNotificationBoxRecipientConfig;
+exports.updateNotificationUserDefaultNotificationBoxRecipientConfigParamsType = updateNotificationUserDefaultNotificationBoxRecipientConfigParamsType;
 exports.updateNotificationUserNotificationBoxRecipientConfigIfChanged = updateNotificationUserNotificationBoxRecipientConfigIfChanged;
 exports.updateNotificationUserNotificationBoxRecipientConfigs = updateNotificationUserNotificationBoxRecipientConfigs;
+exports.updateNotificationUserNotificationBoxRecipientParamsType = updateNotificationUserNotificationBoxRecipientParamsType;
 exports.updateNotificationUserNotificationSendExclusions = updateNotificationUserNotificationSendExclusions;
+exports.updateNotificationUserParamsType = updateNotificationUserParamsType;
+exports.updateStorageFileGroupEntryParamsType = updateStorageFileGroupEntryParamsType;
+exports.updateStorageFileGroupParamsType = updateStorageFileGroupParamsType;
+exports.updateStorageFileParamsType = updateStorageFileParamsType;
 exports.updateWithAccessorUpdateAndConverterFunction = updateWithAccessorUpdateAndConverterFunction;
 exports.uploadFileWithStream = uploadFileWithStream;
 exports.useContextAuth = useContextAuth;