@dereekb/dbx-firebase 2.1.0 → 3.0.0

package/lib/firebase/firebase.module.d.ts

@@ -0,0 +1,50 @@
+import { ModuleWithProviders, InjectionToken } from '@angular/core';
+import { FirebaseOptions } from 'firebase/app';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/fire/firestore";
+import * as i2 from "@angular/fire/auth";
+import * as i3 from "@angular/fire/storage";
+import * as i4 from "@angular/fire/functions";
+import * as i5 from "@angular/fire/app";
+/**
+ * Default firebase firestore provider module.
+ */
+export declare class DbxFirebaseDefaultFirestoreProviderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDefaultFirestoreProviderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFirebaseDefaultFirestoreProviderModule, never, [typeof i1.FirestoreModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseDefaultFirestoreProviderModule>;
+}
+/**
+ * Default firebase auth provider module.
+ */
+export declare class DbxFirebaseDefaultAuthProviderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDefaultAuthProviderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFirebaseDefaultAuthProviderModule, never, [typeof i2.AuthModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseDefaultAuthProviderModule>;
+}
+/**
+ * Default firebase storage provider module.
+ */
+export declare class DbxFirebaseDefaultStorageProviderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDefaultStorageProviderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFirebaseDefaultStorageProviderModule, never, [typeof i3.StorageModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseDefaultStorageProviderModule>;
+}
+/**
+ * Default firebase functions provider module.
+ */
+export declare class DbxFirebaseDefaultFunctionsProviderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDefaultFunctionsProviderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFirebaseDefaultFunctionsProviderModule, never, [typeof i4.FunctionsModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseDefaultFunctionsProviderModule>;
+}
+export declare const DBX_FIREBASE_OPTIONS_TOKEN: InjectionToken<unknown>;
+/**
+ * Default provider module.
+ */
+export declare class DbxFirebaseDefaultFirebaseProvidersModule {
+    static forRoot(firebaseOptions: FirebaseOptions): ModuleWithProviders<DbxFirebaseDefaultFirebaseProvidersModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDefaultFirebaseProvidersModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFirebaseDefaultFirebaseProvidersModule, never, [typeof DbxFirebaseDefaultFirestoreProviderModule, typeof DbxFirebaseDefaultAuthProviderModule, typeof DbxFirebaseDefaultStorageProviderModule, typeof DbxFirebaseDefaultFunctionsProviderModule, typeof i5.FirebaseAppModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseDefaultFirebaseProvidersModule>;
+}

package/lib/firebase/index.d.ts

@@ -0,0 +1,4 @@
+export * from './emulators';
+export * from './firebase.module';
+export * from './firebase.emulator.module';
+export * from './options';

package/lib/firebase/options.d.ts

@@ -0,0 +1,6 @@
+import { FirebaseOptions } from "firebase/app";
+import { DbxFirebaseLoginModuleRootConfig } from "../auth/login/firebase.login.module";
+import { DbxFirebaseEmulatorsConfig } from "./emulators";
+export interface DbxFirebaseOptions extends FirebaseOptions, Pick<DbxFirebaseLoginModuleRootConfig, 'enabledLoginMethods'> {
+    emulators: DbxFirebaseEmulatorsConfig;
+}

package/lib/firestore/firebase.firestore.context.service.d.ts

@@ -0,0 +1,11 @@
+import { FirestoreContext } from '@dereekb/firebase';
+import * as i0 from "@angular/core";
+/**
+ * Service that provides access to the app's FirestoreContext.
+ */
+export declare class DbxFirestoreContextService {
+    readonly firestoreContext: FirestoreContext;
+    constructor(firestoreContext: FirestoreContext);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirestoreContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirestoreContextService>;
+}

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

@@ -0,0 +1,5 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Token to access the FirestoreContext value.
+ */
+export declare const DBX_FIRESTORE_CONTEXT_TOKEN: InjectionToken<unknown>;

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

@@ -0,0 +1,17 @@
+import { ModuleWithProviders } from "@angular/core";
+import { FirestoreContext } from "@dereekb/firebase";
+import { ClassLikeType } from "@dereekb/util";
+import * as i0 from "@angular/core";
+export interface DbxFirebaseFirestoreCollectionModuleConfig<T> {
+    appCollectionClass: ClassLikeType<T>;
+    collectionFactory: (context: FirestoreContext) => T;
+}
+/**
+ * Used to initialize the FirestoreCollection for a DbxFirebase app.
+ */
+export declare class DbxFirebaseFirestoreCollectionModule {
+    static forRoot<T>(config: DbxFirebaseFirestoreCollectionModuleConfig<T>): ModuleWithProviders<DbxFirebaseFirestoreCollectionModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseFirestoreCollectionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFirebaseFirestoreCollectionModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseFirestoreCollectionModule>;
+}

package/lib/firestore/index.d.ts

@@ -0,0 +1,3 @@
+export * from './firebase.firestore';
+export * from './firebase.firestore.module';
+export * from './firebase.firestore.context.service';

package/lib/function/firebase.function.module.d.ts

@@ -0,0 +1,24 @@
+import { ModuleWithProviders } from "@angular/core";
+import { Functions } from "@angular/fire/functions";
+import { FirebaseFunctionsConfigMap } from "@dereekb/firebase";
+import { ClassLikeType } from "@dereekb/util";
+import * as i0 from "@angular/core";
+export interface DbxFirebaseFunctionsModuleConfig<T> {
+    functionsGetterToken: ClassLikeType<T>;
+    functionsGetterFactory: (functions: Functions) => T;
+    /**
+     * Optional functions config map to provide.
+     *
+     * If provided, will inject all the types with factory functions so they can be injected into the app.
+     */
+    functionsConfigMap?: FirebaseFunctionsConfigMap<any>;
+}
+/**
+ * Used to initialize the LazyFirebaseFunctions type for a DbxFirebase app.
+ */
+export declare class DbxFirebaseFunctionsModule {
+    static forRoot<T>(config: DbxFirebaseFunctionsModuleConfig<T>): ModuleWithProviders<DbxFirebaseFunctionsModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseFunctionsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFirebaseFunctionsModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseFunctionsModule>;
+}

package/lib/function/index.d.ts

@@ -0,0 +1 @@
+export * from './firebase.function.module';

package/lib/index.d.ts

@@ -1 +1,6 @@
-export declare const test = "";
+export * from './auth';
+export * from './firebase';
+export * from './firestore';
+export * from './function';
+export * from './model';
+export * from './module';

package/lib/model/error.d.ts

@@ -0,0 +1,5 @@
+export declare const DBX_FIREBASE_MODEL_DOES_NOT_EXIST_ERROR = "DOES_NOT_EXIST";
+export declare function modelDoesNotExistError(): {
+    code: string;
+    message: string | undefined;
+};

package/lib/model/index.d.ts

@@ -0,0 +1,4 @@
+export * from './loader';
+export * from './store';
+export * from './error';
+export * from './model.module';

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

@@ -0,0 +1,38 @@
+import { FirestoreItemPageIterationInstance, FirestoreQueryConstraint } from "@dereekb/firebase";
+import { PageListLoadingState } from "@dereekb/rxjs";
+import { Maybe, ArrayOrValue } from "@dereekb/util";
+import { Observable } from "rxjs";
+/**
+ * Abstract type that loads models from a configured collection.
+ */
+export interface DbxFirebaseCollectionLoader<T = any> {
+    readonly constraints$: Observable<Maybe<ArrayOrValue<FirestoreQueryConstraint>>>;
+    readonly firestoreIteration$: Observable<FirestoreItemPageIterationInstance<T>>;
+    readonly pageLoadingState$: Observable<PageListLoadingState<T>>;
+    /**
+     * Maximum number of pages to load from the interation.
+     *
+     * Changing this updates the iteration, but does not reset it.
+     */
+    maxPages: Maybe<number>;
+    /**
+     * Number of items to load per page.
+     *
+     * Changing this will reset the iteration.
+     */
+    itemsPerPage: Maybe<number>;
+    /**
+     * Sets the constraints on the model loader.
+     *
+     * @param constraints
+     */
+    setConstraints(constraints: Maybe<ArrayOrValue<FirestoreQueryConstraint>>): void;
+    /**
+     * Loads more items.
+     */
+    next(): void;
+    /**
+     * Resets/restarts the list.
+     */
+    restart(): void;
+}

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

@@ -0,0 +1,52 @@
+import { PageListLoadingState } from '@dereekb/rxjs';
+import { BehaviorSubject, Subject, Observable } from 'rxjs';
+import { FirebaseQueryItemAccumulator, FirestoreCollection, FirestoreDocument, FirestoreItemPageIterationInstance, FirestoreItemPageIteratorFilter, FirestoreQueryConstraint, IterationQueryDocChangeWatcher } from '@dereekb/firebase';
+import { ArrayOrValue, Destroyable, Initialized, Maybe } from '@dereekb/util';
+import { DbxFirebaseCollectionLoader } from './collection.loader';
+export interface DbxFirebaseCollectionLoaderInstanceInitConfig<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> {
+    collection?: Maybe<FirestoreCollection<T, D>>;
+    maxPages?: Maybe<number>;
+    itemsPerPage?: Maybe<number>;
+    constraints?: Maybe<ArrayOrValue<FirestoreQueryConstraint<T>>>;
+}
+export interface DbxFirebaseCollectionLoaderInstanceData<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> {
+    readonly firestoreIteration$: Observable<FirestoreItemPageIterationInstance<T>>;
+    readonly accumulator$: Observable<FirebaseQueryItemAccumulator<T>>;
+    readonly pageLoadingState$: Observable<PageListLoadingState<T>>;
+}
+/**
+ * DbxFirebaseModelLoader implementation within an instance.
+ */
+export declare class DbxFirebaseCollectionLoaderInstance<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> implements DbxFirebaseCollectionLoader<T>, DbxFirebaseCollectionLoaderInstanceData<T, D>, Initialized, Destroyable {
+    private readonly _initConfig?;
+    protected readonly _collection: BehaviorSubject<Maybe<FirestoreCollection<T, D>>>;
+    protected readonly _maxPages: BehaviorSubject<Maybe<number>>;
+    protected readonly _itemsPerPage: BehaviorSubject<Maybe<number>>;
+    protected readonly _constraints: BehaviorSubject<Maybe<ArrayOrValue<FirestoreQueryConstraint<T>>>>;
+    protected readonly _restart: Subject<void>;
+    private readonly _maxPagesSub;
+    readonly collection$: Observable<Maybe<FirestoreCollection<T, D>>>;
+    readonly constraints$: Observable<Maybe<ArrayOrValue<FirestoreQueryConstraint<T>>>>;
+    readonly iteratorFilter$: Observable<FirestoreItemPageIteratorFilter>;
+    readonly firestoreIteration$: Observable<FirestoreItemPageIterationInstance<T>>;
+    readonly queryChangeWatcher$: Observable<IterationQueryDocChangeWatcher<T>>;
+    readonly accumulator$: Observable<FirebaseQueryItemAccumulator<T>>;
+    readonly pageLoadingState$: Observable<PageListLoadingState<T>>;
+    constructor(_initConfig?: DbxFirebaseCollectionLoaderInstanceInitConfig<T, D> | undefined);
+    init(): void;
+    destroy(): void;
+    get maxPages(): Maybe<number>;
+    set maxPages(maxPages: Maybe<number>);
+    get itemsPerPage(): Maybe<number>;
+    set itemsPerPage(itemsPerPage: Maybe<number>);
+    get constraints(): Maybe<ArrayOrValue<FirestoreQueryConstraint>>;
+    set constraints(constraints: Maybe<ArrayOrValue<FirestoreQueryConstraint>>);
+    get collection(): Maybe<FirestoreCollection<T, D>>;
+    set collection(collection: Maybe<FirestoreCollection<T, D>>);
+    next(): void;
+    restart(): void;
+    setConstraints(constraints: Maybe<ArrayOrValue<FirestoreQueryConstraint>>): void;
+    setCollection(firestoreCollection: Maybe<FirestoreCollection<T, D>>): void;
+}
+export declare function dbxFirebaseCollectionLoaderInstance<T, D extends FirestoreDocument<T> = FirestoreDocument<T>>(config: DbxFirebaseCollectionLoaderInstanceInitConfig<T, D>): DbxFirebaseCollectionLoaderInstance<T, D>;
+export declare function dbxFirebaseCollectionLoaderInstanceWithCollection<T, D extends FirestoreDocument<T> = FirestoreDocument<T>>(collection: Maybe<FirestoreCollection<T, D>>): DbxFirebaseCollectionLoaderInstance<T, D>;

package/lib/model/loader/index.d.ts

@@ -0,0 +1,2 @@
+export * from './collection.loader.instance';
+export * from './collection.loader';

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

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./store/model.store.module";
+export declare class DbxFirebaseModelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFirebaseModelModule, never, never, [typeof i1.DbxFirebaseModelStoreModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseModelModule>;
+}

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

@@ -0,0 +1,13 @@
+export * from './model.store.module';
+export * from './store.collection';
+export * from './store.collection.change.directive';
+export * from './store.collection.change.if.directive';
+export * from './store.collection.directive';
+export * from './store.collection.list.directive';
+export * from './store.document';
+export * from './store.document.auth.directive';
+export * from './store.document.directive';
+export * from './store.document.router.directive';
+export * from './store.subcollection';
+export * from './store.subcollection.document';
+export * from './store.subcollection.rxjs';

package/lib/model/store/model.store.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./store.collection.list.directive";
+import * as i2 from "./store.collection.change.directive";
+import * as i3 from "./store.collection.change.if.directive";
+import * as i4 from "./store.document.router.directive";
+import * as i5 from "./store.document.auth.directive";
+export declare class DbxFirebaseModelStoreModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelStoreModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFirebaseModelStoreModule, [typeof i1.DbxFirebaseCollectionListDirective, typeof i2.DbxFirebaseCollectionChangeDirective, typeof i3.DbxFirebaseCollectionHasChangeDirective, typeof i4.DbxFirebaseDocumentStoreRouteIdDirective, typeof i5.DbxFirebaseDocumentAuthIdDirective], never, [typeof i1.DbxFirebaseCollectionListDirective, typeof i2.DbxFirebaseCollectionChangeDirective, typeof i3.DbxFirebaseCollectionHasChangeDirective, typeof i4.DbxFirebaseDocumentStoreRouteIdDirective, typeof i5.DbxFirebaseDocumentAuthIdDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseModelStoreModule>;
+}

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

@@ -0,0 +1,30 @@
+import { Observable } from 'rxjs';
+import { FirestoreDocument, IterationQueryDocChangeWatcherEvent } from "@dereekb/firebase";
+import { Maybe } from '@dereekb/util';
+import { DbxFirebaseCollectionStore } from "./store.collection";
+import { DbxFirebaseCollectionStoreDirective } from './store.collection.directive';
+import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import * as i0 from "@angular/core";
+/**
+ * Refresh mode
+ */
+export declare type DbxFirebaseCollectionChangeDirectiveMode = 'auto' | 'manual';
+export declare type DbxFirebaseCollectionChangeDirectiveEvent = Pick<IterationQueryDocChangeWatcherEvent<any>, 'time' | 'type'>;
+/**
+ * Used to watch query doc changes and respond to them accordingly.
+ */
+export declare class DbxFirebaseCollectionChangeDirective<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseCollectionStore<T, D> = DbxFirebaseCollectionStore<T, D>> extends AbstractSubscriptionDirective {
+    readonly dbxFirebaseCollectionStoreDirective: DbxFirebaseCollectionStoreDirective<T, D, S>;
+    private _mode;
+    readonly mode$: Observable<DbxFirebaseCollectionChangeDirectiveMode>;
+    readonly event$: Observable<DbxFirebaseCollectionChangeDirectiveEvent>;
+    readonly hasChangeAvailable$: Observable<boolean>;
+    constructor(dbxFirebaseCollectionStoreDirective: DbxFirebaseCollectionStoreDirective<T, D, S>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get mode(): DbxFirebaseCollectionChangeDirectiveMode;
+    set mode(mode: Maybe<DbxFirebaseCollectionChangeDirectiveMode | ''>);
+    restart(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseCollectionChangeDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseCollectionChangeDirective<any, any, any>, "[dbxFirebaseCollectionChange]", never, { "mode": "dbxFirebaseCollectionChange"; }, {}, never>;
+}

package/lib/model/store/store.collection.change.if.directive.d.ts

@@ -0,0 +1,24 @@
+import { OnDestroy, TemplateRef, ViewContainerRef } from '@angular/core';
+import { AbstractIfDirective } from '@dereekb/dbx-core';
+import { Observable } from 'rxjs';
+import { DbxFirebaseCollectionChangeDirective } from './store.collection.change.directive';
+import { IterationQueryDocChangeWatcherChangeType } from '@dereekb/firebase';
+import { Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+export declare type DbxFirebaseCollectionHasChangeDirectiveMode = 'all' | IterationQueryDocChangeWatcherChangeType;
+/**
+ * Structural directive that displays the content when the target change is detected.
+ *
+ * Can specify which changes to appear on.
+ */
+export declare class DbxFirebaseCollectionHasChangeDirective extends AbstractIfDirective implements OnDestroy {
+    readonly directive: DbxFirebaseCollectionChangeDirective<any>;
+    private _mode;
+    readonly show$: Observable<boolean>;
+    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, directive: DbxFirebaseCollectionChangeDirective<any>);
+    get mode(): DbxFirebaseCollectionHasChangeDirectiveMode;
+    set mode(mode: Maybe<DbxFirebaseCollectionHasChangeDirectiveMode | ''>);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseCollectionHasChangeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseCollectionHasChangeDirective, "[dbxFirebaseCollectionHasChange]", never, { "mode": "dbxFirebaseCollectionHasChange"; }, {}, never>;
+}

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

@@ -0,0 +1,47 @@
+import { Observable, Subscription } from 'rxjs';
+import { FirebaseQueryItemAccumulator, FirestoreCollection, FirestoreDocument, FirestoreItemPageIterationInstance, FirestoreQueryConstraint, IterationQueryDocChangeWatcher } from '@dereekb/firebase';
+import { ObservableOrValue, PageListLoadingState } from '@dereekb/rxjs';
+import { ArrayOrValue, Maybe } from '@dereekb/util';
+import { LockSetComponentStore } from '@dereekb/dbx-core';
+import { DbxFirebaseCollectionLoaderInstance, DbxFirebaseCollectionLoaderInstanceData } from '../loader/collection.loader.instance';
+import * as i0 from "@angular/core";
+export interface DbxFirebaseCollectionStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends DbxFirebaseCollectionLoaderInstanceData<T, D> {
+    readonly firestoreCollection$: Observable<Maybe<FirestoreCollection<T, D>>>;
+    readonly loader$: Observable<DbxFirebaseCollectionLoaderInstance<T, D>>;
+    readonly firestoreIteration$: Observable<FirestoreItemPageIterationInstance<T>>;
+    readonly queryChangeWatcher$: Observable<IterationQueryDocChangeWatcher<T>>;
+    readonly accumulator$: Observable<FirebaseQueryItemAccumulator<T>>;
+    readonly pageLoadingState$: Observable<PageListLoadingState<T>>;
+    setMaxPages(observableOrValue: ObservableOrValue<Maybe<number>>): Subscription;
+    setItemsPerPage(observableOrValue: ObservableOrValue<Maybe<number>>): Subscription;
+    setConstraints(observableOrValue: ObservableOrValue<Maybe<ArrayOrValue<FirestoreQueryConstraint<T>>>>): Subscription;
+    next(observableOrValue: ObservableOrValue<void>): void;
+    restart(observableOrValue: ObservableOrValue<void>): void;
+    readonly setFirestoreCollection: (() => void) | ((observableOrValue: ObservableOrValue<Maybe<FirestoreCollection<T, D>>>) => Subscription);
+}
+export interface DbxFirebaseCollectionStoreContextState<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> {
+    readonly firestoreCollection?: Maybe<FirestoreCollection<T, D>>;
+    readonly maxPages?: Maybe<number>;
+    readonly itemsPerPage?: Maybe<number>;
+    readonly constraints?: Maybe<ArrayOrValue<FirestoreQueryConstraint<T>>>;
+}
+/**
+ * Used for storing the state of a Person and related email threads.
+ */
+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 setMaxPages: (observableOrValue: Maybe<number> | Observable<Maybe<number>>) => Subscription;
+    readonly setItemsPerPage: (observableOrValue: Maybe<number> | Observable<Maybe<number>>) => Subscription;
+    readonly setConstraints: (observableOrValue: Maybe<ArrayOrValue<FirestoreQueryConstraint<T>>> | Observable<Maybe<ArrayOrValue<FirestoreQueryConstraint<T>>>>) => Subscription;
+    readonly next: () => void;
+    readonly restart: () => void;
+    readonly currentFirestoreCollection$: Observable<Maybe<FirestoreCollection<T, D>>>;
+    readonly firestoreCollection$: Observable<FirestoreCollection<T, D>>;
+    readonly loader$: Observable<DbxFirebaseCollectionLoaderInstance<T, D>>;
+    readonly firestoreIteration$: Observable<FirestoreItemPageIterationInstance<T>>;
+    readonly queryChangeWatcher$: Observable<IterationQueryDocChangeWatcher<T>>;
+    readonly accumulator$: Observable<FirebaseQueryItemAccumulator<T>>;
+    readonly pageLoadingState$: Observable<PageListLoadingState<T>>;
+    readonly setFirestoreCollection: (() => void) | ((observableOrValue: FirestoreCollection<T, D> | Observable<FirestoreCollection<T, D> | null | undefined> | null | undefined) => Subscription);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxFirebaseCollectionStore<any, any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AbstractDbxFirebaseCollectionStore<any, any, any>>;
+}

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

@@ -0,0 +1,30 @@
+import { Provider, Type } from '@angular/core';
+import { FirestoreDocument, FirestoreQueryConstraint } from "@dereekb/firebase";
+import { Maybe, ArrayOrValue } from '@dereekb/util';
+import { DbxFirebaseCollectionStore } from "./store.collection";
+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, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseCollectionStore<T, D> = DbxFirebaseCollectionStore<T, D>> {
+    readonly store: S;
+    constructor(store: S);
+    readonly pageLoadingState$: import("rxjs").Observable<import("../../../../../../dist/packages/rxjs/src").PageListLoadingState<T>>;
+    set maxPages(maxPages: Maybe<number>);
+    set itemsPerPage(itemsPerPage: Maybe<number>);
+    set constraints(constraints: Maybe<ArrayOrValue<FirestoreQueryConstraint>>);
+    next(): void;
+    restart(): void;
+    setConstraints(constraints: Maybe<ArrayOrValue<FirestoreQueryConstraint>>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseCollectionStoreDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseCollectionStoreDirective<any, any, any>, never, never, { "maxPages": "maxPages"; "itemsPerPage": "itemsPerPage"; "constraints": "constraints"; }, {}, never>;
+}
+/**
+ * Configures providers for a DbxFirebaseCollectionStoreDirective.
+ *
+ * Can optionally also provide the actual store type to include in the providers array so it is instantiated by Angular.
+ *
+ * @param sourceType
+ */
+export declare function provideDbxFirebaseCollectionStoreDirective<S extends DbxFirebaseCollectionStoreDirective<any, any, any>>(sourceType: Type<S>): Provider[];
+export declare function provideDbxFirebaseCollectionStoreDirective<S extends DbxFirebaseCollectionStore<any, any>, C extends DbxFirebaseCollectionStoreDirective<any, any, S> = DbxFirebaseCollectionStoreDirective<any, any, S>>(sourceType: Type<C>, storeType: Type<S>): Provider[];

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

@@ -0,0 +1,13 @@
+import { DbxListViewWrapper } from '@dereekb/dbx-web';
+import { DbxFirebaseCollectionStoreDirective } from './store.collection.directive';
+import * as i0 from "@angular/core";
+/**
+ * Directive that connects a host DbxListView to a DbxFirebaseCollectionStoreDirective to pass data for rendering items from a collection and query parameters.
+ */
+export declare class DbxFirebaseCollectionListDirective<T> {
+    readonly dbxFirebaseCollectionStoreDirective: DbxFirebaseCollectionStoreDirective<T>;
+    readonly dbxListViewWrapper: DbxListViewWrapper<T>;
+    constructor(dbxFirebaseCollectionStoreDirective: DbxFirebaseCollectionStoreDirective<T>, dbxListViewWrapper: DbxListViewWrapper<T>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseCollectionListDirective<any>, [null, { host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseCollectionListDirective<any>, "[dbxFirebaseCollectionList]", never, {}, {}, never>;
+}

package/lib/model/store/store.document.auth.directive.d.ts

@@ -0,0 +1,19 @@
+import { OnInit } from "@angular/core";
+import { FirestoreDocument } from "@dereekb/firebase";
+import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import { DbxFirebaseAuthService } from "../../auth/service/firebase.auth.service";
+import { DbxFirebaseDocumentStoreDirective } from "./store.document.directive";
+import * as i0 from "@angular/core";
+/**
+ * Utility directive for a host DbxFirebaseDocumentStoreDirective that sets the document's ID to match the ID of the current user.
+ *
+ * This is useful for cases where each document is keyed by the user (I.E. implements UserRelatedById).
+ */
+export declare class DbxFirebaseDocumentAuthIdDirective<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends AbstractSubscriptionDirective implements OnInit {
+    readonly dbxFirebaseAuthService: DbxFirebaseAuthService;
+    readonly dbxFirebaseDocumentStoreDirective: DbxFirebaseDocumentStoreDirective<T, D>;
+    constructor(dbxFirebaseAuthService: DbxFirebaseAuthService, dbxFirebaseDocumentStoreDirective: DbxFirebaseDocumentStoreDirective<T, D>);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDocumentAuthIdDirective<any, any>, [null, { host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseDocumentAuthIdDirective<any, any>, "[dbxFirebaseDocumentAuthId]", never, {}, {}, never>;
+}

package/lib/model/store/store.document.d.ts

@@ -0,0 +1,69 @@
+import { Observable, Subscription } from 'rxjs';
+import { DocumentSnapshot, DocumentReference, FirestoreCollection, FirestoreDocument, DocumentDataWithId } from '@dereekb/firebase';
+import { LoadingState, ObservableOrValue } from '@dereekb/rxjs';
+import { Maybe, ModelKey } from '@dereekb/util';
+import { LockSetComponent, LockSetComponentStore } from '@dereekb/dbx-core';
+import * as i0 from "@angular/core";
+export interface DbxFirebaseDocumentStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends LockSetComponent {
+    readonly firestoreCollection$: Observable<FirestoreCollection<T, D>>;
+    readonly currentInputId$: Observable<Maybe<ModelKey>>;
+    readonly inputId$: Observable<ModelKey>;
+    readonly currentInputRef$: Observable<Maybe<DocumentReference<T>>>;
+    readonly inputRef$: Observable<DocumentReference<T>>;
+    readonly currentDocument$: Observable<Maybe<D>>;
+    readonly document$: Observable<D>;
+    readonly id$: Observable<ModelKey>;
+    readonly ref$: Observable<DocumentReference<T>>;
+    readonly documentLoadingState$: Observable<LoadingState<D>>;
+    readonly snapshot$: Observable<DocumentSnapshot<T>>;
+    readonly snapshotLoadingState$: Observable<LoadingState<DocumentSnapshot<T>>>;
+    readonly currentData$: Observable<Maybe<DocumentDataWithId<T>>>;
+    readonly data$: Observable<DocumentDataWithId<T>>;
+    readonly dataLoadingState$: Observable<LoadingState<DocumentDataWithId<T>>>;
+    readonly exists$: Observable<boolean>;
+    setId: (observableOrValue: ObservableOrValue<string>) => Subscription;
+    setRef: (observableOrValue: ObservableOrValue<DocumentReference<T>>) => Subscription;
+    /**
+     * Sets the firestore collection to retrieve document from.
+     */
+    readonly setFirestoreCollection: (() => void) | ((observableOrValue: ObservableOrValue<Maybe<FirestoreCollection<T, D>>>) => Subscription);
+}
+export interface DbxFirebaseDocumentStoreContextState<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> {
+    readonly firestoreCollection?: Maybe<FirestoreCollection<T, D>>;
+    readonly id?: Maybe<ModelKey>;
+    readonly ref?: Maybe<DocumentReference<T>>;
+}
+/**
+ * Used for storing the state of a Person and related email threads.
+ */
+export declare class AbstractDbxFirebaseDocumentStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, C extends DbxFirebaseDocumentStoreContextState<T, D> = DbxFirebaseDocumentStoreContextState<T, D>> extends LockSetComponentStore<C> implements DbxFirebaseDocumentStore<T, D> {
+    readonly currentFirestoreCollection$: Observable<Maybe<FirestoreCollection<T, D>>>;
+    readonly firestoreCollection$: Observable<FirestoreCollection<T, D>>;
+    readonly currentInputId$: Observable<Maybe<ModelKey>>;
+    readonly inputId$: Observable<ModelKey>;
+    readonly currentInputRef$: Observable<Maybe<DocumentReference<T>>>;
+    readonly inputRef$: Observable<DocumentReference<T>>;
+    readonly currentDocument$: Observable<Maybe<D>>;
+    readonly document$: Observable<D>;
+    readonly documentLoadingState$: Observable<LoadingState<D>>;
+    readonly id$: Observable<ModelKey>;
+    readonly ref$: Observable<DocumentReference<T>>;
+    readonly snapshot$: Observable<DocumentSnapshot<T>>;
+    readonly snapshotLoadingState$: Observable<LoadingState<DocumentSnapshot<T>>>;
+    readonly currentData$: Observable<Maybe<DocumentDataWithId<T>>>;
+    readonly data$: Observable<DocumentDataWithId<T>>;
+    readonly dataLoadingState$: Observable<LoadingState<DocumentDataWithId<T>>>;
+    readonly exists$: Observable<boolean>;
+    readonly doesNotExist$: Observable<boolean>;
+    /**
+     * Sets the id of the document to load.
+     */
+    readonly setId: (observableOrValue: string | Observable<string>) => Subscription;
+    /**
+     * Sets the ref of the document to load.
+     */
+    readonly setRef: (observableOrValue: DocumentReference<T> | Observable<DocumentReference<T>>) => Subscription;
+    readonly setFirestoreCollection: (() => void) | ((observableOrValue: Maybe<FirestoreCollection<T, D>> | Observable<Maybe<FirestoreCollection<T, D>>>) => Subscription);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxFirebaseDocumentStore<any, any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AbstractDbxFirebaseDocumentStore<any, any, any>>;
+}

package/lib/model/store/store.document.directive.d.ts

@@ -0,0 +1,34 @@
+import { Provider, Type } from '@angular/core';
+import { DocumentReference, FirestoreDocument } from "@dereekb/firebase";
+import { ModelKey } from '@dereekb/util';
+import { DbxFirebaseDocumentStore } from "./store.document";
+import * as i0 from "@angular/core";
+/**
+ * Abstract directive that contains a DbxFirebaseDocumentStore and provides an interface for communicating with other directives.
+ */
+export declare abstract class DbxFirebaseDocumentStoreDirective<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseDocumentStore<T, D> = DbxFirebaseDocumentStore<T, D>> {
+    readonly store: S;
+    constructor(store: S);
+    readonly exists$: import("rxjs").Observable<boolean>;
+    readonly document$: import("rxjs").Observable<D>;
+    readonly documentLoadingState$: import("rxjs").Observable<import("../../../../../../dist/packages/rxjs/src").LoadingState<D>>;
+    readonly id$: import("rxjs").Observable<string>;
+    readonly ref$: import("rxjs").Observable<DocumentReference<T>>;
+    readonly snapshot$: import("rxjs").Observable<import("@dereekb/firebase").DocumentSnapshot<T>>;
+    readonly snapshotLoadingState$: import("rxjs").Observable<import("../../../../../../dist/packages/rxjs/src").LoadingState<import("@dereekb/firebase").DocumentSnapshot<T>>>;
+    readonly data$: import("rxjs").Observable<import("@dereekb/firebase").DocumentDataWithId<T>>;
+    readonly loadingState$: import("rxjs").Observable<import("../../../../../../dist/packages/rxjs/src").LoadingState<import("@dereekb/firebase").DocumentDataWithId<T>>>;
+    set id(id: ModelKey);
+    set ref(ref: DocumentReference<T>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDocumentStoreDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseDocumentStoreDirective<any, any, any>, never, never, { "id": "id"; "ref": "ref"; }, {}, never>;
+}
+/**
+ * Configures providers for a DbxFirebaseDocumentStoreDirective.
+ *
+ * Can optionally also provide the actual store type to include in the providers array so it is instantiated by Angular.
+ *
+ * @param sourceType
+ */
+export declare function provideDbxFirebaseDocumentStoreDirective<S extends DbxFirebaseDocumentStoreDirective<any, any, any>>(sourceType: Type<S>): Provider[];
+export declare function provideDbxFirebaseDocumentStoreDirective<S extends DbxFirebaseDocumentStore<any, any>, C extends DbxFirebaseDocumentStoreDirective<any, any, S> = DbxFirebaseDocumentStoreDirective<any, any, S>>(sourceType: Type<C>, storeType: Type<S>): Provider[];

package/lib/model/store/store.document.router.directive.d.ts

@@ -0,0 +1,25 @@
+import { Observable } from 'rxjs';
+import { OnDestroy } from '@angular/core';
+import { OnInit } from '@angular/core';
+import { DbxRouterService, AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import { DbxFirebaseDocumentStoreDirective } from './store.document.directive';
+import { ModelKey } from '@dereekb/util';
+import * as i0 from "@angular/core";
+export declare const DBX_FIREBASE_ROUTER_SYNC_DEFAULT_ID_PARAM_KEY = "id";
+/**
+ * Used for synchronizing the document store id to the param of the route.
+ */
+export declare class DbxFirebaseDocumentStoreRouteIdDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+    readonly dbxFirebaseDocumentStoreDirective: DbxFirebaseDocumentStoreDirective<any>;
+    readonly dbxRouterService: DbxRouterService;
+    private _idParamKey;
+    readonly idParamKey$: Observable<string>;
+    readonly idFromParams$: Observable<ModelKey>;
+    constructor(dbxFirebaseDocumentStoreDirective: DbxFirebaseDocumentStoreDirective<any>, dbxRouterService: DbxRouterService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get idParam(): string;
+    set idParam(idParam: string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDocumentStoreRouteIdDirective, [{ host: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseDocumentStoreRouteIdDirective, "[dbxFirebaseDocumentStoreRouteId]", never, { "idParam": "dbxFirebaseDocumentStoreRouteId"; }, {}, never>;
+}