@dereekb/dbx-firebase 12.4.4 → 12.5.0

package/lib/firestore/firebase.firestore.providers.d.ts

@@ -1,5 +1,5 @@
 import { EnvironmentProviders } from '@angular/core';
-import { FirestoreContext, NotificationFirestoreCollections, SystemStateFirestoreCollections } from '@dereekb/firebase';
+import { FirestoreContext, NotificationFirestoreCollections, StorageFileFirestoreCollections, SystemStateFirestoreCollections } from '@dereekb/firebase';
 import { ClassLikeType } from '@dereekb/util';
 /**
  * Provider factory for the SystemStateFirestoreCollections.
@@ -15,6 +15,13 @@ export declare function provideSystemStateFirestoreCollections(appCollection: Sy
  * @returns Provider factory for the NotificationFirestoreCollections.
  */
 export declare function provideNotificationFirestoreCollections(appCollection: NotificationFirestoreCollections): NotificationFirestoreCollections;
+/**
+ * Provider factory for the StorageFileFirestoreCollections.
+ *
+ * @param appCollection The app collection class to use.
+ * @returns Provider factory for the StorageFileFirestoreCollections.
+ */
+export declare function provideStorageFileFirestoreCollections(appCollection: StorageFileFirestoreCollections): StorageFileFirestoreCollections;
 /**
  * Configuration for provideDbxFirestoreCollection().
  */
