@dereekb/firebase-server 13.11.14 → 13.11.15

package/model/src/lib/notification/notification.task.subtask.handler.d.ts

@@ -218,8 +218,8 @@ export interface NotificationTaskSubtaskNotificationTaskHandlerConfig<I extends
  * This is the primary entry point for building complex, multi-step notification task handlers
  * such as storage file processing or other async workflows.
  *
- * @param factoryConfig - shared configuration including the input function, cleanup logic, and task type
- * @returns a factory function that produces {@link NotificationTaskServiceTaskHandlerConfig} entries
+ * @param factoryConfig - Shared configuration including the input function, cleanup logic, and task type.
+ * @returns A factory function that produces {@link NotificationTaskServiceTaskHandlerConfig} entries.
  *
  * @example
  * ```ts
@@ -251,6 +251,6 @@ export declare class NotificationTaskSubTaskMissingRequiredDataTermination exten
 /**
  * Creates a NotificationTaskSubTaskMissingRequiredDataTermination.
  *
- * @returns a new {@link NotificationTaskSubTaskMissingRequiredDataTermination} error instance
+ * @returns A new {@link NotificationTaskSubTaskMissingRequiredDataTermination} error instance.
  */
 export declare function notificationTaskSubTaskMissingRequiredDataTermination(): NotificationTaskSubTaskMissingRequiredDataTermination;

package/model/src/lib/notification/notification.util.d.ts

@@ -7,8 +7,8 @@ import { type E164PhoneNumber, type EmailAddress, type Maybe, type PhoneNumber,
  * Sets the creation timestamp to now, associates the summary with the given model key,
  * and initializes with an empty notifications array.
  *
- * @param model - the model key to associate the summary with
- * @returns a blank {@link NotificationSummary} with creation timestamp and empty notifications
+ * @param model - The model key to associate the summary with.
+ * @returns A blank {@link NotificationSummary} with creation timestamp and empty notifications.
  *
  * @example
  * ```ts
