@dereekb/firebase 12.4.5 → 12.5.0

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

@@ -58,7 +58,7 @@ export interface NotificationTask<D extends NotificationItemMetadata = {}> {
 /**
  * Returns an empty array, which is used to signal that the task did not fail but has not complete the current checkpoint.
  */
-export declare function delayCompletion(): NotificationTaskServiceTaskHandlerCompletionType;
+export declare function delayCompletion<S extends NotificationTaskCheckpointString = NotificationTaskCheckpointString>(): NotificationTaskServiceTaskHandlerCompletionType<S>;
 /**
  * Convenience function for returning a NotificationTaskServiceHandleNotificationTaskResult that says the task should be retried after the specified delay.
  *
@@ -68,7 +68,7 @@ export declare function notificationTaskDelayRetry<D extends NotificationItemMet
 /**
  * Convenience function for returning a NotificationTaskServiceHandleNotificationTaskResult that says the task was partially completed, and to process the next part in the future.
  */
-export declare function notificationTaskPartiallyComplete<D extends NotificationItemMetadata = {}>(completedParts: ArrayOrValue<NotificationTaskCheckpointString>, updateMetadata?: Maybe<Partial<D>>): NotificationTaskServiceHandleNotificationTaskResult<D>;
+export declare function notificationTaskPartiallyComplete<D extends NotificationItemMetadata = {}, S extends NotificationTaskCheckpointString = NotificationTaskCheckpointString>(completedParts: ArrayOrValue<S>, updateMetadata?: Maybe<Partial<D>>): NotificationTaskServiceHandleNotificationTaskResult<D, S>;
 /**
  * Convenience function for returning a NotificationTaskServiceHandleNotificationTaskResult that says the task was completed successfully.
  */
@@ -77,26 +77,34 @@ export declare function notificationTaskComplete<D extends NotificationItemMetad
  * Convenience function for returning a NotificationTaskServiceHandleNotificationTaskResult that says the task failed.
  */
 export declare function notificationTaskFailed<D extends NotificationItemMetadata = {}>(updateMetadata?: Maybe<Partial<D>>, removeFromCompletedCheckpoints?: Maybe<ArrayOrValue<NotificationTaskCheckpointString>>): NotificationTaskServiceHandleNotificationTaskResult<D>;
+/**
+ * Wraps an existing NotificationTaskServiceHandleNotificationTaskResult<D> and sets canRunNextCheckpoint to true if it is undefined.
+ *
+ * @param result The result to use as a template.
+ * @param force If true, then canRunNextCheckpoint will be set to true even if it is already defined.
+ * @returns A new result.
+ */
+export declare function notificationTaskCanRunNextCheckpoint<D extends NotificationItemMetadata = {}>(result: NotificationTaskServiceHandleNotificationTaskResult<D>, force?: Maybe<boolean>): NotificationTaskServiceHandleNotificationTaskResult<D>;
 /**
  * One or more NotificationTaskCheckpointString values that are considered complete.
  */
-export type NotificationTaskServiceTaskHandlerCompletionTypeCheckpoint = ArrayOrValue<NotificationTaskCheckpointString>;
+export type NotificationTaskServiceTaskHandlerCompletionTypeCheckpoint<S extends NotificationTaskCheckpointString = NotificationTaskCheckpointString> = ArrayOrValue<S>;
 /**
- * Result of a NotificationTaskServiceTaskHandler.handleNotificationTask() call.
+ * Result type of a NotificationTaskServiceTaskHandler.handleNotificationTask() call.
  *
  * true: The task was completed successfully and can now be discarded.
  * false: The task was not completed successfully and should be retried again in the future. Note there are a maximum number of retry attempts before the task is deleted. Use delayCompletion() to avoid increasing the attempt count.
  * NotificationTaskCheckpointString(s): The task has successfully completed this/these particular checkpoint(s) but is not complete and should be continued again in the future. Return an empty array to signal that the task did not fail but has not reached the next checkpoint.
  */
-export type NotificationTaskServiceTaskHandlerCompletionType = true | false | NotificationTaskServiceTaskHandlerCompletionTypeCheckpoint;
+export type NotificationTaskServiceTaskHandlerCompletionType<S extends NotificationTaskCheckpointString = NotificationTaskCheckpointString> = true | false | NotificationTaskServiceTaskHandlerCompletionTypeCheckpoint<S>;
 /**
  * Result of a NotificationTaskServiceTaskHandler.handleNotificationTask() call.
  */
-export interface NotificationTaskServiceHandleNotificationTaskResult<D extends NotificationItemMetadata = {}> {
+export interface NotificationTaskServiceHandleNotificationTaskResult<D extends NotificationItemMetadata = {}, S extends NotificationTaskCheckpointString = NotificationTaskCheckpointString> {
     /**
      * Completion type for the task result.
      */
-    readonly completion: NotificationTaskServiceTaskHandlerCompletionType;
+    readonly completion: NotificationTaskServiceTaskHandlerCompletionType<S>;
     /**
      * If true, clears all completed checkpoints.
      */
@@ -110,7 +118,7 @@ export interface NotificationTaskServiceHandleNotificationTaskResult<D extends N
      *
      * Ignored if removeAllCompletedCheckpoints is true.
      */
-    readonly removeFromCompletedCheckpoints?: Maybe<ArrayOrValue<NotificationTaskCheckpointString>>;
+    readonly removeFromCompletedCheckpoints?: Maybe<ArrayOrValue<S>>;
     /**
      * Updates the metadata for the notification item if the task is successful but not yet marked done.
      *
@@ -121,4 +129,10 @@ export interface NotificationTaskServiceHandleNotificationTaskResult<D extends N
      * Delays the next run of the task by the specified amount of time or until the given date.
      */
     readonly delayUntil?: Maybe<Date | Milliseconds>;
+    /**
+     * If true, can run the next part of the task immediately.
+     *
+     * Ignored if delayUntil is set or if the completion is true/false/empty array.
+     */
+    readonly canRunNextCheckpoint?: Maybe<boolean>;
 }

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

@@ -0,0 +1,12 @@
+export * from './storagefile.action';
+export * from './storagefile.api.error';
+export * from './storagefile.api';
+export * from './storagefile.create';
+export * from './storagefile.id';
+export * from './storagefile.query';
+export * from './storagefile.task';
+export * from './storagefile';
+export * from './storagefile.file';
+export * from './storagefile.upload';
+export * from './storagefile.upload.claims';
+export * from './storagefile.upload.determiner';

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

@@ -0,0 +1,8 @@
+import { AsyncFirebaseFunctionDeleteAction, FirebaseFunctionDeleteAction, type AsyncFirebaseFunctionCreateAction, type AsyncFirebaseFunctionUpdateAction, type FirebaseFunctionCreateAction, type FirebaseFunctionUpdateAction } from '../../common';
+import { type StorageFileDocument } from './storagefile';
+export type StorageFileCreateAction<P extends object> = FirebaseFunctionCreateAction<P, StorageFileDocument>;
+export type AsyncStorageFileCreateAction<P extends object> = AsyncFirebaseFunctionCreateAction<P, StorageFileDocument>;
+export type StorageFileUpdateAction<P extends object> = FirebaseFunctionUpdateAction<P, StorageFileDocument>;
+export type AsyncStorageFileUpdateAction<P extends object> = AsyncFirebaseFunctionUpdateAction<P, StorageFileDocument>;
+export type StorageFileDeleteAction<P extends object> = FirebaseFunctionDeleteAction<P, StorageFileDocument>;
+export type AsyncStorageFileDeleteAction<P extends object> = AsyncFirebaseFunctionDeleteAction<P, StorageFileDocument>;

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

@@ -0,0 +1,148 @@
+import { TargetModelParams, OnCallCreateModelResult } from '../../common';
+import { type ModelFirebaseCrudFunction, type FirebaseFunctionTypeConfigMap, type ModelFirebaseCrudFunctionConfigMap, type ModelFirebaseFunctionMap, ModelFirebaseCreateFunction } from '../../client';
+import { StorageFileTypes } from './storagefile';
+import { StorageBucketId, StoragePath, StorageSlashPath } from '../../common/storage';
+import { Maybe } from '@dereekb/util';
+/**
+ * Used for directly create a new StorageFile.
+ */
+export declare class CreateStorageFileParams {
+}
+/**
+ * Initializes all StorageFiles in the uploads folder.
+ */
+export declare class InitializeAllStorageFilesFromUploadsParams {
+    /**
+     * The maximum number of files to initialize at once.
+     */
+    maxFilesToInitialize?: Maybe<number>;
+    /**
+     * The specific folder under the uploads folder to search for files and initialize
+     */
+    folderPath?: Maybe<StorageSlashPath>;
+    /**
+     * Overrides the default uploads folder path.
+     */
+    overrideUploadsFolderPath?: Maybe<StorageSlashPath>;
+}
+export interface InitializeAllStorageFilesFromUploadsResult extends OnCallCreateModelResult {
+    readonly filesVisited: number;
+    readonly initializationsSuccessCount: number;
+    readonly initializationsFailureCount: number;
+}
+/**
+ * Initializes a StorageFile from the document at the given path.
+ */
+export declare class InitializeStorageFileFromUploadParams implements Pick<StoragePath, 'pathString'> {
+    /**
+     * Specific bucketId to use.
+     *
+     * If not defined, the default bucket will be used.
+     */
+    bucketId?: Maybe<StorageBucketId>;
+    pathString: StorageSlashPath;
+}
+export declare class ProcessStorageFileParams extends TargetModelParams {
+    /**
+     * If set, will start/run the processing immediately instead of waiting for the next scheduled run.
+     */
+    runImmediately?: Maybe<boolean>;
+    /**
+     * If set, will check and retry processing if the StorageFile is in a failed processing state.
+     */
+    checkRetryProcessing?: Maybe<boolean>;
+    /**
+     * Used with retryProcessing.
+     *
+     * If set, will forcibly create a new processing task even if the existing processing task appears to be ok.
+     */
+    forceRestartProcessing?: Maybe<boolean>;
+}
+export interface ProcessStorageFileResult {
+}
+/**
+ * Processes all StorageFiles that are queued for processing.
+ */
+export declare class ProcessAllQueuedStorageFilesParams {
+}
+export interface ProcessAllQueuedStorageFilesResult {
+    /**
+     * The total number of StorageFiles visited.
+     */
+    readonly storageFilesVisited: number;
+    /**
+     * The total number of StorageFiles that started processing.
+     */
+    readonly storageFilesProcessStarted: number;
+    /**
+     * The total number of StorageFiles that failed to start processing.
+     */
+    readonly storageFilesFailedStarting: number;
+}
+export declare class UpdateStorageFileParams extends TargetModelParams {
+    /**
+     * Sets the delete at time for the given StorageFileDocument, and queues the file for deletion.
+     */
+    sdat?: Maybe<Date>;
+}
+export declare class DeleteStorageFileParams extends TargetModelParams {
+    /**
+     * If true, will force the deletion of the StorageFile even if it is not queued for deletion.
+     */
+    force?: Maybe<boolean>;
+}
+/**
+ * Processes all StorageFiles that are queued for processing.
+ */
+export declare class DeleteAllQueuedStorageFilesParams {
+}
+export interface DeleteAllQueuedStorageFilesResult {
+    /**
+     * The total number of StorageFiles visited.
+     */
+    readonly storageFilesVisited: number;
+    /**
+     * The total number of StorageFiles that were deleted.
+     */
+    readonly storageFilesDeleted: number;
+    /**
+     * The total number of StorageFiles that failed to delete.
+     */
+    readonly storageFilesFailedDeleting: number;
+}
+export type StorageFileFunctionTypeMap = {};
+export declare const storageFileFunctionTypeConfigMap: FirebaseFunctionTypeConfigMap<StorageFileFunctionTypeMap>;
+export type StorageFileModelCrudFunctionsConfig = {
+    readonly storageFile: {
+        create: {
+            _: CreateStorageFileParams;
+            fromUpload: InitializeStorageFileFromUploadParams;
+            allFromUpload: [InitializeAllStorageFilesFromUploadsParams, InitializeAllStorageFilesFromUploadsResult];
+        };
+        update: {
+            _: UpdateStorageFileParams;
+            process: [ProcessStorageFileParams, ProcessStorageFileResult];
+        };
+        delete: {
+            _: DeleteStorageFileParams;
+        };
+    };
+};
+export declare const storageFileModelCrudFunctionsConfig: ModelFirebaseCrudFunctionConfigMap<StorageFileModelCrudFunctionsConfig, StorageFileTypes>;
+export declare abstract class StorageFileFunctions implements ModelFirebaseFunctionMap<StorageFileFunctionTypeMap, StorageFileModelCrudFunctionsConfig> {
+    abstract storageFile: {
+        createStorageFile: {
+            create: ModelFirebaseCreateFunction<CreateStorageFileParams, OnCallCreateModelResult>;
+            fromUpload: ModelFirebaseCreateFunction<InitializeStorageFileFromUploadParams, OnCallCreateModelResult>;
+            allFromUpload: ModelFirebaseCrudFunction<InitializeAllStorageFilesFromUploadsParams, InitializeAllStorageFilesFromUploadsResult>;
+        };
+        updateStorageFile: {
+            update: ModelFirebaseCrudFunction<UpdateStorageFileParams>;
+            process: ModelFirebaseCrudFunction<ProcessStorageFileParams, ProcessStorageFileResult>;
+        };
+        deleteStorageFile: {
+            delete: ModelFirebaseCrudFunction<DeleteStorageFileParams>;
+        };
+    };
+}
+export declare const storageFileFunctionMap: import("../../client").ModelFirebaseFunctionMapFactory<StorageFileFunctionTypeMap, StorageFileModelCrudFunctionsConfig>;

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

@@ -0,0 +1,51 @@
+import { Maybe } from '@dereekb/util';
+import { StorageFileInitializeFromUploadResultType } from './storagefile.upload';
+/**
+ * Thrown if the target uploaded file does not exist.
+ */
+export declare const UPLOADED_FILE_DOES_NOT_EXIST_ERROR_CODE = "UPLOADED_FILE_DOES_NOT_EXIST";
+/**
+ * Thrown if the target uploaded file is not allowed to be initialized.
+ */
+export declare const UPLOADED_FILE_NOT_ALLOWED_TO_BE_INITIALIZED_ERROR_CODE = "UPLOADED_FILE_NOT_ALLOWED_TO_BE_INITIALIZED";
+/**
+ * Thrown if the target uploaded file initialization failed.
+ */
+export declare const UPLOADED_FILE_INITIALIZATION_FAILED_ERROR_CODE = "UPLOADED_FILE_INITIALIZATION_FAILED";
+export interface UploadedFileInitializationFailedErrorData {
+    readonly resultType: StorageFileInitializeFromUploadResultType;
+    /**
+     * True if the file was deleted.
+     */
+    readonly fileDeleted?: Maybe<boolean>;
+}
+/**
+ * Thrown if the target uploaded file initialization was successful, but produced no new StorageFileDocument.
+ */
+export declare const UPLOADED_FILE_INITIALIZATION_DISCARDED_ERROR_CODE = "UPLOADED_FILE_INITIALIZATION_DISCARDED";
+/**
+ * Thrown if the target StorageFileDocument is not queued for processing and is called to be processed.
+ */
+export declare const STORAGE_FILE_PROCESSING_NOT_QUEUED_FOR_PROCESSING_ERROR_CODE = "STORAGE_FILE_PROCESSING_NOT_QUEUED_FOR_PROCESSING";
+/**
+ * Thrown if:
+ * - the target StorageFileDocument was marked as queued for processing but isn't actually a processable-type.
+ * - the target StorageFileDocument is marked as init but has no purpose set, meaning it can't be processed.
+ */
+export declare const STORAGE_FILE_PROCESSING_NOT_AVAILABLE_FOR_TYPE_ERROR_CODE = "STORAGE_FILE_PROCESSING_NOT_AVAILABLE_FOR_TYPE";
+/**
+ * Thrown if the StorageFile is not in an OK state.
+ */
+export declare const STORAGE_FILE_PROCESSING_NOT_ALLOWED_FOR_INVALID_STATE_ERROR_CODE = "STORAGE_FILE_PROCESSING_NOT_ALLOWED_FOR_INVALID_STATE";
+/**
+ * Thrown if the target StorageFileDocument already finished processing.
+ */
+export declare const STORAGE_FILE_ALREADY_PROCESSED_ERROR_CODE = "STORAGE_FILE_ALREADY_PROCESSED";
+/**
+ * Thrown if the target StorageFileDocument is not flagged for deletion but attempts to be deleted.
+ */
+export declare const STORAGE_FILE_NOT_FLAGGED_FOR_DELETION_ERROR_CODE = "STORAGE_FILE_NOT_FLAGGED_FOR_DELETION";
+/**
+ * Thrown if the target StorageFileDocument is flagged for deletion, but has not reached the time to be deleted yet.
+ */
+export declare const STORAGE_FILE_CANNOT_BE_DELETED_YET_ERROR_CODE = "STORAGE_FILE_CANNOT_BE_DELETED_YET";

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

@@ -0,0 +1,121 @@
+import { type Maybe } from '@dereekb/util';
+import { StorageFileCreationType, type StorageFile, type StorageFileDocument, type StorageFileFirestoreCollections } from './storagefile';
+import { type Transaction } from '../../common/firestore/types';
+import { type FirestoreDocumentAccessor } from '../../common/firestore/accessor/document';
+import { type FirebaseStorageAccessorFile } from '../../common/storage/driver/accessor';
+import { StoragePathRef, type StoragePath } from '../../common/storage/storage';
+import { FirebaseAuthOwnershipKey, type FirebaseAuthUserId } from '../../common/auth/auth';
+import { StorageFileMetadata, StorageFilePurpose } from './storagefile.id';
+export interface CreateStorageFileDocumentPairInput<M extends StorageFileMetadata = StorageFileMetadata> {
+    /**
+     * Optional "now" value that is assigned to the "cat" value, created at time.
+     */
+    readonly now?: Maybe<Date>;
+    /**
+     * The document transaction
+     */
+    readonly transaction?: Transaction;
+    /**
+     * The storage path to set on the StorageFile template.
+     *
+     * Is ignored if file or storagePathRef is provided.
+     */
+    readonly storagePath?: StoragePath;
+    /**
+     * The ref of the storage path to set on the StorageFile template.
+     *
+     * Is ignored if file is provided.
+     */
+    readonly storagePathRef?: StoragePathRef;
+    /**
+     * File to use when creating the StorageFile.
+     */
+    readonly file?: FirebaseStorageAccessorFile;
+    /**
+     * The user that the file is associated with.
+     *
+     * Corresponds with the "u" value in the StorageFile template.
+     */
+    readonly user?: Maybe<FirebaseAuthUserId>;
+    /**
+     * The user that uploaded the file.
+     *
+     * Corresponds with the "uby" value in the StorageFile template.
+     */
+    readonly uploadedBy?: Maybe<FirebaseAuthUserId>;
+    /**
+     * The ownership key of the file.
+     *
+     * Corresponds with the "o" value in the StorageFile template.
+     */
+    readonly ownershipKey?: Maybe<FirebaseAuthOwnershipKey>;
+    /**
+     * The purpose of the file.
+     *
+     * Corresponds with the "p" value in the StorageFile template.
+     */
+    readonly purpose?: Maybe<StorageFilePurpose>;
+    /**
+     * The metadata of the file.
+     *
+     * Corresponds with the "m" value in the StorageFile template.
+     */
+    readonly metadata?: Maybe<M>;
+    /**
+     * If true, will queue the StorageFile for processing.
+     */
+    readonly shouldBeProcessed?: Maybe<boolean>;
+    /**
+     * Template details for the StorageFileDocument.
+     */
+    readonly template?: Maybe<Omit<Partial<StorageFile<M>>, 'cat'>>;
+    /**
+     * Context to create the accessor from.
+     */
+    readonly context?: Pick<StorageFileFirestoreCollections, 'storageFileCollection'>;
+    /**
+     * Accessor to use directly.
+     */
+    readonly accessor?: FirestoreDocumentAccessor<StorageFile, StorageFileDocument>;
+}
+export interface CreateStorageFileDocumentPairResult<M extends StorageFileMetadata = StorageFileMetadata> {
+    /**
+     * The StorageFileDocument that was created.
+     */
+    readonly storageFileDocument: StorageFileDocument;
+    /**
+     * The template that was passed to create the StorageFileDocument.
+     */
+    readonly storageFile: StorageFile<M>;
+}
+export interface CreateStorageFileDocumentPairFactoryConfig {
+    /**
+     * The default creation type to use.
+     *
+     * Defaults to StorageFileCreationType.DIRECTLY_CREATED.
+     */
+    readonly defaultCreationType?: Maybe<StorageFileCreationType>;
+    /**
+     * The default value for shouldBeProcessed.
+     *
+     * Defaults to false.
+     */
+    readonly defaultShouldBeProcessed?: Maybe<boolean>;
+}
+/**
+ * Factory function for creating StorageFileDocument pairs.
+ */
+export type CreateStorageFileDocumentPairFactory = <M extends StorageFileMetadata = StorageFileMetadata>(input: CreateStorageFileDocumentPairInput<M>) => Promise<CreateStorageFileDocumentPairResult<M>>;
+/**
+ * Creates a CreateStorageFileDocumentPairFactory.
+ *
+ * @param config
+ * @returns
+ */
+export declare function createStorageFileDocumentPairFactory(config?: CreateStorageFileDocumentPairFactoryConfig): CreateStorageFileDocumentPairFactory;
+/**
+ * Convenience function for creating a StorageFileDocumentPair.
+ *
+ * Calls createStorageFileDocumentPairFactory() with no arguments, then passes the input to the factory and returns the result.
+ */
+export declare function createStorageFileDocumentPair<M extends StorageFileMetadata = StorageFileMetadata>(input: CreateStorageFileDocumentPairInput<M>): Promise<CreateStorageFileDocumentPairResult<M>>;

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

@@ -0,0 +1,164 @@
+import { type Maybe } from '@dereekb/util';
+import { type GrantedReadRole, type GrantedUpdateRole } from '@dereekb/model';
+import { AbstractFirestoreDocument, type CollectionReference, type FirestoreCollection, type FirestoreContext, FirebaseAuthUserId, FirebaseAuthOwnershipKey, StoragePath } from '../../common';
+import { StorageFileMetadata, StorageFilePurpose } from './storagefile.id';
+import { NotificationKey } from '../notification';
+export declare abstract class StorageFileFirestoreCollections {
+    abstract readonly storageFileCollection: StorageFileFirestoreCollection;
+}
+export type StorageFileTypes = typeof storageFileIdentity;
+export declare const storageFileIdentity: import("../../common").RootFirestoreModelIdentity<"storageFile", "sf">;
+/**
+ * The current file state.
+ */
+export declare enum StorageFileCreationType {
+    /**
+     * No info about how this file was created.
+     */
+    NONE = 0,
+    /**
+     * The StorageFile was directly created.
+     */
+    DIRECTLY_CREATED = 1,
+    /**
+     * The StorageFile was initialized from an uploaded file.
+     */
+    INIT_FROM_UPLOAD = 2
+}
+/**
+ * The current file state.
+ */
+export declare enum StorageFileState {
+    /**
+     * The StorageFile has no state, or is just being initialized.
+     */
+    INIT = 0,
+    /**
+     * The StorageFile failed to initialize properly and is considered invalid.
+     *
+     * StorageFiles that are marked invalid are deleted after a period of time.
+     *
+     * Files that are invalid cannot be processed.
+     */
+    INVALID = 1,
+    /**
+     * The StorageFile has been initialized and is ok.
+     */
+    OK = 2,
+    /**
+     * A previously OK file that is now queued for deletion.
+     */
+    QUEUED_FOR_DELETE = 3
+}
+/**
+ * The current processing state of the file.
+ */
+export declare enum StorageFileProcessingState {
+    /**
+     * The StorageFile has no processing state or is just being initialized.
+     */
+    INIT_OR_NONE = 0,
+    /**
+     * The StorageFile is flagged for processing, which will create a NotificationTask for it.
+     */
+    QUEUED_FOR_PROCESSING = 1,
+    /**
+     * The StorageFile has an associated NotificationTask for it.
+     */
+    PROCESSING = 2,
+    /**
+     * The StorageFile has encountered an error during processing.
+     */
+    FAILED = 3,
+    /**
+     * The StorageFile has been processed or required no processing and is done.
+     */
+    SUCCESS = 4,
+    /**
+     * The StorageFile has been archived. It should not be processed.
+     */
+    ARCHIVED = 5,
+    /**
+     * The StorageFile shouldn't be processed.
+     */
+    DO_NOT_PROCESS = 6
+}
+/**
+ * After 3 hours of being in the PROCESSING state, we can check for retring processing.
+ */
+export declare const STORAGE_FILE_PROCESSING_STUCK_THROTTLE_CHECK_MS: number;
+/**
+ * A global storage file in the system.
+ *
+ * Contains file metadata and ownership information, along with other arbitrary metadata.
+ */
+export interface StorageFile<M extends StorageFileMetadata = StorageFileMetadata> extends StoragePath {
+    /**
+     * Created at date
+     */
+    cat: Date;
+    /**
+     * Type of creation.
+     */
+    ct?: Maybe<StorageFileCreationType>;
+    /**
+     * State of the storage file.
+     */
+    fs: StorageFileState;
+    /**
+     * Processing state of the storage file.
+     */
+    ps: StorageFileProcessingState;
+    /**
+     * The NotificationTask key for this storage file.
+     *
+     * Set only if the StorageFile has an associated NotificationTask.
+     *
+     * Cleared once the processing stage is no longer PROCESSING.
+     */
+    pn?: Maybe<NotificationKey>;
+    /**
+     * The date that state was last updated to PROCESSING.
+     *
+     * Is used as a way to track if processing should be checked on.
+     */
+    pat?: Maybe<Date>;
+    /**
+     * The date that the cleanup step of the processing task was run, and the notification ended.
+     */
+    pcat?: Maybe<Date>;
+    /**
+     * User this file is associated with, if applicable.
+     */
+    u?: Maybe<FirebaseAuthUserId>;
+    /**
+     * User who uploaded this file, if applicable.
+     */
+    uby?: Maybe<FirebaseAuthUserId>;
+    /**
+     * Ownership key, if applicable.
+     */
+    o?: Maybe<FirebaseAuthOwnershipKey>;
+    /**
+     * Purpose of the file, if applicable.
+     */
+    p?: Maybe<StorageFilePurpose>;
+    /**
+     * Arbitrary metadata attached to the StorageFile.
+     */
+    d?: Maybe<M>;
+    /**
+     * Scheduled delete at date. The StorageFile cannot be deleted before this set time.
+     *
+     * Is the main trigger for determining a StorageFile should be deleted.
+     */
+    sdat?: Maybe<Date>;
+}
+export type StorageFileRoles = 'process' | GrantedUpdateRole | GrantedReadRole;
+export declare class StorageFileDocument extends AbstractFirestoreDocument<StorageFile, StorageFileDocument, typeof storageFileIdentity> {
+    get modelIdentity(): import("../../common").RootFirestoreModelIdentity<"storageFile", "sf">;
+}
+export declare const storageFileConverter: import("../../common").SnapshotConverterFunctions<StorageFile<Readonly<Record<string, any>>>, Partial<import("@dereekb/util").ReplaceType<StorageFile<Readonly<Record<string, any>>>, import("@dereekb/util").MaybeMap<object>, any>>>;
+export declare function storageFileCollectionReference(context: FirestoreContext): CollectionReference<StorageFile>;
+export type StorageFileFirestoreCollection = FirestoreCollection<StorageFile, StorageFileDocument>;
+export declare function storageFileFirestoreCollection(firestoreContext: FirestoreContext): StorageFileFirestoreCollection;

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

@@ -0,0 +1,55 @@
+import { Factory, FactoryWithRequiredInput, Maybe, SlashPathDetails } from '@dereekb/util';
+import { StoragePath } from '../../common/storage/storage';
+import { StorageCustomMetadata } from '../../common/storage/types';
+import { FirebaseStorageAccessorFile } from '../../common/storage/driver/accessor';
+/**
+ * Details from the input.
+ */
+export type StoredFileReaderInput = StoragePath;
+/**
+ * Factory function that creates a StoredFileReader from the input details.
+ */
+export type StoredFileReaderFactory = FactoryWithRequiredInput<StoredFileReader, FirebaseStorageAccessorFile>;
+/**
+ * A read-only accessor for file in FirebaseStorage.
+ *
+ * It exposes only read-only methods for accessing details about the file.
+ *
+ * This accessor is generally a server-side only interface.
+ */
+export interface StoredFileReader {
+    /**
+     * The details that this accessor is for.
+     */
+    readonly input: StoredFileReaderInput;
+    /**
+     * Returns details about the path.
+     */
+    readonly getPathDetails: Factory<SlashPathDetails>;
+    /**
+     * Loads the file bytes.
+     */
+    readonly loadFileBytes: FirebaseStorageAccessorFile['getBytes'];
+    /**
+     * Loads the file stream.
+     */
+    readonly loadFileStream: FirebaseStorageAccessorFile['getStream'];
+    /**
+     * Loads the StorageMetadata for this file.
+     */
+    readonly loadFileMetadata: FirebaseStorageAccessorFile['getMetadata'];
+    /**
+     * Loads the custom metadata for this file.
+     */
+    readonly loadCustomMetadata: () => Promise<Maybe<StorageCustomMetadata>>;
+    /**
+     * Copies this file to the specified destination.
+     */
+    readonly copy: Required<FirebaseStorageAccessorFile>['copy'];
+}
+/**
+ * Creates a StoredFileReaderFactory.
+ *
+ * Should generally only be used on the server-side, as copy may not be available on the client-side.
+ */
+export declare function storedFileReaderFactory(): StoredFileReaderFactory;

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

@@ -0,0 +1,20 @@
+import { FirestoreModelId, FirestoreModelKey } from '../../common';
+export type StorageFileId = FirestoreModelId;
+export type StorageFileKey = FirestoreModelKey;
+/**
+ * Arbitrary string that can be used to describe the file's purpose.
+ *
+ * It should be unique between different file types.
+ *
+ * The purpose is generally used while querying for StorageFiles that require processing, but can also be
+ * set on files that do not get processed.
+ *
+ * Can be used for querying.
+ */
+export type StorageFilePurpose = string;
+/**
+ * Arbitrary metadata to attach to the storage file.
+ *
+ * Is serialized directly to/from Firestore, so be mindful of what is stored.
+ */
+export type StorageFileMetadata = Readonly<Record<string, any>>;