@@ -39,6 +46,12 @@ export interface ProvideDbxFirebaseFirestoreCollectionConfig<T> {
      * False by default.
      */
     readonly provideNotificationFirestoreCollections?: boolean;
+    /**
+     * Whether or not to provide the StorageFileFirestoreCollections.
+     *
+     * False by default.
+     */
+    readonly provideStorageFileFirestoreCollections?: boolean;
 }
 /**
  * Creates EnvironmentProviders for the DBX_FIRESTORE_CONTEXT_TOKEN, appCollectionClass, and optionally the SystemStateFirestoreCollections and NotificationFirestoreCollections.

package/lib/model/loader/collection.loader.instance.d.ts

@@ -1,10 +1,20 @@
 import { PageListLoadingState, ItemAccumulatorNextPageUntilResultsCountResult } from '@dereekb/rxjs';
 import { BehaviorSubject, Subject, Observable } from 'rxjs';
-import { DocumentDataWithIdAndKey, DocumentReference, FirebaseQueryItemAccumulator, FirebaseQueryItemAccumulatorNextPageUntilResultsCountFunction, FirebaseQuerySnapshotAccumulator, FirestoreCollectionLike, FirestoreDocument, FirestoreItemPageIterationInstance, FirestoreItemPageIteratorFilter, FirestoreQueryConstraint, IterationQueryDocChangeWatcher } from '@dereekb/firebase';
+import { DocumentDataWithIdAndKey, DocumentReference, FirebaseQueryItemAccumulator, FirebaseQueryItemAccumulatorNextPageUntilResultsCountFunction, FirebaseQuerySnapshotAccumulator, FirestoreCollectionLike, FirestoreDocument, FirestoreItemPageIterationInstance, FirestoreItemPageIteratorFilter, FirestoreModelKey, FirestoreQueryConstraint, IterationQueryDocChangeWatcher } from '@dereekb/firebase';
 import { ArrayOrValue, Destroyable, GetterOrValue, Initialized, Maybe, PageNumber } from '@dereekb/util';
 import { DbxFirebaseCollectionLoaderAccessor, DbxFirebaseCollectionLoaderWithAccumulator } from './collection.loader';
+/**
+ * The store mode.
+ *
+ * - query: The store will load documents from a query, using the given collection.
+ * - references: The store will load documents from the input references (keys, refs, etc.).
+ */
+export type DbxFirebaseCollectionMode = 'query' | 'references';
 export interface DbxFirebaseCollectionLoaderInstanceInitConfig<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> {
     readonly collection?: Maybe<FirestoreCollectionLike<T, D>>;
+    readonly collectionMode?: DbxFirebaseCollectionMode;
+    readonly collectionKeys?: Maybe<FirestoreModelKey[]>;
+    readonly collectionRefs?: Maybe<DocumentReference<T>[]>;
     readonly maxPages?: Maybe<number>;
     readonly itemsPerPage?: Maybe<number>;
     readonly constraints?: Maybe<ArrayOrValue<FirestoreQueryConstraint>>;
@@ -22,12 +32,18 @@ export type DbxFirebaseCollectionLoaderInstanceData<T, D extends FirestoreDocume
 export declare class DbxFirebaseCollectionLoaderInstance<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>> implements DbxFirebaseCollectionLoaderWithAccumulator<T>, DbxFirebaseCollectionLoaderInstanceData<T, D>, Initialized, Destroyable {
     private readonly _maxPagesSub;
     protected readonly _collection: BehaviorSubject<Maybe<FirestoreCollectionLike<T, D, import("@dereekb/firebase").LimitedFirestoreDocumentAccessor<T, D>>>>;
+    protected readonly _collectionMode: BehaviorSubject<DbxFirebaseCollectionMode>;
+    protected readonly _collectionRefs: BehaviorSubject<Maybe<DocumentReference<T>[]>>;
     protected readonly _maxPages: BehaviorSubject<Maybe<number>>;
     protected readonly _itemsPerPage: BehaviorSubject<Maybe<number>>;
     protected readonly _constraints: BehaviorSubject<Maybe<ArrayOrValue<FirestoreQueryConstraint<unknown>>>>;
     protected readonly _waitForNonNullConstraints: BehaviorSubject<Maybe<boolean>>;
     protected readonly _restart: Subject<void>;
     readonly collection$: Observable<Maybe<FirestoreCollectionLike<T, D, import("@dereekb/firebase").LimitedFirestoreDocumentAccessor<T, D>>>>;
+    readonly collectionMode$: Observable<DbxFirebaseCollectionMode>;
+    readonly currentCollectionRefs$: Observable<Maybe<DocumentReference<T>[]>>;
+    readonly collectionRefs$: Observable<DocumentReference<T>[]>;
+    readonly collectionKeys$: Observable<string[]>;
     readonly currentConstraints$: Observable<Maybe<ArrayOrValue<FirestoreQueryConstraint<unknown>>>>;
     readonly constraints$: Observable<Maybe<ArrayOrValue<FirestoreQueryConstraint<unknown>>>>;
     readonly iteratorFilter$: Observable<FirestoreItemPageIteratorFilter>;
@@ -60,6 +76,12 @@ export declare class DbxFirebaseCollectionLoaderInstance<T = unknown, D extends
     constructor(initConfig?: DbxFirebaseCollectionLoaderInstanceInitConfig<T, D>);
     init(): void;
     destroy(): void;
+    get collectionMode(): DbxFirebaseCollectionMode;
+    set collectionMode(mode: DbxFirebaseCollectionMode);
+    get collectionKeys(): Maybe<FirestoreModelKey[]>;
+    set collectionKeys(keys: Maybe<FirestoreModelKey[]>);
+    get collectionRefs(): Maybe<DocumentReference<T>[]>;
+    set collectionRefs(refs: Maybe<DocumentReference<T>[]>);
     get maxPages(): Maybe<number>;
     set maxPages(maxPages: Maybe<number>);
     get itemsPerPage(): Maybe<number>;
@@ -72,6 +94,9 @@ export declare class DbxFirebaseCollectionLoaderInstance<T = unknown, D extends
     set collection(collection: Maybe<FirestoreCollectionLike<T, D>>);
     next(): void;
     restart(): void;
+    setCollectionMode(mode: DbxFirebaseCollectionMode): void;
+    setCollectionKeys(keys: Maybe<FirestoreModelKey[]>): void;
+    setCollectionRefs(refs: Maybe<DocumentReference<T>[]>): void;
     setMaxPages(maxPages: Maybe<number>): void;
     setItemsPerPage(itemsPerPage: Maybe<number>): void;
     setConstraints(constraints: Maybe<ArrayOrValue<FirestoreQueryConstraint>>): void;

package/lib/model/modules/store/index.d.ts

@@ -1,5 +1,6 @@
 export * from './model.store.module';
 export * from './store.collection';
+export * from './store.collection.crud';
 export * from './store.collection.change.directive';
 export * from './store.collection.change.if.directive';
 export * from './store.collection.directive';

package/lib/model/modules/store/store.collection.crud.d.ts

@@ -0,0 +1,21 @@
+import { ModelFirebaseCreateFunction, ModelFirebaseCrudFunction, OnCallCreateModelResult } from '@dereekb/firebase';
+import { LoadingState } from '@dereekb/rxjs';
+import { Observable } from 'rxjs';
+import { DbxFirebaseCollectionStore } from './store.collection';
+export type DbxFirebaseCollectionStoreCreateFunction<I, O extends OnCallCreateModelResult = OnCallCreateModelResult> = (params: I) => Observable<LoadingState<O>>;
+/**
+ * Creates a function for a store that DbxFirebaseDocumentStore captures the ModelFirebaseCreateFunction result and sets the key of the created value.
+ *
+ * @param store
+ * @param fn
+ * @returns
+ */
+export declare function firebaseCollectionStoreCreateFunction<I, O extends OnCallCreateModelResult = OnCallCreateModelResult>(store: DbxFirebaseCollectionStore<any, any>, fn: ModelFirebaseCreateFunction<I, O>): DbxFirebaseCollectionStoreCreateFunction<I, O>;
+export type DbxFirebaseCollectionStoreCrudFunction<I, O = void> = (input: I) => Observable<LoadingState<O>>;
+/**
+ * Creates a DbxfirebaseDocumentStoreCrudFunction from the input ModelFirebaseCrudFunction.
+ *
+ * @param fn
+ * @returns
+ */
+export declare function firebaseCollectionStoreCrudFunction<I, O = void>(fn: ModelFirebaseCrudFunction<I, O>): DbxFirebaseCollectionStoreCrudFunction<I, O>;

package/lib/model/modules/store/store.collection.d.ts

@@ -1,13 +1,23 @@
 import { Observable, Subscription } from 'rxjs';
-import { FirebaseQueryItemAccumulator, FirestoreCollectionLike, FirestoreDocument, FirestoreItemPageIterationInstance, FirestoreQueryConstraint, IterationQueryDocChangeWatcher, DocumentDataWithIdAndKey, DocumentReference, FirebaseQuerySnapshotAccumulator, FirebaseQueryItemAccumulatorNextPageUntilResultsCountFunction } from '@dereekb/firebase';
+import { FirebaseQueryItemAccumulator, FirestoreCollectionLike, FirestoreDocument, FirestoreItemPageIterationInstance, FirestoreQueryConstraint, IterationQueryDocChangeWatcher, DocumentDataWithIdAndKey, DocumentReference, FirebaseQuerySnapshotAccumulator, FirebaseQueryItemAccumulatorNextPageUntilResultsCountFunction, FirestoreModelKey } from '@dereekb/firebase';
 import { ObservableOrValue, PageListLoadingState, ItemAccumulatorNextPageUntilResultsCountResult } from '@dereekb/rxjs';
 import { ArrayOrValue, Maybe, PageNumber } from '@dereekb/util';
 import { LockSetComponentStore } from '@dereekb/dbx-core';
-import { DbxFirebaseCollectionLoaderInstance, DbxFirebaseCollectionLoaderInstanceData, DbxFirebaseCollectionLoaderInstanceInitConfig } from '../../loader/collection.loader.instance';
+import { DbxFirebaseCollectionLoaderInstance, DbxFirebaseCollectionLoaderInstanceData, DbxFirebaseCollectionLoaderInstanceInitConfig, DbxFirebaseCollectionMode } from '../../loader/collection.loader.instance';
 import { DbxFirebaseCollectionLoaderAccessorWithAccumulator } from '../../loader/collection.loader';
 import * as i0 from "@angular/core";
 export interface DbxFirebaseCollectionStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends DbxFirebaseCollectionLoaderAccessorWithAccumulator<T>, DbxFirebaseCollectionLoaderInstanceData<T, D> {
+    /**
+     * The current collection that documents are loaded from.
+     */
     readonly firestoreCollection$: Observable<Maybe<FirestoreCollectionLike<T, D>>>;
+    /**
+     * The current store mode.
+     */
+    readonly collectionMode$: Observable<DbxFirebaseCollectionMode>;
+    /**
+     * The loader instance.
+     */
     readonly loader$: Observable<DbxFirebaseCollectionLoaderInstance<T, D>>;
     /**
      * Whether or not the iterator has more pages to load.
@@ -37,6 +47,9 @@ export interface DbxFirebaseCollectionStore<T, D extends FirestoreDocument<T> =
      * Returns all documents data loaded by the accumulator.
      */
     readonly allDocumentData$: Observable<DocumentDataWithIdAndKey<T>[]>;
+    setCollectionMode(observableOrValue: ObservableOrValue<DbxFirebaseCollectionMode>): Subscription;
+    setCollectionKeys(observableOrValue: ObservableOrValue<Maybe<FirestoreModelKey[]>>): Subscription;
+    setCollectionRefs(observableOrValue: ObservableOrValue<Maybe<DocumentReference<T>[]>>): Subscription;
     setMaxPages(observableOrValue: ObservableOrValue<Maybe<number>>): Subscription;
     setItemsPerPage(observableOrValue: ObservableOrValue<Maybe<number>>): Subscription;
     setConstraints(observableOrValue: ObservableOrValue<Maybe<ArrayOrValue<FirestoreQueryConstraint>>>): Subscription;
@@ -49,6 +62,9 @@ export interface DbxFirebaseCollectionStoreContextState<T, D extends FirestoreDo
     readonly firestoreCollection?: Maybe<FirestoreCollectionLike<T, D>>;
 }
 export declare class AbstractDbxFirebaseCollectionStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, C extends DbxFirebaseCollectionStoreContextState<T, D> = DbxFirebaseCollectionStoreContextState<T, D>> extends LockSetComponentStore<C> implements DbxFirebaseCollectionStore<T, D> {
+    readonly setCollectionMode: (observableOrValue: DbxFirebaseCollectionMode | Observable<DbxFirebaseCollectionMode>) => Subscription;
+    readonly setCollectionKeys: (observableOrValue: Maybe<string[]> | Observable<Maybe<string[]>>) => Subscription;
+    readonly setCollectionRefs: (observableOrValue: Maybe<DocumentReference<T>[]> | Observable<Maybe<DocumentReference<T>[]>>) => Subscription;
     readonly setMaxPages: (observableOrValue: Maybe<number> | Observable<Maybe<number>>) => Subscription;
     readonly setItemsPerPage: (observableOrValue: Maybe<number> | Observable<Maybe<number>>) => Subscription;
     readonly setConstraints: (observableOrValue: Maybe<ArrayOrValue<FirestoreQueryConstraint<unknown>>> | Observable<Maybe<ArrayOrValue<FirestoreQueryConstraint<unknown>>>>) => Subscription;
@@ -58,6 +74,7 @@ export declare class AbstractDbxFirebaseCollectionStore<T, D extends FirestoreDo
     readonly currentFirestoreCollection$: Observable<Maybe<FirestoreCollectionLike<T, D>>>;
     readonly firestoreCollection$: Observable<FirestoreCollectionLike<T, D>>;
     readonly loader$: Observable<DbxFirebaseCollectionLoaderInstance<T, D>>;
+    readonly collectionMode$: Observable<DbxFirebaseCollectionMode>;
     readonly constraints$: Observable<Maybe<ArrayOrValue<FirestoreQueryConstraint>>>;
     readonly firestoreIteration$: Observable<FirestoreItemPageIterationInstance<T>>;
     readonly queryChangeWatcher$: Observable<IterationQueryDocChangeWatcher<T>>;

package/lib/model/modules/store/store.collection.directive.d.ts

@@ -1,16 +1,23 @@
 import { OnDestroy, Provider, Type } from '@angular/core';
-import { FirestoreDocument, FirestoreQueryConstraint } from '@dereekb/firebase';
+import { DocumentReference, FirestoreDocument, FirestoreModelKey, FirestoreQueryConstraint } from '@dereekb/firebase';
 import { Maybe, ArrayOrValue } from '@dereekb/util';
 import { DbxFirebaseCollectionStore } from './store.collection';
+import { DbxFirebaseCollectionMode } from '../../loader/collection.loader.instance';
 import * as i0 from "@angular/core";
 /**
  * Abstract directive that contains a DbxFirebaseCollectionStore and provides an interface for communicating with other directives.
  */
 export declare abstract class DbxFirebaseCollectionStoreDirective<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseCollectionStore<T, D> = DbxFirebaseCollectionStore<T, D>> implements OnDestroy {
+    readonly collectionMode: import("@angular/core").ModelSignal<DbxFirebaseCollectionMode>;
+    readonly collectionKeys: import("@angular/core").ModelSignal<Maybe<string[]>>;
+    readonly collectionRefs: import("@angular/core").ModelSignal<Maybe<DocumentReference<T>[]>>;
     readonly maxPages: import("@angular/core").ModelSignal<Maybe<number>>;
     readonly itemsPerPage: import("@angular/core").ModelSignal<Maybe<number>>;
     readonly constraints: import("@angular/core").ModelSignal<Maybe<ArrayOrValue<FirestoreQueryConstraint<unknown>>>>;
     readonly waitForNonNullConstraints: import("@angular/core").ModelSignal<Maybe<boolean>>;
+    private readonly _collectionMode;
+    private readonly _collectionKeys;
+    private readonly _collectionRefs;
     private readonly _maxPages;
     private readonly _itemsPerPage;
     private readonly _constraints;
@@ -26,6 +33,9 @@ export declare abstract class DbxFirebaseCollectionStoreDirective<T = unknown, D
      * Replaces the internal store.
      */
     replaceStore(store: S): void;
+    setCollectionMode(collectionMode: DbxFirebaseCollectionMode): void;
+    setCollectionKeys(collectionKeys: Maybe<FirestoreModelKey[]>): void;
+    setCollectionRefs(collectionRefs: Maybe<DocumentReference<T>[]>): void;
     setMaxPages(maxPages: Maybe<number>): void;
     setItemsPerPage(itemsPerPage: Maybe<number>): void;
     setConstraints(constraints: Maybe<ArrayOrValue<FirestoreQueryConstraint>>): void;
@@ -33,7 +43,7 @@ export declare abstract class DbxFirebaseCollectionStoreDirective<T = unknown, D
     next(): void;
     restart(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseCollectionStoreDirective<any, any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseCollectionStoreDirective<any, any, any>, never, never, { "maxPages": { "alias": "maxPages"; "required": false; "isSignal": true; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; "isSignal": true; }; "constraints": { "alias": "constraints"; "required": false; "isSignal": true; }; "waitForNonNullConstraints": { "alias": "waitForNonNullConstraints"; "required": false; "isSignal": true; }; }, { "maxPages": "maxPagesChange"; "itemsPerPage": "itemsPerPageChange"; "constraints": "constraintsChange"; "waitForNonNullConstraints": "waitForNonNullConstraintsChange"; }, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseCollectionStoreDirective<any, any, any>, never, never, { "collectionMode": { "alias": "collectionMode"; "required": false; "isSignal": true; }; "collectionKeys": { "alias": "collectionKeys"; "required": false; "isSignal": true; }; "collectionRefs": { "alias": "collectionRefs"; "required": false; "isSignal": true; }; "maxPages": { "alias": "maxPages"; "required": false; "isSignal": true; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; "isSignal": true; }; "constraints": { "alias": "constraints"; "required": false; "isSignal": true; }; "waitForNonNullConstraints": { "alias": "waitForNonNullConstraints"; "required": false; "isSignal": true; }; }, { "collectionMode": "collectionModeChange"; "collectionKeys": "collectionKeysChange"; "collectionRefs": "collectionRefsChange"; "maxPages": "maxPagesChange"; "itemsPerPage": "itemsPerPageChange"; "constraints": "constraintsChange"; "waitForNonNullConstraints": "waitForNonNullConstraintsChange"; }, never, never, false, never>;
 }
 /**
  * Configures providers for a DbxFirebaseCollectionStoreDirective.

package/lib/modules/index.d.ts

@@ -1 +1,2 @@
 export * from './notification';
+export * from './storagefile';

package/lib/modules/storagefile/container/index.d.ts

@@ -0,0 +1,6 @@
+export * from './storagefile.upload.action.handler.directive';
+export * from './storagefile.upload.error';
+export * from './storagefile.upload.handler';
+export * from './storagefile.upload.initialize.document.directive';
+export * from './storagefile.upload.store.directive';
+export * from './storagefile.upload.sync.directive';

package/lib/modules/storagefile/container/storagefile.upload.action.handler.directive.d.ts

@@ -0,0 +1,47 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { Maybe } from '@dereekb/util';
+import { DbxFirebaseStorageFileUploadStore } from '../store/storagefile.upload.store';
+import { StorageFileUploadFilesFinalResult, StorageFileUploadHandler } from './storagefile.upload.handler';
+import { DbxActionContextStoreSourceInstance, DbxActionHandlerInstance } from '@dereekb/dbx-core';
+import * as i0 from "@angular/core";
+/**
+ * Connects a DbxFirebaseStorageFileUploadStore to a DbxActionContext, and handles the upload action.
+ */
+export declare class DbxFirebaseStorageFileUploadActionHandlerDirective implements OnInit, OnDestroy {
+    private readonly _triggerSub;
+    private readonly _readySub;
+    private readonly _isWorkingSub;
+    private readonly _progressSub;
+    readonly source: DbxActionContextStoreSourceInstance<File[], StorageFileUploadFilesFinalResult>;
+    readonly uploadStore: DbxFirebaseStorageFileUploadStore;
+    readonly _dbxActionHandlerInstance: DbxActionHandlerInstance<File[], StorageFileUploadFilesFinalResult>;
+    /**
+     * If true, the action will be triggered when files are set.
+     *
+     * Defaults to false.
+     */
+    readonly triggerOnFiles: import("@angular/core").InputSignal<boolean>;
+    readonly triggerOnFiles$: import("rxjs").Observable<boolean>;
+    /**
+     * Uploading of all/any files should be cancelled if any file fails to upload.
+     *
+     * Any file that was successfully uploaded will not be reverted.
+     *
+     * Defaults to false.
+     */
+    readonly cancelUploadsOnUploadError: import("@angular/core").InputSignal<boolean>;
+    /**
+     * The upload should fail if any file fails to upload, rather than if all files fail to upload.
+     *
+     * Defaults to false.
+     */
+    readonly actionFailureOnUploadError: import("@angular/core").InputSignal<boolean>;
+    readonly uploadHandler: import("@angular/core").InputSignal<Maybe<StorageFileUploadHandler>>;
+    protected readonly _uploadHandlerEffect: import("@angular/core").EffectRef;
+    readonly files$: import("rxjs").Observable<File[]>;
+    readonly uploadHandler$: import("rxjs").Observable<Maybe<StorageFileUploadHandler>>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageFileUploadActionHandlerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseStorageFileUploadActionHandlerDirective, "[dbxFirebaseStorageFileUploadActionHandler]", never, { "triggerOnFiles": { "alias": "triggerOnFiles"; "required": false; "isSignal": true; }; "cancelUploadsOnUploadError": { "alias": "cancelUploadsOnUploadError"; "required": false; "isSignal": true; }; "actionFailureOnUploadError": { "alias": "actionFailureOnUploadError"; "required": false; "isSignal": true; }; "uploadHandler": { "alias": "dbxFirebaseStorageFileUploadActionHandler"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/modules/storagefile/container/storagefile.upload.error.d.ts

@@ -0,0 +1,9 @@
+import { BaseError } from 'make-error';
+import { StorageFileUploadFilesFinalResult } from './storagefile.upload.handler';
+/**
+ * Error that is thrown when a single file fails to upload.
+ */
+export declare class StorageFileUploadFilesError extends BaseError {
+    readonly result: StorageFileUploadFilesFinalResult;
+    constructor(result: StorageFileUploadFilesFinalResult);
+}

package/lib/modules/storagefile/container/storagefile.upload.handler.d.ts

@@ -0,0 +1,183 @@
+import { Observable } from 'rxjs';
+import { DbxFirebaseStorageFileUploadStoreFileProgress } from '../store';
+import { DbxFirebaseStorageService } from '../../../storage/firebase.storage.service';
+import { Maybe, PercentNumber, PromiseOrValue } from '@dereekb/util';
+import { FirebaseStorageAccessorFile, StorageCustomMetadata, StoragePathInput, StorageUploadOptions, StorageUploadTask } from '@dereekb/firebase';
+/**
+ * Creates a new observable for uploading a file.
+ */
+export type StorageFileUploadHandlerFunction = (file: File) => Promise<StorageFileUploadHandlerInstance>;
+export interface StorageFileUploadHandlerInstance extends Pick<StorageUploadTask<FirebaseStorageAccessorFile>, 'taskRef' | 'pause' | 'resume' | 'cancel'> {
+    /**
+     * The upload observable.
+     *
+     * Must be subscribed to in order for the upload to begin.
+     */
+    readonly upload: Observable<DbxFirebaseStorageFileUploadStoreFileProgress>;
+}
+/**
+ * Handles uploading files.
+ */
+export interface StorageFileUploadHandler {
+    /**
+     * Uploads a file, and returns the file progress as it is uploading.
+     */
+    readonly uploadFile: StorageFileUploadHandlerFunction;
+}
+/**
+ * Configuration for a single file upload.
+ */
+export interface StorageFileUploadConfig {
+    /**
+     * Path for where to upload the file to
+     */
+    readonly storagePath: StoragePathInput;
+    /**
+     * Upload options for the file.
+     *
+     * Resumable is not supported.
+     */
+    readonly uploadOptions?: StorageFileUploadConfigOptions;
+    /**
+     * Custom metadata for the file.
+     *
+     * Is merged with uploadOptions's metadata.
+     */
+    readonly customMetadata?: StorageCustomMetadata;
+}
+/**
+ * StorageFileUploadConfig upload options.
+ */
+export type StorageFileUploadConfigOptions = Omit<StorageUploadOptions, 'resumable'>;
+/**
+ * Function used to generate file names for the uploaded files.
+ *
+ * If not set, the file name will be used as is.
+ */
+export type StorageFileUploadConfigFactory = (file: File) => PromiseOrValue<StorageFileUploadConfig>;
+/**
+ * Configuration for StorageFileUploadHandler().
+ */
+export interface StorageFileUploadHandlerConfig {
+    readonly storageService: DbxFirebaseStorageService;
+    readonly storageFileUploadConfigFactory: StorageFileUploadConfigFactory;
+}
+/**
+ * Default implementation of StorageFileUploadHandler.
+ */
+export declare function storageFileUploadHandler(config: StorageFileUploadHandlerConfig): StorageFileUploadHandler;
+export interface StorageFileUploadFilesInput {
+    readonly uploadHandler: StorageFileUploadHandler;
+    /**
+     * Files to upload
+     */
+    readonly files: File[];
+    /**
+     * The number of max parallel uploads to perform at a time.
+     *
+     * Defaults to 3
+     */
+    readonly maxParallelUploads?: number;
+}
+export interface StorageFileUploadFilesInstance {
+    /**
+     * Cancels the upload of the remaining files.
+     */
+    cancel(): void;
+    /**
+     * The upload observable.
+     *
+     * Must be subscribed to in order for the upload to begin.
+     */
+    readonly upload: Observable<StorageFileUploadFilesEvent>;
+}
+export interface StorageFileUploadFilesEvent {
+    /**
+     * All files being uploaded
+     */
+    readonly allFiles: File[];
+    /**
+     * Returns true if all files have been uploaded.
+     *
+     * The result value should be available.
+     */
+    readonly isComplete: boolean;
+    /**
+     * Returns true if the upload was canceled.
+     */
+    readonly isCanceled?: Maybe<boolean>;
+    /**
+     * The overall progress of all files being uploaded.
+     */
+    readonly overallProgress: PercentNumber;
+    /**
+     * The upload progress that triggered this event.
+     */
+    readonly uploadProgress?: Maybe<DbxFirebaseStorageFileUploadStoreFileProgress>;
+    /**
+     * The final result.
+     *
+     * Set when the final file has been uploaded or failed.
+     */
+    readonly result?: StorageFileUploadFilesFinalResult;
+    /**
+     * The number of files that are still uploading or queued for upload.
+     */
+    readonly incompleteFileCount: number;
+    /**
+     * The number of files that are active.
+     */
+    readonly activeFileCount: number;
+    /**
+     * The number of files that are done.
+     */
+    readonly doneFileCount: number;
+}
+export interface StorageFileUploadFilesFinalResult {
+    readonly startTime: Date;
+    readonly endTime: Date;
+    readonly fileResults: StorageFileUploadFilesFinalFileResult[];
+    readonly successFileResults: StorageFileUploadFilesFinalFileResult[];
+    readonly errorFileResults: StorageFileUploadFilesFinalFileResult[];
+}
+export interface StorageFileUploadFilesFinalFileResult {
+    /**
+     * The start time of the file upload.
+     */
+    readonly startTime: Date;
+    /**
+     * The end time of the file upload, or when it failed or was canceled.
+     */
+    readonly endTime: Date;
+    /**
+     * The file that was uploaded.
+     */
+    readonly file: File;
+    /**
+     * The accessor file for the file, if available.
+     *
+     * Is generally available if success is true.
+     */
+    readonly fileRef?: Maybe<FirebaseStorageAccessorFile>;
+    /**
+     * True if the file was uploaded successfully.
+     */
+    readonly success: boolean;
+    /**
+     * Error if the file failed to upload.
+     */
+    readonly error?: Maybe<unknown>;
+    /**
+     * True if the file upload was cancelled.
+     */
+    readonly canceled?: Maybe<boolean>;
+}
+/**
+ * Uploads files using the provided upload handler and files.
+ *
+ * An observable is returned that emits the latest file events from any file that is being uploaded.
+ *
+ * @param input
+ * @returns
+ */
+export declare function storageFileUploadFiles(input: StorageFileUploadFilesInput): StorageFileUploadFilesInstance;

package/lib/modules/storagefile/container/storagefile.upload.initialize.document.directive.d.ts

@@ -0,0 +1,14 @@
+import { OnDestroy } from '@angular/core';
+import { DbxFirebaseStorageFileUploadStore, StorageFileDocumentStore } from '../store';
+import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import * as i0 from "@angular/core";
+/**
+ * Directive that passes the upload result to a StorageFileDocumentStore to initialize the document immediately.
+ */
+export declare class DbxFirebaseStorageFileUploadInitializeDocumentDirective extends AbstractSubscriptionDirective implements OnDestroy {
+    readonly uploadStore: DbxFirebaseStorageFileUploadStore;
+    readonly storageFileDocumentStore: StorageFileDocumentStore;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageFileUploadInitializeDocumentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseStorageFileUploadInitializeDocumentDirective, "[dbxFirebaseStorageFileUploadInitializeDocument]", ["dbxFirebaseStorageFileUploadInitializeDocument"], {}, {}, never, never, true, never>;
+}

package/lib/modules/storagefile/container/storagefile.upload.store.directive.d.ts

@@ -0,0 +1,20 @@
+import { OnDestroy } from '@angular/core';
+import { DbxFirebaseStorageFileUploadStore } from '../store';
+import { ArrayOrValue, Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+/**
+ * Directive that provides a DbxFirebaseStorageFileUploadStore, and sync's the inputs to the store.
+ */
+export declare class DbxFirebaseStorageFileUploadStoreDirective implements OnDestroy {
+    private readonly _allowedSub;
+    private readonly _multiSub;
+    readonly uploadStore: DbxFirebaseStorageFileUploadStore;
+    readonly multipleUpload: import("@angular/core").InputSignal<Maybe<boolean>>;
+    readonly fileTypesAccepted: import("@angular/core").InputSignal<Maybe<ArrayOrValue<string>>>;
+    readonly fileTypesAccepted$: import("rxjs").Observable<Maybe<ArrayOrValue<string>>>;
+    readonly isMultiUploadAllowed$: import("rxjs").Observable<Maybe<boolean>>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageFileUploadStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseStorageFileUploadStoreDirective, "[dbxFirebaseStorageFileUploadStore]", ["dbxFirebaseStorageFileUploadStore"], { "multipleUpload": { "alias": "multipleUpload"; "required": false; "isSignal": true; }; "fileTypesAccepted": { "alias": "fileTypesAccepted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/modules/storagefile/container/storagefile.upload.sync.directive.d.ts

@@ -0,0 +1,18 @@
+import { OnDestroy } from '@angular/core';
+import { DbxFirebaseStorageFileUploadStore } from '../store';
+import { DbxFileUploadComponent } from '@dereekb/dbx-web';
+import * as i0 from "@angular/core";
+/**
+ * Directive that syncs a DbxFirebaseStorageFileUploadStore's configuration to a DbxFileUploadComponent.
+ */
+export declare class DbxFirebaseStorageFileUploadSyncDirective implements OnDestroy {
+    private readonly _allowedSub;
+    private readonly _multiSub;
+    private readonly _filesSub;
+    readonly uploadStore: DbxFirebaseStorageFileUploadStore;
+    readonly uploadComponent: DbxFileUploadComponent;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageFileUploadSyncDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseStorageFileUploadSyncDirective, "[dbxFirebaseStorageFileUploadSync]", ["dbxFirebaseStorageFileUploadSync"], {}, {}, never, never, true, never>;
+}

package/lib/modules/storagefile/index.d.ts

@@ -0,0 +1,3 @@
+export * from './container';
+export * from './store';
+export * from './storagefile.upload.module';

package/lib/modules/storagefile/storagefile.upload.module.d.ts

@@ -0,0 +1,29 @@
+import { DbxActionLoadingContextDirective, DbxActionModule, DbxActionSnackbarErrorDirective, DbxFileUploadComponent, DbxFileUploadActionSyncDirective, DbxLoadingComponent } from '@dereekb/dbx-web';
+import { DbxFirebaseStorageFileUploadActionHandlerDirective, DbxFirebaseStorageFileUploadStoreDirective, DbxFirebaseStorageFileUploadSyncDirective, DbxFirebaseStorageFileUploadInitializeDocumentDirective } from './container';
+import { DbxFirebaseStorageFileDocumentStoreDirective } from './store/storagefile.document.store.directive';
+import { DbxFirebaseStorageFileCollectionStoreDirective } from './store';
+import * as i0 from "@angular/core";
+import * as i1 from "@dereekb/dbx-web";
+import * as i2 from "./container/storagefile.upload.action.handler.directive";
+import * as i3 from "./container/storagefile.upload.store.directive";
+import * as i4 from "./container/storagefile.upload.sync.directive";
+import * as i5 from "./container/storagefile.upload.initialize.document.directive";
+import * as i6 from "./store/storagefile.collection.store.directive";
+import * as i7 from "./store/storagefile.document.store.directive";
+export declare const importsAndExports: (typeof DbxActionModule | typeof DbxFirebaseStorageFileCollectionStoreDirective | typeof DbxFirebaseStorageFileDocumentStoreDirective | typeof DbxFirebaseStorageFileUploadActionHandlerDirective | typeof DbxFirebaseStorageFileUploadInitializeDocumentDirective | typeof DbxFirebaseStorageFileUploadStoreDirective | typeof DbxFirebaseStorageFileUploadSyncDirective | typeof DbxFileUploadComponent | typeof DbxLoadingComponent | typeof DbxActionLoadingContextDirective | typeof DbxActionSnackbarErrorDirective | typeof DbxFileUploadActionSyncDirective)[];
+/**
+ * Convenience module for importing various modules/components that are relevant to the storage file upload feature.
+ *
+ * - DbxActionModule
+ * - DbxFileUploadComponent
+ * - DbxFirebaseStorageFileUploadActionHandlerDirective
+ * - DbxFirebaseStorageFileUploadStoreDirective
+ * - DbxFirebaseStorageFileUploadSyncDirective
+ * - DbxFirebaseStorageFileUploadInitializeDocumentDirective
+ * - DbxFirebaseStorageFileUploadStore
+ */
+export declare class DbxFirebaseStorageFileUploadModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageFileUploadModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFirebaseStorageFileUploadModule, never, [typeof i1.DbxActionModule, typeof i1.DbxLoadingComponent, typeof i1.DbxActionLoadingContextDirective, typeof i1.DbxActionSnackbarErrorDirective, typeof i1.DbxFileUploadComponent, typeof i1.DbxFileUploadActionSyncDirective, typeof i2.DbxFirebaseStorageFileUploadActionHandlerDirective, typeof i3.DbxFirebaseStorageFileUploadStoreDirective, typeof i4.DbxFirebaseStorageFileUploadSyncDirective, typeof i5.DbxFirebaseStorageFileUploadInitializeDocumentDirective, typeof i6.DbxFirebaseStorageFileCollectionStoreDirective, typeof i7.DbxFirebaseStorageFileDocumentStoreDirective], [typeof i1.DbxActionModule, typeof i1.DbxLoadingComponent, typeof i1.DbxActionLoadingContextDirective, typeof i1.DbxActionSnackbarErrorDirective, typeof i1.DbxFileUploadComponent, typeof i1.DbxFileUploadActionSyncDirective, typeof i2.DbxFirebaseStorageFileUploadActionHandlerDirective, typeof i3.DbxFirebaseStorageFileUploadStoreDirective, typeof i4.DbxFirebaseStorageFileUploadSyncDirective, typeof i5.DbxFirebaseStorageFileUploadInitializeDocumentDirective, typeof i6.DbxFirebaseStorageFileCollectionStoreDirective, typeof i7.DbxFirebaseStorageFileDocumentStoreDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseStorageFileUploadModule>;
+}

package/lib/modules/storagefile/store/index.d.ts

@@ -0,0 +1,5 @@
+export * from './storagefile.collection.store';
+export * from './storagefile.collection.store.directive';
+export * from './storagefile.document.store';
+export * from './storagefile.document.store.directive';
+export * from './storagefile.upload.store';

package/lib/modules/storagefile/store/storagefile.collection.store.d.ts

@@ -0,0 +1,10 @@
+import { AbstractDbxFirebaseCollectionStore } from '../../../model/modules/store';
+import { StorageFileFirestoreCollections, StorageFile, StorageFileDocument, StorageFileFunctions } from '@dereekb/firebase';
+import * as i0 from "@angular/core";
+export declare class StorageFileCollectionStore extends AbstractDbxFirebaseCollectionStore<StorageFile, StorageFileDocument> {
+    readonly storageFileFunctions: StorageFileFunctions;
+    constructor(collections: StorageFileFirestoreCollections);
+    readonly initializeAllStorageFilesFromUpload: import("../../../model/modules/store").DbxFirebaseCollectionStoreCreateFunction<import("@dereekb/firebase").InitializeAllStorageFilesFromUploadsParams, import("@dereekb/firebase").InitializeAllStorageFilesFromUploadsResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageFileCollectionStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageFileCollectionStore>;
+}

package/lib/modules/storagefile/store/storagefile.collection.store.directive.d.ts

@@ -0,0 +1,9 @@
+import { DbxFirebaseCollectionStoreDirective } from '../../../model/modules/store';
+import { StorageFileCollectionStore } from './storagefile.collection.store';
+import { StorageFile, StorageFileDocument } from '@dereekb/firebase';
+import * as i0 from "@angular/core";
+export declare class DbxFirebaseStorageFileCollectionStoreDirective extends DbxFirebaseCollectionStoreDirective<StorageFile, StorageFileDocument, StorageFileCollectionStore> {
+    constructor(store: StorageFileCollectionStore);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageFileCollectionStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseStorageFileCollectionStoreDirective, "[dbxFirebaseStorageFileCollection]", never, {}, {}, never, never, true, never>;
+}

package/lib/modules/storagefile/store/storagefile.document.store.d.ts

@@ -0,0 +1,15 @@
+import { AbstractDbxFirebaseDocumentStore } from '../../../model/modules/store';
+import { StorageFile, StorageFileDocument, StorageFileFunctions } from '@dereekb/firebase';
+import * as i0 from "@angular/core";
+export declare class StorageFileDocumentStore extends AbstractDbxFirebaseDocumentStore<StorageFile, StorageFileDocument> {
+    readonly storageFileFunctions: StorageFileFunctions;
+    constructor();
+    readonly createStorageFileFromUpload: import("../../../model/modules/store").DbxFirebaseDocumentStoreCreateFunction<import("@dereekb/firebase").CreateStorageFileParams, import("@dereekb/firebase").OnCallCreateModelResult>;
+    readonly initializeStorageFileFromUpload: import("../../../model/modules/store").DbxFirebaseDocumentStoreCreateFunction<import("@dereekb/firebase").InitializeStorageFileFromUploadParams, import("@dereekb/firebase").OnCallCreateModelResult>;
+    readonly initializeAllStorageFilesFromUpload: import("../../../model/modules/store").DbxFirebaseDocumentStoreCrudFunction<import("@dereekb/firebase").InitializeAllStorageFilesFromUploadsParams, import("@dereekb/firebase").InitializeAllStorageFilesFromUploadsResult>;
+    readonly updateStorageFile: import("../../../model/modules/store").DbxFirebaseDocumentStoreFunction<import("@dereekb/firebase").UpdateStorageFileParams, void>;
+    readonly processStorageFile: import("../../../model/modules/store").DbxFirebaseDocumentStoreFunction<import("@dereekb/firebase").ProcessStorageFileParams, import("@dereekb/firebase").ProcessStorageFileResult>;
+    readonly deleteStorageFile: import("../../../model/modules/store").DbxFirebaseDocumentStoreFunction<import("@dereekb/firebase").DeleteStorageFileParams, void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageFileDocumentStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageFileDocumentStore>;
+}