@@ -143,8 +143,8 @@ export interface ExpandNotificationRecipientsResult {
  *
  * Recipients are each configurable and may be defined with as little info as a single contact info, or have multiple contact info pieces associated with them.
  *
- * @param input - the notification, box, auth service, and recipient configuration
- * @returns channel-specific recipient lists (email, text, notification summary) ready for delivery
+ * @param input - The notification, box, auth service, and recipient configuration.
+ * @returns Channel-specific recipient lists (email, text, notification summary) ready for delivery.
  */
 export declare function expandNotificationRecipients(input: ExpandNotificationRecipientsInput): Promise<ExpandNotificationRecipientsResult>;
 /**
@@ -199,9 +199,9 @@ export interface UpdateNotificationUserNotificationBoxRecipientConfigResult {
  *
  * Also re-applies send exclusions to the updated config array.
  *
- * @param input - the current state and intended change
- * @returns the updated box config array and notification box recipient, if changes occurred
- * @throws notificationUserBlockedFromBeingAddedToRecipientsError when inserting a blocked user
- * @throws notificationUserLockedConfigFromBeingUpdatedError when updating a locked user's config
+ * @param input - The current state and intended change.
+ * @returns The updated box config array and notification box recipient, if changes occurred.
+ * @throws {Error} NotificationUserBlockedFromBeingAddedToRecipientsError when inserting a blocked user.
+ * @throws {Error} NotificationUserLockedConfigFromBeingUpdatedError when updating a locked user's config.
  */
 export declare function updateNotificationUserNotificationBoxRecipientConfig(input: UpdateNotificationUserNotificationBoxRecipientConfigInput): UpdateNotificationUserNotificationBoxRecipientConfigResult;

package/model/src/lib/storagefile/storagefile.action.server.d.ts

@@ -65,10 +65,9 @@ export declare abstract class StorageFileServerActions {
  * Creates a concrete {@link StorageFileServerActions} implementation by wiring each action
  * to its factory function using the provided context.
  *
- * @param context - the fully assembled storage file server actions context
- *
- * @param context - the fully assembled storage file server actions context
- * @returns a concrete {@link StorageFileServerActions} with all action methods wired to their factories
+ * @param context - The fully assembled storage file server actions context.
+ * @param context - The fully assembled storage file server actions context.
+ * @returns A concrete {@link StorageFileServerActions} with all action methods wired to their factories.
  *
  * @example
  * ```ts
@@ -83,8 +82,8 @@ export declare function storageFileServerActions(context: StorageFileServerActio
  *
  * Creates a new {@link StorageFile} document using the provided template data.
  *
- * @param context - the base server actions context providing Firestore and storage access
- * @returns an async transform-and-validate function that creates a StorageFile document
+ * @param context - The base server actions context providing Firestore and storage access.
+ * @returns An async transform-and-validate function that creates a StorageFile document.
  */
 export declare function createStorageFileFactory(context: BaseStorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<CreateStorageFileParams, () => Promise<StorageFileDocument>, object, unknown>;
 /**
@@ -94,8 +93,8 @@ export declare function createStorageFileFactory(context: BaseStorageFileServerA
  * initializes each one via the upload service, and cleans up the source upload
  * on success. Failed initializations are logged but do not halt the batch.
  *
- * @param context - the storage file server actions context with storage service and upload initialization
- * @returns an async transform-and-validate function that returns batch initialization results
+ * @param context - The storage file server actions context with storage service and upload initialization.
+ * @returns An async transform-and-validate function that returns batch initialization results.
  */
 export declare function initializeAllStorageFilesFromUploadsFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<InitializeAllStorageFilesFromUploadsParams, () => Promise<InitializeAllStorageFilesFromUploadsResult>, object, unknown>;
 export interface InitializeStorageFileFromUploadFileInput {
@@ -113,8 +112,8 @@ export interface InitializeStorageFileFromUploadFileInput {
  * Validates the file exists and is allowed, runs the upload initializer, deletes the upload source
  * on success, and optionally expedites processing of the created storage file.
  *
- * @param context - the storage file server actions context
- * @returns an async function that accepts an upload file input and returns the created StorageFileDocument
+ * @param context - The storage file server actions context.
+ * @returns An async function that accepts an upload file input and returns the created StorageFileDocument.
  */
 export declare function _initializeStorageFileFromUploadFileFactory(context: StorageFileServerActionsContext): (input: InitializeStorageFileFromUploadFileInput) => Promise<StorageFileDocument>;
 /**
@@ -124,8 +123,8 @@ export declare function _initializeStorageFileFromUploadFileFactory(context: Sto
  * Validates the file exists and is allowed, runs the type determiner and initializer,
  * then cleans up the upload source on success.
  *
- * @param context - the storage file server actions context with storage and upload services
- * @returns an async transform-and-validate function that creates a StorageFile from an upload
+ * @param context - The storage file server actions context with storage and upload services.
+ * @returns An async transform-and-validate function that creates a StorageFile from an upload.
  */
 export declare function initializeStorageFileFromUploadFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<InitializeStorageFileFromUploadParams, () => Promise<StorageFileDocument>, object, unknown>;
 /**
@@ -133,8 +132,8 @@ export declare function initializeStorageFileFromUploadFactory(context: StorageF
  *
  * Updates an existing {@link StorageFile} document with the provided schedule-delete-at time.
  *
- * @param context - the base server actions context providing Firestore access
- * @returns an async transform-and-validate function that updates a StorageFile document
+ * @param context - The base server actions context providing Firestore access.
+ * @returns An async transform-and-validate function that updates a StorageFile document.
  */
 export declare function updateStorageFileFactory(context: BaseStorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<UpdateStorageFileParams, (storageFileDocument: StorageFileDocument) => Promise<StorageFileDocument>, object, unknown>;
 /**
@@ -143,8 +142,8 @@ export declare function updateStorageFileFactory(context: BaseStorageFileServerA
  * Updates embedded file entries within a {@link StorageFileGroup} document inside a
  * Firestore transaction, merging display name changes into the existing entries.
  *
- * @param context - the storage file server actions context
- * @returns an async transform-and-validate function that updates a StorageFileGroup document
+ * @param context - The storage file server actions context.
+ * @returns An async transform-and-validate function that updates a StorageFileGroup document.
  */
 export declare function updateStorageFileGroupFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<UpdateStorageFileGroupParams, (storageFileGroupDocument: StorageFileGroupDocument) => Promise<StorageFileGroupDocument>, object, unknown>;
 /**
@@ -154,8 +153,8 @@ export declare function updateStorageFileGroupFactory(context: StorageFileServer
  * processing notification task for each file and optionally expedites delivery.
  * Handles stuck-processing detection with a throttle check.
  *
- * @param context - the storage file server actions context
- * @returns an async transform-and-validate function that returns batch processing results
+ * @param context - The storage file server actions context.
+ * @returns An async transform-and-validate function that returns batch processing results.
  */
 export declare function processAllQueuedStorageFilesFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<ProcessAllQueuedStorageFilesParams, () => Promise<ProcessAllQueuedStorageFilesResult>, object, unknown>;
 export interface ProcessStorageFileInTransactionInput {
@@ -182,8 +181,8 @@ export interface ProcessStorageFileInTransactionInput {
  * Creates or restarts a notification task for the file based on its current processing state,
  * handling stuck-processing detection, forced restarts, and re-processing of already-successful files.
  *
- * @param context - the storage file server actions context
- * @returns an async function that processes a storage file within a transaction
+ * @param context - The storage file server actions context.
+ * @returns An async function that processes a storage file within a transaction.
  */
 export declare function _processStorageFileInTransactionFactory(context: StorageFileServerActionsContext): (input: ProcessStorageFileInTransactionInput, transaction: Transaction) => Promise<void>;
 /**
@@ -192,8 +191,8 @@ export declare function _processStorageFileInTransactionFactory(context: Storage
  * Processes a single {@link StorageFile} by creating a notification task for it
  * and marking it as processing. Validates the file is in a valid state for processing.
  *
- * @param context - the storage file server actions context
- * @returns an async transform-and-validate function that processes a single StorageFile
+ * @param context - The storage file server actions context.
+ * @returns An async transform-and-validate function that processes a single StorageFile.
  */
 export declare function processStorageFileFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<ProcessStorageFileParams, (storageFileDocument: StorageFileDocument) => Promise<ProcessStorageFileResult>, object, unknown>;
 /**
@@ -203,8 +202,8 @@ export declare function processStorageFileFactory(context: StorageFileServerActi
  * scheduled delete time has passed. Removes both the Firestore document and
  * the associated file in Cloud Storage.
  *
- * @param context - the storage file server actions context
- * @returns an async transform-and-validate function that returns batch deletion results
+ * @param context - The storage file server actions context.
+ * @returns An async transform-and-validate function that returns batch deletion results.
  */
 export declare function deleteAllQueuedStorageFilesFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<DeleteAllQueuedStorageFilesParams, () => Promise<DeleteAllQueuedStorageFilesResult>, object, unknown>;
 /**
@@ -213,8 +212,8 @@ export declare function deleteAllQueuedStorageFilesFactory(context: StorageFileS
  * Deletes a single {@link StorageFile} document and its associated Cloud Storage file.
  * Validates the file is flagged for deletion and the scheduled delete time has passed.
  *
- * @param context - the storage file server actions context
- * @returns an async transform-and-validate function that deletes a StorageFile and its storage object
+ * @param context - The storage file server actions context.
+ * @returns An async transform-and-validate function that deletes a StorageFile and its storage object.
  */
 export declare function deleteStorageFileFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<DeleteStorageFileParams, (inputStorageFileDocument: StorageFileDocument) => Promise<void>, object, unknown>;
 /**
@@ -267,8 +266,8 @@ export declare const DEFAULT_DOWNLOAD_MULTIPLE_STORAGE_FILES_MAX_PARALLEL_TASKS
  * Generates a signed download URL for a {@link StorageFile}'s associated Cloud Storage file.
  * Delegates to {@link _downloadMultipleStorageFilesFactory} with a single item and `throwOnFirstError: true`.
  *
- * @param context - the storage file server actions context
- * @returns an async transform-and-validate function that generates a signed download URL
+ * @param context - The storage file server actions context.
+ * @returns An async transform-and-validate function that generates a signed download URL.
  */
 export declare function downloadStorageFileFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<DownloadStorageFileParams, (storageFileDocument?: Maybe<StorageFileDocument>) => Promise<DownloadMultipleStorageFileSuccessItem>, object, unknown>;
 /**
@@ -278,8 +277,8 @@ export declare function downloadStorageFileFactory(context: StorageFileServerAct
  * By default, individual failures are collected in the errors array rather than failing the entire batch.
  * Set `throwOnFirstError` in params to throw on the first failure instead.
  *
- * @param context - the storage file server actions context
- * @returns an async transform-and-validate function that generates signed download URLs for multiple files
+ * @param context - The storage file server actions context.
+ * @returns An async transform-and-validate function that generates signed download URLs for multiple files.
  */
 export declare function downloadMultipleStorageFilesFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<DownloadMultipleStorageFilesParams, (storageFileDocuments?: Maybe<StorageFileDocument[]>) => Promise<DownloadMultipleStorageFilesResult>, object, unknown>;
 /**
@@ -308,8 +307,8 @@ export interface CreateStorageFileGroupInTransactionInput extends StorageFileGro
  * The created group is flagged for initialization (`s=true`) and uses a dummy owner key
  * that will be set during the initialization step.
  *
- * @param context - the storage file server actions context
- * @returns an async function that creates a StorageFileGroup within a transaction
+ * @param context - The storage file server actions context.
+ * @returns An async function that creates a StorageFileGroup within a transaction.
  */
 export declare function createStorageFileGroupInTransactionFactory(context: StorageFileServerActionsContext): (params: CreateStorageFileGroupInTransactionInput, transaction: Transaction) => Promise<{
     storageFileGroupTemplate: StorageFileGroup;
@@ -321,8 +320,8 @@ export declare function createStorageFileGroupInTransactionFactory(context: Stor
  * Creates a new {@link StorageFileGroup} document within a Firestore transaction,
  * associating it with a model key or storage file.
  *
- * @param context - the storage file server actions context
- * @returns an async transform-and-validate function that creates a new StorageFileGroup
+ * @param context - The storage file server actions context.
+ * @returns An async transform-and-validate function that creates a new StorageFileGroup.
  */
 export declare function createStorageFileGroupFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<CreateStorageFileGroupParams, () => Promise<StorageFileGroupDocument>, object, unknown>;
 export interface SyncStorageFileWithGroupsInTransactionInput {
@@ -353,8 +352,8 @@ export interface SyncStorageFileWithGroupsInTransactionInput {
  * Adds the storage file to groups it is missing from, removes it from groups when requested,
  * and optionally creates new groups for references that do not yet exist.
  *
- * @param context - the storage file server actions context
- * @returns an async function that syncs a storage file with its groups within a transaction
+ * @param context - The storage file server actions context.
+ * @returns An async function that syncs a storage file with its groups within a transaction.
  */
 export declare function _syncStorageFileWithGroupsInTransactionFactory(context: StorageFileServerActionsContext): (input: SyncStorageFileWithGroupsInTransactionInput, transaction: Transaction) => Promise<SyncStorageFileWithGroupsResult>;
 /**
@@ -363,8 +362,8 @@ export declare function _syncStorageFileWithGroupsInTransactionFactory(context:
  * Syncs a single {@link StorageFile}'s embedded data into its associated {@link StorageFileGroup}
  * documents and clears the sync flag on completion.
  *
- * @param context - the storage file server actions context
- * @returns an async transform-and-validate function that syncs a StorageFile with its groups
+ * @param context - The storage file server actions context.
+ * @returns An async transform-and-validate function that syncs a StorageFile with its groups.
  */
 export declare function syncStorageFileWithGroupsFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<SyncStorageFileWithGroupsParams, (storageFileDocument: StorageFileDocument) => Promise<SyncStorageFileWithGroupsResult>, object, unknown>;
 /**
@@ -374,8 +373,8 @@ export declare function syncStorageFileWithGroupsFactory(context: StorageFileSer
  * updating their associated {@link StorageFileGroup} documents and flagging
  * groups for content regeneration when changes occur.
  *
- * @param context - the storage file server actions context
- * @returns an async transform-and-validate function that returns batch sync results
+ * @param context - The storage file server actions context.
+ * @returns An async transform-and-validate function that returns batch sync results.
  */
 export declare function syncAllFlaggedStorageFilesWithGroupsFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<SyncAllFlaggedStorageFilesWithGroupsParams, () => Promise<SyncAllFlaggedStorageFilesWithGroupsResult>, object, unknown>;
 /**
@@ -384,8 +383,8 @@ export declare function syncAllFlaggedStorageFilesWithGroupsFactory(context: Sto
  * Regenerates the content of a single {@link StorageFileGroup}, including building a ZIP
  * archive from the group's embedded files and updating the group's content metadata.
  *
- * @param context - the storage file server actions context
- * @returns an async transform-and-validate function that regenerates a StorageFileGroup's content
+ * @param context - The storage file server actions context.
+ * @returns An async transform-and-validate function that regenerates a StorageFileGroup's content.
  */
 export declare function regenerateStorageFileGroupContentFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<RegenerateStorageFileGroupContentParams, (storageFileGroupDocument: StorageFileGroupDocument) => Promise<RegenerateStorageFileGroupContentResult>, object, unknown>;
 /**
@@ -394,7 +393,7 @@ export declare function regenerateStorageFileGroupContentFactory(context: Storag
  * Batch-processes all {@link StorageFileGroup} documents flagged for content regeneration,
  * rebuilding their ZIP archives and updating content metadata.
  *
- * @param context - the storage file server actions context
- * @returns an async transform-and-validate function that returns batch regeneration results
+ * @param context - The storage file server actions context.
+ * @returns An async transform-and-validate function that returns batch regeneration results.
  */
 export declare function regenerateAllFlaggedStorageFileGroupsContentFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<RegenerateAllFlaggedStorageFileGroupsContentParams, () => Promise<RegenerateAllFlaggedStorageFileGroupsContentResult>, object, unknown>;

package/model/src/lib/storagefile/storagefile.action.server.init.d.ts

@@ -67,8 +67,8 @@ export declare abstract class StorageFileInitServerActions {
  * Creates a concrete {@link StorageFileInitServerActions} implementation by wiring each
  * initialization action to its factory function.
  *
- * @param context - the initialization context with template function and Firestore access
- * @returns a {@link StorageFileInitServerActions} wired to the provided context
+ * @param context - The initialization context with template function and Firestore access.
+ * @returns A {@link StorageFileInitServerActions} wired to the provided context.
  */
 export declare function storageFileInitServerActions(context: StorageFileInitServerActionsContext): StorageFileInitServerActions;
 /**
@@ -90,9 +90,9 @@ export interface InitializeStorageFileModelInTransactionInput<D extends Firestor
  * - Returns `null`/`undefined` → marks the model as invalid (`fi=true`)
  * - Returns `false` → deletes the document entirely
  *
- * @param input - the document, transaction, template function, and options
- * @returns an object indicating whether the document was initialized or was already initialized
- * @throws storageFileModelAlreadyInitializedError when `throwErrorIfAlreadyInitialized` is true
+ * @param input - The document, transaction, template function, and options.
+ * @returns An object indicating whether the document was initialized or was already initialized.
+ * @throws {Error} StorageFileModelAlreadyInitializedError when `throwErrorIfAlreadyInitialized` is true.
  */
 export declare function initializeStorageFileModelInTransaction<D extends FirestoreDocument<InitializedStorageFileModel>>(input: InitializeStorageFileModelInTransactionInput<D>): Promise<{
     initialized: boolean;
@@ -104,8 +104,8 @@ export declare function initializeStorageFileModelInTransaction<D extends Firest
  * Applies the app-specific template function, restricting the template to only the `o` (owner)
  * and content flag properties, and always flags the group for content regeneration.
  *
- * @param context - the initialization context providing collection access and the template function
- * @returns an async function that initializes a storage file group document within a transaction
+ * @param context - The initialization context providing collection access and the template function.
+ * @returns An async function that initializes a storage file group document within a transaction.
  */
 export declare function initializeStorageFileGroupInTransactionFactory(context: StorageFileInitServerActionsContext): (params: InitializeStorageFileModelParams, storageFileGroupDocument: StorageFileGroupDocument, transaction: Transaction) => Promise<{
     initialized: boolean;
@@ -117,8 +117,8 @@ export declare function initializeStorageFileGroupInTransactionFactory(context:
  * Wraps the in-transaction group initialization in a Firestore transaction
  * and follows the transform-and-validate pattern.
  *
- * @param context - the initialization context with Firestore access and template function
- * @returns a transform-and-validate function for single storage file group initialization
+ * @param context - The initialization context with Firestore access and template function.
+ * @returns A transform-and-validate function for single storage file group initialization.
  */
 export declare function initializeStorageFileGroupFactory(context: StorageFileInitServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<InitializeStorageFileModelParams, (storageFileGroupDocument: StorageFileGroupDocument) => Promise<StorageFileGroupDocument>, object, unknown>;
 /**
@@ -128,7 +128,7 @@ export declare function initializeStorageFileGroupFactory(context: StorageFileIn
  * initializing each in parallel (up to 5 concurrent tasks). Loops until no more
  * flagged groups are found.
  *
- * @param context - the initialization context with Firestore access, collection, and template function
- * @returns a transform-and-validate function for batch storage file group initialization
+ * @param context - The initialization context with Firestore access, collection, and template function.
+ * @returns A transform-and-validate function for batch storage file group initialization.
  */
 export declare function initializeAllApplicableStorageFileGroupsFactory(context: StorageFileInitServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<InitializeAllApplicableStorageFileGroupsParams, () => Promise<InitializeAllApplicableStorageFileGroupsResult>, object, unknown>;

package/model/src/lib/storagefile/storagefile.error.d.ts

@@ -2,85 +2,85 @@ import { type UploadedFileInitializationFailedErrorData } from '@dereekb/firebas
 /**
  * Creates an error indicating that a storage file model has already been initialized.
  *
- * @returns a precondition-conflict HttpsError with the STORAGE_FILE_MODEL_ALREADY_INITIALIZED error code
+ * @returns A precondition-conflict HttpsError with the STORAGE_FILE_MODEL_ALREADY_INITIALIZED error code.
  */
 export declare function storageFileModelAlreadyInitializedError(): import("firebase-functions/https").HttpsError;
 /**
  * Creates an error indicating that the StorageFile is not flagged for group sync.
  *
- * @returns a precondition-conflict HttpsError with the STORAGE_FILE_NOT_FLAGGED_FOR_GROUPS_SYNC error code
+ * @returns A precondition-conflict HttpsError with the STORAGE_FILE_NOT_FLAGGED_FOR_GROUPS_SYNC error code.
  */
 export declare function storageFileNotFlaggedForGroupsSyncError(): import("firebase-functions/https").HttpsError;
 /**
  * Creates an error indicating that the target uploaded file does not exist in storage.
  *
- * @returns a precondition-conflict HttpsError with the UPLOADED_FILE_DOES_NOT_EXIST error code
+ * @returns A precondition-conflict HttpsError with the UPLOADED_FILE_DOES_NOT_EXIST error code.
  */
 export declare function uploadedFileDoesNotExistError(): import("firebase-functions/https").HttpsError;
 /**
  * Creates an error indicating that the file is not allowed to be initialized (rejected by the check function).
  *
- * @returns a precondition-conflict HttpsError with the UPLOADED_FILE_NOT_ALLOWED_TO_BE_INITIALIZED error code
+ * @returns A precondition-conflict HttpsError with the UPLOADED_FILE_NOT_ALLOWED_TO_BE_INITIALIZED error code.
  */
 export declare function uploadedFileIsNotAllowedToBeInitializedError(): import("firebase-functions/https").HttpsError;
 /**
  * Creates an error indicating that the file initialization failed with the given result type.
  *
- * @param data - error data containing the result type that caused the failure
- * @returns an internal-server HttpsError with the UPLOADED_FILE_INITIALIZATION_FAILED error code and the result type
+ * @param data - Error data containing the result type that caused the failure.
+ * @returns An internal-server HttpsError with the UPLOADED_FILE_INITIALIZATION_FAILED error code and the result type.
  */
 export declare function uploadedFileInitializationFailedError(data: UploadedFileInitializationFailedErrorData): import("firebase-functions/https").HttpsError;
 /**
  * Creates an error indicating that the initialization result was discarded (e.g., the created file no longer exists).
  *
- * @returns an internal-server HttpsError with the UPLOADED_FILE_INITIALIZATION_DISCARDED error code
+ * @returns An internal-server HttpsError with the UPLOADED_FILE_INITIALIZATION_DISCARDED error code.
  */
 export declare function uploadedFileInitializationDiscardedError(): import("firebase-functions/https").HttpsError;
 /**
  * Creates an error indicating that the StorageFile is not in a valid state for processing.
  *
- * @returns a precondition-conflict HttpsError with the STORAGE_FILE_PROCESSING_NOT_ALLOWED_FOR_INVALID_STATE error code
+ * @returns A precondition-conflict HttpsError with the STORAGE_FILE_PROCESSING_NOT_ALLOWED_FOR_INVALID_STATE error code.
  */
 export declare function storageFileProcessingNotAllowedForInvalidStateError(): import("firebase-functions/https").HttpsError;
 /**
  * Creates an error indicating that the StorageFile is not queued for processing.
  *
- * @returns a precondition-conflict HttpsError with the STORAGE_FILE_PROCESSING_NOT_QUEUED_FOR_PROCESSING error code
+ * @returns A precondition-conflict HttpsError with the STORAGE_FILE_PROCESSING_NOT_QUEUED_FOR_PROCESSING error code.
  */
 export declare function storageFileProcessingNotQueuedForProcessingError(): import("firebase-functions/https").HttpsError;
 /**
  * Creates an error indicating that no processor is configured for the StorageFile's type.
  *
- * @returns a precondition-conflict HttpsError with the STORAGE_FILE_PROCESSING_NOT_AVAILABLE_FOR_TYPE error code
+ * @returns A precondition-conflict HttpsError with the STORAGE_FILE_PROCESSING_NOT_AVAILABLE_FOR_TYPE error code.
  */
 export declare function storageFileProcessingNotAvailableForTypeError(): import("firebase-functions/https").HttpsError;
 /**
  * Creates an error indicating that the StorageFile has already finished processing.
  *
- * @returns a precondition-conflict HttpsError with the STORAGE_FILE_ALREADY_PROCESSED error code
+ * @returns A precondition-conflict HttpsError with the STORAGE_FILE_ALREADY_PROCESSED error code.
  */
 export declare function storageFileAlreadyProcessedError(): import("firebase-functions/https").HttpsError;
 /**
  * Creates an error indicating that the StorageFile is not flagged for deletion.
  *
- * @returns a precondition-conflict HttpsError with the STORAGE_FILE_NOT_FLAGGED_FOR_DELETION error code
+ * @returns A precondition-conflict HttpsError with the STORAGE_FILE_NOT_FLAGGED_FOR_DELETION error code.
  */
 export declare function storageFileNotFlaggedForDeletionError(): import("firebase-functions/https").HttpsError;
 /**
  * Creates an error indicating that the StorageFile's scheduled deletion time has not yet passed.
  *
- * @returns a precondition-conflict HttpsError with the STORAGE_FILE_CANNOT_BE_DELETED_YET error code
+ * @returns A precondition-conflict HttpsError with the STORAGE_FILE_CANNOT_BE_DELETED_YET error code.
  */
 export declare function storageFileCannotBeDeletedYetError(): import("firebase-functions/https").HttpsError;
 /**
  * Creates an error indicating that the StorageFileGroup is still queued for initialization and cannot be operated on.
  *
- * @returns a precondition-conflict HttpsError with the STORAGE_FILE_GROUP_QUEUED_FOR_INITIALIZATION error code
+ * @returns A precondition-conflict HttpsError with the STORAGE_FILE_GROUP_QUEUED_FOR_INITIALIZATION error code.
  */
 export declare function storageFileGroupQueuedForInitializationError(): import("firebase-functions/https").HttpsError;
 /**
  * Creates an error indicating that the required model key or storageFileId is missing when creating a StorageFileGroup.
  *
- * @returns a precondition-conflict HttpsError with the STORAGE_FILE_GROUP_CREATE_INPUT error code
+ * @returns A precondition-conflict HttpsError with the STORAGE_FILE_GROUP_CREATE_INPUT error code.
  */
 export declare function createStorageFileGroupInputError(): import("firebase-functions/https").HttpsError;

package/model/src/lib/storagefile/storagefile.module.d.ts

@@ -7,25 +7,25 @@ import { StorageFileInitServerActions, type StorageFileInitServerActionsContextC
  * Factory that assembles the full {@link StorageFileServerActionsContext} by combining
  * the base context with the upload initialization service.
  *
- * @param context - the base server actions context providing Firebase infrastructure
- * @param storageFileInitializeFromUploadService - the service for initializing storage files from uploads
- * @returns the fully assembled StorageFileServerActionsContext
+ * @param context - The base server actions context providing Firebase infrastructure.
+ * @param storageFileInitializeFromUploadService - The service for initializing storage files from uploads.
+ * @returns The fully assembled StorageFileServerActionsContext.
  */
 export declare function storageFileServerActionsContextFactory(context: BaseStorageFileServerActionsContext, storageFileInitializeFromUploadService: StorageFileInitializeFromUploadService): StorageFileServerActionsContext;
 /**
  * Factory that creates a {@link StorageFileServerActions} instance from the assembled context.
  *
- * @param context - the fully assembled storage file server actions context
- * @returns a concrete StorageFileServerActions instance
+ * @param context - The fully assembled storage file server actions context.
+ * @returns A concrete StorageFileServerActions instance.
  */
 export declare function storageFileServerActionsFactory(context: StorageFileServerActionsContext): StorageFileServerActions;
 /**
  * Factory that creates a {@link StorageFileInitServerActions} instance by merging the
  * server actions context with the init-specific configuration.
  *
- * @param context - the storage file server actions context
- * @param storageFileInitServerActionsContextConfig - init-specific configuration with the template function
- * @returns a concrete StorageFileInitServerActions instance
+ * @param context - The storage file server actions context.
+ * @param storageFileInitServerActionsContextConfig - Init-specific configuration with the template function.
+ * @returns A concrete StorageFileInitServerActions instance.
  */
 export declare function storageFileInitServerActionsFactory(context: StorageFileServerActionsContext, storageFileInitServerActionsContextConfig: StorageFileInitServerActionsContextConfig): StorageFileInitServerActions;
 export interface ProvideAppStorageFileMetadataConfig extends Pick<ModuleMetadata, 'imports' | 'exports' | 'providers'> {
@@ -49,7 +49,7 @@ export interface ProvideAppStorageFileMetadataConfig extends Pick<ModuleMetadata
  *
  * Be sure the class that delares the module using this function also extends AbstractAppStorageFileModule.
  *
- * @param config - the module configuration including optional dependency module, imports, exports, and providers
- * @returns the assembled {@link ModuleMetadata} for the storage file module
+ * @param config - The module configuration including optional dependency module, imports, exports, and providers.
+ * @returns The assembled {@link ModuleMetadata} for the storage file module.
  */
 export declare function appStorageFileModuleMetadata(config: ProvideAppStorageFileMetadataConfig): ModuleMetadata;

package/model/src/lib/storagefile/storagefile.task.service.handler.d.ts

@@ -98,8 +98,8 @@ export declare const storageFileProcessingNotificationTaskHandlerDefaultCleanup:
  * determines its purpose, and dispatches to the appropriate purpose-specific processor.
  * Includes optional StorageFileGroup processors (e.g., ZIP generation) by default.
  *
- * @param config - handler configuration including processors, storage accessor, and Firestore collections
- * @returns a NotificationTaskServiceTaskHandlerConfig wired for storage file processing
+ * @param config - Handler configuration including processors, storage accessor, and Firestore collections.
+ * @returns A NotificationTaskServiceTaskHandlerConfig wired for storage file processing.
  */
 export declare function storageFileProcessingNotificationTaskHandler(config: StorageFileProcessingNotificationTaskHandlerConfig): NotificationTaskServiceTaskHandlerConfig<StorageFileProcessingNotificationTaskData>;
 export interface AllStorageFileGroupStorageFileProcessingPurposeSubtaskProcessorsConfig extends StorageFileGroupStorageFileProcessingPurposeSubtaskProcessorsConfig {
@@ -113,8 +113,8 @@ export interface AllStorageFileGroupStorageFileProcessingPurposeSubtaskProcessor
 /**
  * Assembles all built-in StorageFileGroup subtask processors, such as ZIP generation.
  *
- * @param config - configuration controlling which group processors to include
- * @returns an array of subtask processor configs for StorageFileGroup processing purposes
+ * @param config - Configuration controlling which group processors to include.
+ * @returns The subtask processor configs for StorageFileGroup processing purposes.
  */
 export declare function allStorageFileGroupStorageFileProcessingPurposeSubtaskProcessors(config: AllStorageFileGroupStorageFileProcessingPurposeSubtaskProcessorsConfig): StorageFileProcessingPurposeSubtaskProcessorConfigWithTarget[];
 export interface StorageFileGroupStorageFileProcessingPurposeSubtaskProcessorsConfig {
@@ -186,7 +186,7 @@ export interface StorageFileGroupStorageFileProcessingPurposeSubtaskProcessorsCo
  * This processor streams all files in the group into a ZIP archive, attaches an info JSON
  * manifest, and uploads the result to the group's designated storage path.
  *
- * @param config - configuration providing Firestore collections, storage accessor, and ZIP options
- * @returns a subtask processor config targeting the StorageFileGroup ZIP purpose
+ * @param config - Configuration providing Firestore collections, storage accessor, and ZIP options.
+ * @returns A subtask processor config targeting the StorageFileGroup ZIP purpose.
  */
 export declare function storageFileGroupZipStorageFileProcessingPurposeSubtaskProcessor(config: StorageFileGroupStorageFileProcessingPurposeSubtaskProcessorsConfig): StorageFileProcessingPurposeSubtaskProcessorConfigWithTarget<StorageFileGroupZipStorageFileProcessingSubtaskMetadata, StorageFileGroupZipStorageFileProcessingSubtask>;

package/model/src/lib/storagefile/storagefile.upload.service.initializer.d.ts

@@ -69,9 +69,9 @@ export interface StorageFileInitializeFromUploadServiceInitializerStorageFileDoc
  * Convenience factory for creating a permanent failure result, indicating the file
  * should be discarded and any created intermediate files cleaned up.
  *
- * @param error - the error that caused the permanent failure
- * @param createdFile - optional path to a file that was created before the error and should be deleted
- * @returns a permanent failure result with the error and optional created file reference
+ * @param error - The error that caused the permanent failure.
+ * @param createdFile - Optional path to a file that was created before the error and should be deleted.
+ * @returns A permanent failure result with the error and optional created file reference.
  */
 export declare function storageFileInitializeFromUploadServiceInitializerResultPermanentFailure(error: unknown, createdFile?: Maybe<StoragePathRef>): StorageFileInitializeFromUploadServiceInitializerResult;
 /**
@@ -145,8 +145,8 @@ export interface StorageFileInitializeFromUploadServiceConfig {
  * 3. The created file is linked back to the StorageFile document via custom metadata
  * 4. Optionally, previous files for the same purpose/user are flagged for deletion
  *
- * @param config - service configuration including determiners, initializers, and storage references
- * @returns a {@link StorageFileInitializeFromUploadService} with type detection and upload initialization
+ * @param config - Service configuration including determiners, initializers, and storage references.
+ * @returns A {@link StorageFileInitializeFromUploadService} with type detection and upload initialization.
  *
  * @example
  * ```ts

package/model/src/lib/storagefile/storagefile.util.d.ts

@@ -32,14 +32,14 @@ export interface QueryAndFlagStorageFilesForDeleteResult {
 /**
  * Performs a query and flags the matching StorageFiles for deletion.
  *
- * @param input The input for the query and flagging.
+ * @param input - The input for the query and flagging.
  * @returns The result of the query and flagging.
  */
 export declare function queryAndFlagStorageFilesForDelete(input: QueryAndFlagStorageFilesForDeleteInput): Promise<QueryAndFlagStorageFilesForDeleteResult>;
 /**
  * Creates a template for updating a StorageFile to be queued for deletion at the input time.
  *
- * @param queueForDeleteTime When to delete the StorageFile. If true or unset, the StorageFile will be flagged to be deleted immediately.
+ * @param queueForDeleteTime - When to delete the StorageFile. If true or unset, the StorageFile will be flagged to be deleted immediately.
  * @returns The update template for the StorageFile.
  */
 export declare function markStorageFileForDeleteTemplate(queueForDeleteTime?: Maybe<StorageFileQueueForDeleteTime>): Pick<StorageFile, 'sdat' | 'fs'>;