@dereekb/firebase-server 13.2.1 → 13.3.0

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

@@ -6,17 +6,43 @@ import { type NotificationExpediteServiceInstance, type NotificationExpediteServ
 import { type StorageFileInitializeFromUploadServiceRef } from './storagefile.upload.service';
 import { type Maybe } from '@dereekb/util';
 /**
- * Injection token for the BaseStorageFileServerActionsContext
+ * NestJS injection token for the {@link BaseStorageFileServerActionsContext}, providing
+ * Firebase infrastructure, storage service, notification collections, and Firestore collections
+ * needed by storage file actions.
  */
 export declare const BASE_STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN: InjectionToken;
 /**
- * Injection token for the StorageFileServerActionsContext
+ * NestJS injection token for the fully assembled {@link StorageFileServerActionsContext},
+ * which adds the upload initialization service on top of the base context.
  */
 export declare const STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN: InjectionToken;
+/**
+ * Minimal context providing Firebase infrastructure, storage, notification, and Firestore
+ * collections needed by all storage file server actions.
+ */
 export interface BaseStorageFileServerActionsContext extends FirebaseServerActionsContext, NotificationFirestoreCollections, NotificationExpediteServiceRef, StorageFileFirestoreCollections, FirebaseServerAuthServiceRef, FirebaseServerStorageServiceRef, FirestoreContextReference {
 }
+/**
+ * Full context for storage file server actions, extending the base with the
+ * upload initialization service.
+ */
 export interface StorageFileServerActionsContext extends BaseStorageFileServerActionsContext, StorageFileInitializeFromUploadServiceRef {
 }
+/**
+ * Abstract service class defining all server-side storage file CRUD, upload processing, and group management actions.
+ *
+ * This is the central API surface for the storage file system's backend. It provides:
+ *
+ * - **File management**: create, update, delete, and download {@link StorageFile} documents
+ * - **Upload pipeline**: initialize storage files from uploaded files, with type detection and processing
+ * - **Batch processing**: process all queued files, delete all flagged files
+ * - **Group management**: create/update {@link StorageFileGroup} documents, sync files with groups,
+ *   and regenerate group content (e.g., ZIP archives)
+ *
+ * Each method follows the transform-and-validate pattern used throughout the notification/storage system.
+ *
+ * @see {@link storageFileServerActions} for the concrete implementation factory.
+ */
 export declare abstract class StorageFileServerActions {
     abstract createStorageFile(params: CreateStorageFileParams): AsyncStorageFileCreateAction<CreateStorageFileParams>;
     abstract initializeAllStorageFilesFromUploads(params: InitializeAllStorageFilesFromUploadsParams): Promise<TransformAndValidateFunctionResult<InitializeAllStorageFilesFromUploadsParams, () => Promise<InitializeAllStorageFilesFromUploadsResult>>>;
@@ -34,8 +60,33 @@ export declare abstract class StorageFileServerActions {
     abstract regenerateStorageFileGroupContent(params: RegenerateStorageFileGroupContentParams): Promise<TransformAndValidateFunctionResult<RegenerateStorageFileGroupContentParams, (storageFileGroupDocument: StorageFileGroupDocument) => Promise<RegenerateStorageFileGroupContentResult>>>;
     abstract regenerateAllFlaggedStorageFileGroupsContent(params: RegenerateAllFlaggedStorageFileGroupsContentParams): Promise<TransformAndValidateFunctionResult<RegenerateAllFlaggedStorageFileGroupsContentParams, () => Promise<RegenerateAllFlaggedStorageFileGroupsContentResult>>>;
 }
+/**
+ * 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
+ *
+ * @example
+ * ```ts
+ * const actions = storageFileServerActions(context);
+ * const initFn = await actions.initializeStorageFileFromUpload({ key, storagePath });
+ * const storageFileDoc = await initFn();
+ * ```
+ */
 export declare function storageFileServerActions(context: StorageFileServerActionsContext): StorageFileServerActions;
+/**
+ * Factory for the `createStorageFile` action.
+ *
+ * Creates a new {@link StorageFile} document using the provided template data.
+ */
 export declare function createStorageFileFactory(context: BaseStorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<CreateStorageFileParams, () => Promise<any>, object, unknown>;
+/**
+ * Factory for the `initializeAllStorageFilesFromUploads` action.
+ *
+ * Scans the uploads folder in Firebase Storage, identifies new uploaded files,
+ * 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.
+ */
 export declare function initializeAllStorageFilesFromUploadsFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<InitializeAllStorageFilesFromUploadsParams, () => Promise<InitializeAllStorageFilesFromUploadsResult>, object, unknown>;
 export interface InitializeStorageFileFromUploadFileInput {
     readonly file: FirebaseStorageAccessorFile;
@@ -47,9 +98,23 @@ export interface InitializeStorageFileFromUploadFileInput {
     readonly expediteProcessing?: Maybe<boolean>;
 }
 export declare function _initializeStorageFileFromUploadFileFactory(context: StorageFileServerActionsContext): (input: InitializeStorageFileFromUploadFileInput) => Promise<StorageFileDocument>;
+/**
+ * Factory for the `initializeStorageFileFromUpload` action.
+ *
+ * Initializes a single {@link StorageFile} from an uploaded file at the given storage path.
+ * Validates the file exists and is allowed, runs the type determiner and initializer,
+ * then cleans up the upload source on success.
+ */
 export declare function initializeStorageFileFromUploadFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<InitializeStorageFileFromUploadParams, () => Promise<StorageFileDocument>, object, unknown>;
 export declare function updateStorageFileFactory(context: BaseStorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<UpdateStorageFileParams, (storageFileDocument: StorageFileDocument) => Promise<StorageFileDocument>, object, unknown>;
 export declare function updateStorageFileGroupFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<UpdateStorageFileGroupParams, (storageFileGroupDocument: StorageFileGroupDocument) => Promise<StorageFileGroupDocument>, object, unknown>;
+/**
+ * Factory for the `processAllQueuedStorageFiles` action.
+ *
+ * Batch-processes all {@link StorageFile} documents queued for processing. Creates a
+ * processing notification task for each file and optionally expedites delivery.
+ * Handles stuck-processing detection with a throttle check.
+ */
 export declare function processAllQueuedStorageFilesFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<ProcessAllQueuedStorageFilesParams, () => Promise<ProcessAllQueuedStorageFilesResult>, object, unknown>;
 export interface ProcessStorageFileInTransactionInput {
     /**
@@ -70,9 +135,35 @@ export interface ProcessStorageFileInTransactionInput {
     readonly expediteInstance?: Maybe<NotificationExpediteServiceInstance>;
 }
 export declare function _processStorageFileInTransactionFactory(context: StorageFileServerActionsContext): (input: ProcessStorageFileInTransactionInput, transaction: Transaction) => Promise<void>;
+/**
+ * Factory for the `processStorageFile` action.
+ *
+ * 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.
+ */
 export declare function processStorageFileFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<ProcessStorageFileParams, (storageFileDocument: StorageFileDocument) => Promise<ProcessStorageFileResult>, object, unknown>;
+/**
+ * Factory for the `deleteAllQueuedStorageFiles` action.
+ *
+ * Batch-deletes all {@link StorageFile} documents flagged for deletion whose
+ * scheduled delete time has passed. Removes both the Firestore document and
+ * the associated file in Cloud Storage.
+ */
 export declare function deleteAllQueuedStorageFilesFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<DeleteAllQueuedStorageFilesParams, () => Promise<DeleteAllQueuedStorageFilesResult>, object, unknown>;
+/**
+ * Factory for the `deleteStorageFile` action.
+ *
+ * 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.
+ */
 export declare function deleteStorageFileFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<DeleteStorageFileParams, (inputStorageFileDocument: StorageFileDocument) => Promise<void>, object, unknown>;
+/**
+ * Factory for the `downloadStorageFile` action.
+ *
+ * Generates a signed download URL for a {@link StorageFile}'s associated Cloud Storage file.
+ * The URL expires after the configured duration. Supports loading the storage file document
+ * by key if not provided directly.
+ */
 export declare function downloadStorageFileFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<DownloadStorageFileParams, (storageFileDocument?: Maybe<StorageFileDocument>) => Promise<DownloadStorageFileResult>, object, unknown>;
 /**
  * Used for creating a new NotificationBox within a transaction.
@@ -97,6 +188,12 @@ export declare function createStorageFileGroupInTransactionFactory(context: Stor
     storageFileGroupTemplate: StorageFileGroup;
     storageFileGroupDocument: StorageFileGroupDocument;
 }>;
+/**
+ * Factory for the `createStorageFileGroup` action.
+ *
+ * Creates a new {@link StorageFileGroup} document within a Firestore transaction,
+ * associating it with a model key or storage file.
+ */
 export declare function createStorageFileGroupFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<CreateStorageFileGroupParams, () => Promise<StorageFileGroupDocument>, object, unknown>;
 export interface SyncStorageFileWithGroupsInTransactionInput {
     readonly storageFileDocument: StorageFileDocument;
@@ -120,7 +217,32 @@ export interface SyncStorageFileWithGroupsInTransactionInput {
     readonly skipStorageFileUpdate?: Maybe<boolean>;
 }
 export declare function _syncStorageFileWithGroupsInTransactionFactory(context: StorageFileServerActionsContext): (input: SyncStorageFileWithGroupsInTransactionInput, transaction: Transaction) => Promise<SyncStorageFileWithGroupsResult>;
+/**
+ * Factory for the `syncStorageFileWithGroups` action.
+ *
+ * Syncs a single {@link StorageFile}'s embedded data into its associated {@link StorageFileGroup}
+ * documents and clears the sync flag on completion.
+ */
 export declare function syncStorageFileWithGroupsFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<SyncStorageFileWithGroupsParams, (storageFileDocument: StorageFileDocument) => Promise<SyncStorageFileWithGroupsResult>, object, unknown>;
+/**
+ * Factory for the `syncAllFlaggedStorageFilesWithGroups` action.
+ *
+ * Batch-processes all {@link StorageFile} documents flagged for group sync,
+ * updating their associated {@link StorageFileGroup} documents and flagging
+ * groups for content regeneration when changes occur.
+ */
 export declare function syncAllFlaggedStorageFilesWithGroupsFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<SyncAllFlaggedStorageFilesWithGroupsParams, () => Promise<SyncAllFlaggedStorageFilesWithGroupsResult>, object, unknown>;
+/**
+ * Factory for the `regenerateStorageFileGroupContent` action.
+ *
+ * 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.
+ */
 export declare function regenerateStorageFileGroupContentFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<RegenerateStorageFileGroupContentParams, (storageFileGroupDocument: StorageFileGroupDocument) => Promise<RegenerateStorageFileGroupContentResult>, object, unknown>;
+/**
+ * Factory for the `regenerateAllFlaggedStorageFileGroupsContent` action.
+ *
+ * Batch-processes all {@link StorageFileGroup} documents flagged for content regeneration,
+ * rebuilding their ZIP archives and updating content metadata.
+ */
 export declare function regenerateAllFlaggedStorageFileGroupsContentFactory(context: StorageFileServerActionsContext): import("@dereekb/model").TransformAndValidateFunctionResultFunction<RegenerateAllFlaggedStorageFileGroupsContentParams, () => Promise<RegenerateAllFlaggedStorageFileGroupsContentResult>, object, unknown>;

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

@@ -1,15 +1,59 @@
 import { type UploadedFileInitializationFailedErrorData } from '@dereekb/firebase';
+/**
+ * Creates an error indicating that a storage file model has already been initialized.
+ */
 export declare function storageFileModelAlreadyInitializedError(): import("firebase-functions/https").HttpsError;
+/**
+ * Creates an error indicating that the StorageFile is not flagged for group sync.
+ */
 export declare function storageFileNotFlaggedForGroupsSyncError(): import("firebase-functions/https").HttpsError;
+/**
+ * Creates an error indicating that the target uploaded file does not exist in storage.
+ */
 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).
+ */
 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
+ */
 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).
+ */
 export declare function uploadedFileInitializationDiscardedError(): import("firebase-functions/https").HttpsError;
+/**
+ * Creates an error indicating that the StorageFile is not in a valid state for processing.
+ */
 export declare function storageFileProcessingNotAllowedForInvalidStateError(): import("firebase-functions/https").HttpsError;
+/**
+ * Creates an error indicating that the StorageFile is not queued for processing.
+ */
 export declare function storageFileProcessingNotQueuedForProcessingError(): import("firebase-functions/https").HttpsError;
+/**
+ * Creates an error indicating that no processor is configured for the StorageFile's type.
+ */
 export declare function storageFileProcessingNotAvailableForTypeError(): import("firebase-functions/https").HttpsError;
+/**
+ * Creates an error indicating that the StorageFile has already finished processing.
+ */
 export declare function storageFileAlreadyProcessedError(): import("firebase-functions/https").HttpsError;
+/**
+ * Creates an error indicating that the StorageFile is not flagged for deletion.
+ */
 export declare function storageFileNotFlaggedForDeletionError(): import("firebase-functions/https").HttpsError;
+/**
+ * Creates an error indicating that the StorageFile's scheduled deletion time has not yet passed.
+ */
 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.
+ */
 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.
+ */
 export declare function createStorageFileGroupInputError(): import("firebase-functions/https").HttpsError;

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

@@ -3,8 +3,19 @@ import { type Maybe } from '@dereekb/util';
 import { type BaseStorageFileServerActionsContext, StorageFileServerActions, type StorageFileServerActionsContext } from './storagefile.action.server';
 import { StorageFileInitializeFromUploadService } from './storagefile.upload.service';
 import { StorageFileInitServerActions, type StorageFileInitServerActionsContextConfig } from './storagefile.action.init.service';
+/**
+ * Factory that assembles the full {@link StorageFileServerActionsContext} by combining
+ * the base context with the upload initialization service.
+ */
 export declare function storageFileServerActionsContextFactory(context: BaseStorageFileServerActionsContext, storageFileInitializeFromUploadService: StorageFileInitializeFromUploadService): StorageFileServerActionsContext;
+/**
+ * Factory that creates a {@link StorageFileServerActions} instance from the assembled context.
+ */
 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.
+ */
 export declare function storageFileInitServerActionsFactory(context: StorageFileServerActionsContext, storageFileInitServerActionsContextConfig: StorageFileInitServerActionsContextConfig): StorageFileInitServerActions;
 export interface ProvideAppStorageFileMetadataConfig extends Pick<ModuleMetadata, 'imports' | 'exports' | 'providers'> {
     /**

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

@@ -5,7 +5,10 @@ import { type StorageFileQueueForDeleteTime } from './storagefile.util';
 import { type NotificationTaskSubtaskCleanupInstructions, type NotificationTaskSubtaskFlowEntry, type NotificationTaskSubtaskInput, type NotificationTaskSubtaskNotificationTaskHandlerConfig, type NotificationTaskSubtaskProcessorConfig } from '../notification/notification.task.subtask.handler';
 import archiver from 'archiver';
 /**
- * Input for a StorageFileProcessingPurposeSubtask.
+ * Input for a purpose-specific storage file processing subtask.
+ *
+ * Extends the generic subtask input with storage-file-specific context: the document reference,
+ * a lazy loader for the current file data, and a file reader for accessing the stored file's content.
  */
 export interface StorageFileProcessingPurposeSubtaskInput<M extends StorageFileProcessingSubtaskMetadata = any, S extends StorageFileProcessingSubtask = StorageFileProcessingSubtask> extends NotificationTaskSubtaskInput<StorageFileProcessingNotificationTaskData<M, S>, M, S> {
     /**

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

@@ -6,6 +6,9 @@ import { type Maybe, type PromiseOrValue } from '@dereekb/util';
 export interface StorageFileInitializeFromUploadServiceRef {
     readonly storageFileInitializeFromUploadService: StorageFileInitializeFromUploadService;
 }
+/**
+ * Input for storage file upload initialization, containing the file to process.
+ */
 export interface StorageFileInitializeFromUploadInput {
     /**
      * The target file.
@@ -14,6 +17,10 @@ export interface StorageFileInitializeFromUploadInput {
      */
     readonly file: FirebaseStorageAccessorFile;
 }
+/**
+ * Result of a storage file upload initialization, indicating success/failure,
+ * the created file path, and the initialized document.
+ */
 export interface StorageFileInitializeFromUploadResult {
     /**
      * Whether or not the initialization was successful.
@@ -39,7 +46,12 @@ export interface StorageFileInitializeFromUploadResult {
     readonly previousStorageFilesFlaggedForDeletion?: Maybe<number>;
 }
 /**
- * Service dedicated to initializing a StorageFileDocument value from an uploaded file.
+ * Abstract service responsible for the upload-to-StorageFile initialization pipeline.
+ *
+ * Implementations determine the uploaded file's type, validate it's allowed,
+ * and create the corresponding {@link StorageFile} document in Firestore.
+ *
+ * @see {@link storageFileInitializeFromUploadService} for the default implementation.
  */
 export declare abstract class StorageFileInitializeFromUploadService {
     /**

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

@@ -2,6 +2,10 @@ import { type CombineUploadFileTypeDeterminerConfig, type CreateStorageFileDocum
 import { type ArrayOrValue, type AsyncDecisionFunction, type Maybe } from '@dereekb/util';
 import { type StorageFileInitializeFromUploadService } from './storagefile.upload.service';
 import { type FirebaseServerStorageService } from '@dereekb/firebase-server';
+/**
+ * Input for a storage file upload initializer, providing the type determination result
+ * and the file reader for accessing the uploaded file's content.
+ */
 export interface StorageFileInitializeFromUploadServiceInitializerInput {
     /**
      * The result of the determiner.
@@ -12,6 +16,12 @@ export interface StorageFileInitializeFromUploadServiceInitializerInput {
      */
     readonly fileDetailsAccessor: StoredFileReader;
 }
+/**
+ * Union result type from a storage file upload initializer. Can be:
+ * - An error result (initialization failed)
+ * - A create result (new StorageFile document was created via pair factory)
+ * - A document result (StorageFile document was created/found directly)
+ */
 export type StorageFileInitializeFromUploadServiceInitializerResult = StorageFileInitializeFromUploadServiceInitializerStorageFileErrorResult | StorageFileInitializeFromUploadServiceInitializerCreateStorageFileResult | StorageFileInitializeFromUploadServiceInitializerStorageFileDocumentResult;
 export interface StorageFileInitializeFromUploadServiceInitializerStorageFileErrorResult {
     /**
@@ -55,6 +65,13 @@ export interface StorageFileInitializeFromUploadServiceInitializerStorageFileDoc
      */
     readonly flagPreviousForDelete?: Maybe<StorageFilePurposeAndUserQueryInput>;
 }
+/**
+ * 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
+ */
 export declare function storageFileInitializeFromUploadServiceInitializerResultPermanentFailure(error: unknown, createdFile?: Maybe<StoragePathRef>): StorageFileInitializeFromUploadServiceInitializerResult;
 /**
  * Processes the input details accessor and returns the results.
@@ -117,6 +134,31 @@ export interface StorageFileInitializeFromUploadServiceConfig {
     readonly initializer: StorageFileInitializeFromUploadServiceInitializer[];
 }
 /**
- * A basic StorageFileInitializeFromUploadService implementation.
+ * Creates a {@link StorageFileInitializeFromUploadService} from the provided configuration.
+ *
+ * Combines file type determiners with type-specific initializers to form a complete
+ * upload processing pipeline. When a file is uploaded:
+ *
+ * 1. The combined determiner identifies the file type
+ * 2. The corresponding initializer processes the file (copies, creates Firestore document, etc.)
+ * 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
+ *
+ * @example
+ * ```ts
+ * const service = storageFileInitializeFromUploadService({
+ *   storageService,
+ *   storageFileCollection,
+ *   initializer: [
+ *     {
+ *       type: 'image',
+ *       determiner: imageDeterminer,
+ *       initialize: processImage
+ *     }
+ *   ]
+ * });
+ * ```
  */
 export declare function storageFileInitializeFromUploadService(config: StorageFileInitializeFromUploadServiceConfig): StorageFileInitializeFromUploadService;

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

@@ -8,6 +8,10 @@ import { type Maybe, type Milliseconds, type ArrayOrValue } from '@dereekb/util'
  * If a Date, the StorageFile will be queued for deletion at the specified date.
  */
 export type StorageFileQueueForDeleteTime = true | Milliseconds | Date;
+/**
+ * Input for {@link queryAndFlagStorageFilesForDelete}, specifying the query constraints,
+ * collection, deletion timing, and optional keys to skip.
+ */
 export interface QueryAndFlagStorageFilesForDeleteInput {
     readonly storageFileCollection: StorageFileFirestoreCollection;
     readonly constraints: FirestoreQueryConstraint[];
@@ -17,6 +21,10 @@ export interface QueryAndFlagStorageFilesForDeleteInput {
      */
     readonly skipDeleteForKeys?: ArrayOrValue<StorageFileKey>;
 }
+/**
+ * Result of {@link queryAndFlagStorageFilesForDelete}, reporting how many files were visited
+ * and how many were actually flagged for deletion.
+ */
 export interface QueryAndFlagStorageFilesForDeleteResult {
     readonly visitedCount: number;
     readonly queuedForDeleteCount: number;

package/oidc/index.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./index.cjs.js').default;