@dereekb/dbx-firebase 12.6.21 → 13.0.0

package/types/dereekb-dbx-firebase.d.ts

@@ -0,0 +1,4304 @@
+import { DbxAnalyticsUserProperties, DbxAnalyticsUserSource, DbxAnalyticsUser, DbxAnalyticsService } from '@dereekb/dbx-analytics';
+import * as _dereekb_util from '@dereekb/util';
+import { Maybe, ISO8601DateString, AuthRoleSet, AuthRoleClaimsService, AuthClaimsObject, AuthClaims, FactoryWithRequiredInput, Initialized, Destroyable, ArrayOrValue, LabelRef, ClassLikeType, PageNumber, GetterOrValue, IterableOrValue, SetIncludesMode, ModelKey, ClassType, MapFunction, PartialOnKeys, UnixDateTimeSecondsNumber, ContentTypeMimeType, Milliseconds, Seconds, DateOrUnixDateTimeSecondsNumber, PercentDecimal, PercentNumber, PromiseOrValue } from '@dereekb/util';
+import { DbxAuthService, AuthUserState, AuthUserIdentifier, NoAuthUserIdentifier, DbxInjectionContext, ClickableAnchor, AbstractForwardDbxInjectionContextDirective, DbxActionSuccessHandlerFunction, DbxInjectionComponentConfig, ClickableUrl, IconAndTitle, SegueRef, ClickableAnchorLinkSegueRef, LockSetComponent, DbxButtonDisplay, DbxRouteModelIdDirectiveDelegate, DbxRouteModelKeyDirectiveDelegate, LockSetComponentStore, AbstractIfDirective, StorageAccessor, DbxActionContextStoreSourceInstance, DbxActionHandlerInstance, SimpleStorageAccessorFactory, DbxRouteParamReader, DbxRouterService } from '@dereekb/dbx-core';
+import { Auth, User as User$1, IdTokenResult, ParsedToken, UserCredential, AuthProvider, PopupRedirectResolver } from '@angular/fire/auth';
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject, Subject, OperatorFunction, Subscription } from 'rxjs';
+import * as _dereekb_firebase from '@dereekb/firebase';
+import { FirebaseAuthToken, FirebaseAuthContextInfo, FirebaseDevelopmentFunctions, ScheduledFunctionDevelopmentFirebaseFunctionListEntry, FirestoreContext, NotificationFirestoreCollections, StorageFileFirestoreCollections, SystemStateFirestoreCollections, FirebaseFunctionsMap, FirebaseFunctionsConfigMap, FirestoreQueryConstraint, FirestoreItemPageIterationInstance, DocumentDataWithIdAndKey, IterationQueryDocChangeWatcher, FirebaseQuerySnapshotAccumulator, FirebaseQueryItemAccumulator, FirebaseQueryItemAccumulatorNextPageUntilResultsCountFunction, IterationQueryDocChangeWatcherEvent, FirestoreDocument, FirestoreCollectionLike, FirestoreModelKey, DocumentReference, FirestoreItemPageIteratorFilter, FirestoreModelId, DocumentSnapshot, FirestoreDocumentAccessor, LimitedFirestoreDocumentAccessor, FirestoreModelType, FirestoreDocumentData, FirestoreAccessorStreamMode, SnapshotOptions, FirebasePermissionErrorContext, InModelContextFirebaseModelService, InContextFirebaseModelsService, FirebaseModelsService, FirestoreModelIdentityTypeMap, FirestoreModelIdentity, FirestoreCollectionType, FirestoreCollection, FlatFirestoreModelKey, TwoWayFlatFirestoreModelKey, FirestoreModelCollectionAndIdPair, FirestoreModelCollectionAndIdPairObject, IterationQueryDocChangeWatcherChangeType, OnCallCreateModelResult, ModelFirebaseCreateFunction, ModelFirebaseCrudFunction, TargetModelParams, InferredTargetModelParams, ModelFirebaseDeleteFunction, ModelFirebaseReadFunction, ModelFirebaseUpdateFunction, FirestoreCollectionWithParentFactory, FirestoreCollectionGroup, SystemState, SystemStateDocument, SystemStateStoredData, SystemStateTypeIdentifier, AppNotificationTemplateTypeInfoRecordService, NotificationItemMetadata, NotificationItem, NotificationItemSubjectMessagePair, NotificationId, Notification, NotificationBox, NotificationDocument, NotificationBoxDocument, NotificationFunctions, NotificationSummary, NotificationSummaryDocument, UnreadNotificationItemsResult, NotificationUser, NotificationUserDocument, NotificationTemplateType, NotificationTemplateTypeInfo, FirebaseAuthUserId, StorageFileId, StorageFileSignedDownloadUrl, FirestoreModelIdInput, StorageFileFunctions, StorageFileKey, DownloadStorageFileParams, DownloadStorageFileResult, StorageFileDownloadUrl, StoragePathInput, FirebaseStorageAccessorFile, StorageFile, StorageFileDocument, StorageFileGroup, StorageFileGroupDocument, FirebaseStorageAccessor, FirebaseStorageContext, FirebaseStorageAccessorFolder, StorageUploadTask, StorageUploadOptions, StorageCustomMetadata, FirebaseStorageContextFactoryConfig } from '@dereekb/firebase';
+import { UserInfo, User, IdTokenResult as IdTokenResult$1 } from 'firebase/auth';
+import * as i0 from '@angular/core';
+import { EnvironmentProviders, Type, InjectionToken, OnInit, Component, EventEmitter, Injector, AfterViewInit, ElementRef, Signal, Provider, PipeTransform } from '@angular/core';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import * as _dereekb_dbx_form from '@dereekb/dbx-form';
+import { TextPasswordFieldPasswordParameters, AbstractSyncFormlyFormDirective, AbstractConfigAsyncFormlyFormDirective, DefaultUsernameLoginFieldsValue, TextPasswordFieldConfig, SourceSelectLoadSource } from '@dereekb/dbx-form';
+import * as _firebase_auth from '@firebase/auth';
+import * as _dereekb_dbx_firebase from '@dereekb/dbx-firebase';
+import * as _dereekb_rxjs from '@dereekb/rxjs';
+import { WorkUsingContext, WorkUsingObservable, ObservableOrValue, IsModifiedFunction, PageListLoadingState, ItemAccumulatorNextPageUntilResultsCountResult, SubscriptionObject, ObservableDecisionFunction, ListLoadingState, LoadingState, MaybeObservableOrValue, SwitchMapToDefaultFilterFunction, MaybeObservableOrValueGetter } from '@dereekb/rxjs';
+import * as dist_packages_dbx_form_types_dereekb_dbx_form from 'dist/packages/dbx-form/types/dereekb-dbx-form';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import * as i1 from '@dereekb/dbx-web';
+import { DbxWidgetEntry, DbxPopupService, DbxWidgetService, DbxWidgetType, TwoColumnsContextStore, AbstractPopupDirective, DbxPopupKey, AbstractDbxSelectionListWrapperDirective, AbstractDbxSelectionListViewDirective, DbxSelectionValueListViewConfig, DbxValueAsListItem, AbstractDbxValueListViewItemComponent, DbxModelTypesService, DbxModelTypeInfo, DbxModelTypesMap, DbxModelTrackerService, AnchorForValueFunction, AbstractPopoverDirective, DbxPopoverService, DbxPopoverKey, AbstractPopoverRefDirective, DbxPopoverConfigSizing, DbxButtonStyle, DownloadTextContent, DbxModelObjectStateService, DbxListViewWrapper, DbxWidgetViewComponentConfig, AbstractDbxWidgetComponent, DbxWebFilePreviewService, DbxActionDialogFunction, FileAcceptFilterTypeString, DbxFileUploadComponent, DbxActionModule, DbxLoadingComponent, DbxActionSnackbarErrorDirective, DbxActionLoadingContextDirective, DbxFileUploadActionSyncDirective } from '@dereekb/dbx-web';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { NgPopoverRef } from 'ng-overlay-container';
+import { AppCheckOptions } from 'firebase/app-check';
+import { PersistentCacheSettings } from 'firebase/firestore';
+import { FirebaseOptions } from 'firebase/app';
+import { Functions } from '@angular/fire/functions';
+import { GrantedRole, GrantedRoleMapReader, GrantedRoleMap, GrantedRoleTruthMapObject, GrantedRoleTruthMap } from '@dereekb/model';
+import { ComponentStore } from '@ngrx/component-store';
+import * as dist_packages_dbx_core_types_dereekb_dbx_core from 'dist/packages/dbx-core/types/dereekb-dbx-core';
+import { MatDialog, MatDialogRef } from '@angular/material/dialog';
+import { BaseError } from 'make-error';
+import { FirebaseApp } from '@angular/fire/app';
+
+type AuthUserInfo = Omit<UserInfo, 'providerId'> & {
+    /**
+     * The creation time of the user's account.
+     */
+    readonly creationTime?: Maybe<ISO8601DateString>;
+    /**
+     * The last time the user signed in and recieved a refresh token.
+     */
+    readonly lastSignInTime?: Maybe<ISO8601DateString>;
+};
+declare function authUserInfoFromAuthUser(user: User): AuthUserInfo;
+declare function firebaseAuthTokenFromUser(user: User): FirebaseAuthToken;
+
+/**
+ * Returns an observable that returns the state of the
+ */
+type AuthUserStateObsFunction = (dbxFirebaseAuthService: DbxFirebaseAuthService) => Observable<AuthUserState>;
+declare abstract class DbxFirebaseAuthServiceDelegate {
+    readonly fullControlOfAuthUserState?: boolean;
+    abstract authUserStateObs: AuthUserStateObsFunction;
+    abstract authRolesObs(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<AuthRoleSet>;
+    abstract isOnboarded(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<boolean>;
+    /**
+     * Whether or not the input roles imply the admin priviledges.
+     */
+    abstract isAdminInAuthRoleSet(authRoleSet: AuthRoleSet): boolean;
+    abstract authRoleClaimsService?: Maybe<AuthRoleClaimsService<AuthClaimsObject>>;
+}
+declare const DEFAULT_DBX_FIREBASE_AUTH_SERVICE_DELEGATE: DbxFirebaseAuthServiceDelegate;
+declare class DbxFirebaseAuthService implements DbxAuthService {
+    readonly firebaseAuth: Auth;
+    readonly delegate: DbxFirebaseAuthServiceDelegate;
+    readonly _authState$: Observable<Maybe<User$1>>;
+    readonly currentAuthUser$: Observable<Maybe<User$1>>;
+    readonly currentAuthUserInfo$: Observable<Maybe<AuthUserInfo>>;
+    readonly authUser$: Observable<User$1>;
+    readonly authUserInfo$: Observable<AuthUserInfo>;
+    readonly hasAuthUser$: Observable<boolean>;
+    readonly isAnonymousUser$: Observable<boolean>;
+    readonly isNotAnonymousUser$: Observable<boolean>;
+    readonly isLoggedIn$: Observable<boolean>;
+    readonly isNotLoggedIn$: Observable<boolean>;
+    readonly onLogIn$: Observable<void>;
+    readonly onLogOut$: Observable<void>;
+    readonly currentUid$: Observable<Maybe<AuthUserIdentifier>>;
+    readonly uid$: Observable<AuthUserIdentifier | NoAuthUserIdentifier>;
+    /**
+     * Alias for uid$
+     */
+    readonly userIdentifier$: Observable<AuthUserIdentifier | NoAuthUserIdentifier>;
+    readonly currentIdTokenString$: Observable<Maybe<string>>;
+    readonly idTokenString$: Observable<string>;
+    readonly currentIdTokenResult$: Observable<Maybe<IdTokenResult>>;
+    readonly idTokenResult$: Observable<IdTokenResult>;
+    readonly currentClaims$: Observable<Maybe<ParsedToken>>;
+    readonly claims$: Observable<ParsedToken>;
+    readonly currentAuthContextInfo$: Observable<Maybe<DbxFirebaseAuthContextInfo>>;
+    readonly authContextInfo$: Observable<Maybe<DbxFirebaseAuthContextInfo>>;
+    readonly authUserState$: Observable<AuthUserState>;
+    readonly authRoles$: Observable<AuthRoleSet>;
+    readonly isOnboarded$: Observable<boolean>;
+    private _authRoleClaimsService?;
+    readonly isAdminInAuthRoleSet: (authRoleSet: AuthRoleSet) => boolean;
+    refreshToken(): Promise<IdTokenResult>;
+    rolesForClaims<T extends AuthClaimsObject = AuthClaimsObject>(claims: AuthClaims<T>): AuthRoleSet;
+    getAuthContextInfo(): Promise<Maybe<DbxFirebaseAuthContextInfo>>;
+    loadAuthContextInfoForUser(user: Maybe<User$1>): Promise<Maybe<DbxFirebaseAuthContextInfo>>;
+    logInWithGoogle(): Promise<UserCredential>;
+    logInWithFacebook(): Promise<UserCredential>;
+    logInWithTwitter(): Promise<UserCredential>;
+    logInWithGithub(): Promise<UserCredential>;
+    logInWithApple(): Promise<UserCredential>;
+    logInWithMicrosoft(): Promise<UserCredential>;
+    logInWithPhone(): Promise<UserCredential>;
+    logInWithPopup(provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<UserCredential>;
+    registerWithEmailAndPassword(email: string, password: string): Promise<UserCredential>;
+    sendPasswordResetEmail(email: string): Promise<void>;
+    logInWithEmailAndPassword(email: string, password: string): Promise<UserCredential>;
+    logInAsAnonymous(): Promise<UserCredential>;
+    logOut(): Promise<void>;
+    reauthenticateWithPopup(provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<UserCredential>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseAuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseAuthService>;
+}
+/**
+ * FirebaseAuthContextInfo implementation from DbxFirebaseAuthService.
+ */
+interface DbxFirebaseAuthContextInfo extends FirebaseAuthContextInfo {
+    readonly service: DbxFirebaseAuthService;
+    readonly user: User$1;
+    readonly jwtToken: IdTokenResult;
+}
+/**
+ * Creates a new DbxFirebaseAuthContextInfo instance.
+ *
+ * @param service
+ * @param user
+ * @param jwtToken
+ * @returns
+ */
+declare function dbxFirebaseAuthContextInfo(service: DbxFirebaseAuthService, user: User$1, jwtToken: IdTokenResult): DbxFirebaseAuthContextInfo;
+
+type DbxFirebaseAnalyticsUserPropertiesFactory = FactoryWithRequiredInput<Observable<DbxAnalyticsUserProperties>, AuthUserInfo>;
+declare function readDbxAnalyticsUserPropertiesFromAuthUserInfo(user: AuthUserInfo): DbxAnalyticsUserProperties;
+declare const DEFAULT_DBX_FIREBASE_ANALYTICS_USER_PROPERTIES_FACTORY: DbxFirebaseAnalyticsUserPropertiesFactory;
+/**
+ * DbxAnalyticsUserSource implementation that uses the DbxFirebaseAuthService.
+ */
+declare class DbxFirebaseAnalyticsUserSource implements DbxAnalyticsUserSource {
+    readonly dbxFirebaseAuthService: DbxFirebaseAuthService;
+    private _userPropertiesFactory;
+    readonly analyticsUser$: Observable<Maybe<DbxAnalyticsUser>>;
+    get userPropertiesFactory(): DbxFirebaseAnalyticsUserPropertiesFactory;
+    set userPropertiesFactory(userPropertiesFactory: DbxFirebaseAnalyticsUserPropertiesFactory);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseAnalyticsUserSource, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseAnalyticsUserSource>;
+}
+
+/**
+ * Service that listens for DbxFirebaseAuthService changes and emits them a user events.
+ */
+declare class DbxFirebaseAnalyticsUserEventsListenerService implements Initialized, Destroyable {
+    readonly dbxFirebaseAuthService: DbxFirebaseAuthService;
+    readonly dbxFirebaseAnalyticsUserSource: DbxFirebaseAnalyticsUserSource;
+    readonly dbxAnalyticsService: DbxAnalyticsService;
+    private readonly _loginSub;
+    private readonly _logoutSub;
+    init(): void;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseAnalyticsUserEventsListenerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseAnalyticsUserEventsListenerService>;
+}
+
+/**
+ * Creates a EnvironmentProviders that provides a DbxFirebaseAnalyticsUserEventsListenerService and initialize it when the app is initialized.
+ *
+ * @returns EnvironmentProviders
+ */
+declare function provideDbxFirebaseAnalyticsUserEventsListenerService(): EnvironmentProviders;
+
+/**
+ * Enables debug token generation for AppCheck by setting FIREBASE_APPCHECK_DEBUG_TOKEN in the browser's self/window.
+ *
+ * https://firebase.google.com/docs/app-check/web/debug-provider
+ *
+ * @param enable
+ */
+declare function enableAppCheckDebugTokenGeneration(enable?: boolean): void;
+
+/**
+ * HTTP Interceptor that sets the X-Firebase-AppCheck for any requests to the routes configured in DbxFirebaseEnvironmentOptions.
+ */
+declare class DbxFirebaseAppCheckHttpInterceptor implements HttpInterceptor {
+    private appCheck;
+    private _appCheckRoutes;
+    private _isEnabled;
+    intercept(req: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    private matchesAnyRoute;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseAppCheckHttpInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseAppCheckHttpInterceptor>;
+}
+
+type FirebaseLoginMethodType = string;
+type FirebaseLoginMethodCategory = string;
+type KnownFirebaseLoginMethodType = 'email' | 'phone' | 'google' | 'facebook' | 'github' | 'twitter' | 'apple' | 'microsoft' | 'anonymous';
+declare const DEFAULT_FIREBASE_LOGIN_METHOD_CATEGORY = "default";
+declare const OAUTH_FIREBASE_LOGIN_METHOD_CATEGORY = "oauth";
+type KnownFirebaseLoginMethodCategory = typeof DEFAULT_FIREBASE_LOGIN_METHOD_CATEGORY | typeof OAUTH_FIREBASE_LOGIN_METHOD_CATEGORY;
+type DbxFirebaseLoginMode = 'login' | 'register';
+
+type DbxFirebaseAuthLoginPasswordConfig = TextPasswordFieldPasswordParameters;
+declare const DEFAULT_FIREBASE_AUTH_LOGIN_PASSWORD_CONFIG: DbxFirebaseAuthLoginPasswordConfig;
+
+/**
+ * Configuration interface for DbxFirebaseLoginTermsSimpleComponent.
+ */
+interface DbxFirebaseLoginTermsOfServiceUrlsConfig {
+    /**
+     * The Terms of Service URL.
+     */
+    readonly tosUrl: string;
+    /**
+     * The Privacy Policy URL.
+     */
+    readonly privacyUrl: string;
+}
+
+/**
+ * Configuration for provideDbxFirebaseLogin().
+ */
+interface ProvideDbxFirebaseLoginConfig {
+    /**
+     * DbxFirebaseLoginTermsOfServiceUrlsConfig configuration.
+     */
+    readonly termsOfServiceUrls: DbxFirebaseLoginTermsOfServiceUrlsConfig;
+    /**
+     * Enabled login methods. Set to true to enable all methods.
+     */
+    readonly enabledLoginMethods: FirebaseLoginMethodType[] | true;
+    /**
+     * Configures the default login terms component class via DEFAULT_FIREBASE_AUTH_LOGIN_TERMS_COMPONENT_CLASS_TOKEN.
+     */
+    readonly loginTermsComponentClass?: Type<unknown>;
+    /**
+     * Optional password configuration.
+     */
+    readonly passwordConfig?: DbxFirebaseAuthLoginPasswordConfig;
+}
+/**
+ * Creates EnvironmentProviders for providing DbxFirebaseLogin configuration.
+ *
+ * @param config Configuration
+ * @returns EnvironmentProviders
+ */
+declare function provideDbxFirebaseLogin(config: ProvideDbxFirebaseLoginConfig): EnvironmentProviders;
+
+/**
+ * Default providers to inject.
+ */
+declare const DEFAULT_FIREBASE_AUTH_LOGIN_PROVIDERS_TOKEN: InjectionToken<DbxFirebaseAuthLoginProvider<unknown>[]>;
+declare const DEFAULT_FIREBASE_AUTH_LOGIN_TERMS_COMPONENT_CLASS_TOKEN: InjectionToken<Type<unknown>>;
+declare const DEFAULT_FIREBASE_AUTH_LOGIN_PASSWORD_CONFIG_TOKEN: InjectionToken<Partial<Pick<dist_packages_dbx_form_types_dereekb_dbx_form.TextFieldConfig, "maxLength" | "minLength" | "pattern">>>;
+interface DbxFirebaseAuthLoginProvider<D = unknown> {
+    /**
+     * Category for this login method.
+     */
+    readonly category?: FirebaseLoginMethodCategory;
+    /**
+     * Login method key for this type.
+     */
+    readonly loginMethodType: KnownFirebaseLoginMethodType | FirebaseLoginMethodType;
+    /**
+     * Login/Registration class to use.
+     */
+    readonly componentClass: Type<unknown>;
+    /**
+     * Custom registration type to use instead. If false, registration is not allowd for this type.
+     */
+    readonly registrationComponentClass?: Type<unknown> | false;
+    /**
+     * Custom data available to the components.
+     *
+     * Components are responsible for knowing the typing information of this data.
+     */
+    readonly componentData?: D;
+    /**
+     * Asset configuration for this type.
+     */
+    readonly assets: DbxFirebaseAuthLoginProviderAssets;
+}
+/**
+ * Asset configurations for a provider.
+ */
+interface DbxFirebaseAuthLoginProviderAssets {
+    /**
+     * URL of the logo to use.
+     */
+    readonly logoUrl?: string;
+    /**
+     * Icon to use in place of the logo.
+     */
+    readonly loginIcon?: string;
+    /**
+     * Log in text to display next to the logo.
+     */
+    readonly loginText?: string;
+    /**
+     * Optional background color to apply.
+     */
+    readonly backgroundColor?: string;
+    /**
+     * Optional background color to apply.
+     */
+    readonly textColor?: string;
+}
+/**
+ * Service used for registering components used for logging in.
+ *
+ * Default providers can be configured by the DEFAULT_FIREBASE_AUTH_LOGIN_PROVIDERS_TOKEN injectable value.
+ */
+declare class DbxFirebaseAuthLoginService {
+    readonly loginTermsComponentClass: Type<unknown>;
+    private readonly _providers;
+    private readonly _assets;
+    private _enableAll;
+    private _passwordConfig;
+    private _enabled;
+    constructor();
+    /**
+     * Used to register a provider. If a provider is already registered, this will override it by default.
+     *
+     * @param provider
+     * @param override
+     */
+    register(provider: DbxFirebaseAuthLoginProvider, override?: boolean): boolean;
+    /**
+     * Updates the assets for a provider type.
+     *
+     * @param type
+     * @param assets
+     */
+    updateAssetsForProvider(type: FirebaseLoginMethodType, assets: Partial<DbxFirebaseAuthLoginProviderAssets>): void;
+    /**
+     * Enables all providers and any providers that will be registered.
+     */
+    setEnableAll(enableAll?: boolean): void;
+    clearEnabled(): void;
+    /**
+     * Enables all of the specified types.
+     *
+     * @param types
+     */
+    enable(types: ArrayOrValue<FirebaseLoginMethodType>): void;
+    disable(types: ArrayOrValue<FirebaseLoginMethodType>): void;
+    getRegisteredTypes(): FirebaseLoginMethodType[];
+    getEnabledTypes(): FirebaseLoginMethodType[];
+    getLoginProvider(type: FirebaseLoginMethodType): Maybe<DbxFirebaseAuthLoginProvider>;
+    getLoginProviders(types: Iterable<FirebaseLoginMethodType>): DbxFirebaseAuthLoginProvider[];
+    getRegisterProvider(type: FirebaseLoginMethodType): Maybe<DbxFirebaseAuthLoginProvider>;
+    getRegisterProviders(types: Iterable<FirebaseLoginMethodType>): DbxFirebaseAuthLoginProvider[];
+    getProviderAssets(type: FirebaseLoginMethodType): Maybe<DbxFirebaseAuthLoginProviderAssets>;
+    getPasswordConfig(): Partial<Pick<dist_packages_dbx_form_types_dereekb_dbx_form.TextFieldConfig, "maxLength" | "minLength" | "pattern">>;
+    setPasswordConfig(passwordConfig: DbxFirebaseAuthLoginPasswordConfig): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseAuthLoginService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseAuthLoginService>;
+}
+
+/**
+ * Injection token for a DbxInjectionContext for DbxFirebaseLoginContext.
+ */
+declare abstract class DbxFirebaseLoginContext extends DbxInjectionContext {
+}
+
+interface DbxFirebaseLoginButtonConfig {
+    text: string;
+    iconUrl?: string;
+    icon?: string;
+    buttonColor?: string;
+    buttonTextColor?: string;
+    handleLogin: () => Promise<unknown>;
+}
+/**
+ * Login button and action.
+ */
+declare class DbxFirebaseLoginButtonComponent {
+    readonly config: i0.ModelSignal<Maybe<DbxFirebaseLoginButtonConfig>>;
+    readonly iconUrlSignal: i0.Signal<string | undefined>;
+    readonly iconSignal: i0.Signal<string | undefined>;
+    readonly textSignal: i0.Signal<string>;
+    readonly buttonColorSignal: i0.Signal<string>;
+    readonly buttonTextColorSignal: i0.Signal<string | undefined>;
+    setConfig(config: Maybe<DbxFirebaseLoginButtonConfig>): void;
+    readonly handleAction: WorkUsingContext;
+    onActionSuccess: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginButtonComponent, "dbx-firebase-login-button", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, { "config": "configChange"; }, never, never, true, never>;
+}
+declare class DbxFirebaseLoginButtonContainerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginButtonContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginButtonContainerComponent, "dbx-firebase-login-button-container", never, {}, {}, never, ["*"], true, never>;
+}
+declare const DEFAULT_CONFIGURED_DBX_FIREBASE_LOGIN_BUTTON_TEMPLATE = "\n  <dbx-firebase-login-button-container>\n    <dbx-firebase-login-button [config]=\"configSignal()\"></dbx-firebase-login-button>\n  </dbx-firebase-login-button-container>\n";
+declare const DBX_CONFIGURED_DBX_FIREBASE_LOGIN_BUTTON_COMPONENT_CONFIGURATION: Pick<Component, 'template' | 'imports' | 'changeDetection'>;
+declare abstract class AbstractConfiguredDbxFirebaseLoginButtonDirective implements OnInit {
+    abstract readonly loginProvider: FirebaseLoginMethodType;
+    readonly dbxFirebaseAuthService: DbxFirebaseAuthService;
+    readonly dbxFirebaseAuthLoginService: DbxFirebaseAuthLoginService;
+    readonly dbxFirebaseLoginContext: DbxFirebaseLoginContext;
+    private readonly _config;
+    readonly configSignal: i0.Signal<DbxFirebaseLoginButtonConfig | null>;
+    ngOnInit(): void;
+    abstract handleLogin(): Promise<unknown>;
+    get providerConfig(): Maybe<_dereekb_dbx_firebase.DbxFirebaseAuthLoginProvider<unknown>>;
+    get assetConfig(): _dereekb_dbx_firebase.DbxFirebaseAuthLoginProviderAssets;
+    get config(): DbxFirebaseLoginButtonConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractConfiguredDbxFirebaseLoginButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractConfiguredDbxFirebaseLoginButtonDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseLoginAnonymousComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "anonymous";
+    handleLogin(): Promise<_firebase_auth.UserCredential>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginAnonymousComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginAnonymousComponent, "dbx-firebase-login-anonymous", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseLoginAppleComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "apple";
+    handleLogin(): Promise<_firebase_auth.UserCredential>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginAppleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginAppleComponent, "dbx-firebase-login-apple", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Pre-configured login component that displays all configured login types.
+ */
+declare class DbxFirebaseLoginComponent {
+    readonly loginMode: i0.InputSignal<DbxFirebaseLoginMode>;
+    readonly providerTypes: i0.InputSignal<Maybe<ArrayOrValue<string>>>;
+    readonly omitProviderTypes: i0.InputSignal<Maybe<ArrayOrValue<string>>>;
+    readonly providerCategories: i0.InputSignal<Maybe<ArrayOrValue<string>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginComponent, "dbx-firebase-login", never, { "loginMode": { "alias": "loginMode"; "required": false; "isSignal": true; }; "providerTypes": { "alias": "providerTypes"; "required": false; "isSignal": true; }; "omitProviderTypes": { "alias": "omitProviderTypes"; "required": false; "isSignal": true; }; "providerCategories": { "alias": "providerCategories"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseLoginContextBackButtonComponent {
+    readonly cancelLogin: i0.OutputEmitterRef<void>;
+    readonly anchor: ClickableAnchor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginContextBackButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginContextBackButtonComponent, "dbx-firebase-login-context-back-button", never, {}, { "cancelLogin": "cancelLogin"; }, never, never, true, never>;
+}
+
+/**
+ * DbxFirebaseLoginContext implementation.
+ */
+declare class DbxFirebaseLoginContextDirective extends AbstractForwardDbxInjectionContextDirective implements DbxFirebaseLoginContext {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginContextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseLoginContextDirective, "[dbxFirebaseLoginContext]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseLoginEmailComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "email";
+    handleLogin(): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginEmailComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginEmailComponent, "dbx-firebase-login-email", never, {}, {}, never, never, true, never>;
+}
+
+interface DbxFirebaseEmailRecoveryFormValue {
+    email: string;
+}
+declare class DbxFirebaseEmailRecoveryFormComponent extends AbstractSyncFormlyFormDirective<DbxFirebaseEmailRecoveryFormValue> {
+    readonly fields: FormlyFieldConfig[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseEmailRecoveryFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseEmailRecoveryFormComponent, "dbx-firebase-email-recovery-form", never, {}, {}, never, never, true, never>;
+}
+
+type DbxFirebaseEmailFormValue = DefaultUsernameLoginFieldsValue;
+interface DbxFirebaseEmailFormConfig {
+    readonly loginMode: DbxFirebaseLoginMode;
+    readonly passwordConfig?: TextPasswordFieldConfig;
+}
+declare class DbxFirebaseEmailFormComponent extends AbstractConfigAsyncFormlyFormDirective<DbxFirebaseEmailFormValue, DbxFirebaseEmailFormConfig> {
+    readonly fields$: Observable<Maybe<FormlyFieldConfig[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseEmailFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseEmailFormComponent, "dbx-firebase-email-form", never, {}, {}, never, never, true, never>;
+}
+
+interface DbxFirebaseLoginEmailContentComponentConfig extends DbxFirebaseEmailFormConfig {
+    readonly loginMode: DbxFirebaseLoginMode;
+}
+type DbxFirebaseLoginEmailContentMode = 'login' | 'recover' | 'recoversent';
+declare class DbxFirebaseLoginEmailContentComponent {
+    readonly dbxFirebaseAuthService: DbxFirebaseAuthService;
+    readonly config: DbxFirebaseLoginEmailContentComponentConfig;
+    readonly formConfig: DbxFirebaseEmailFormConfig;
+    private readonly _emailFormValueSignal;
+    private readonly _recoveryFormValueSignal;
+    private readonly _emailModeSignal;
+    readonly emailFormValueSignal: i0.Signal<Maybe<_dereekb_dbx_form.DefaultUsernameLoginFieldsValue>>;
+    readonly recoveryFormValueSignal: i0.Signal<Maybe<DbxFirebaseEmailRecoveryFormValue>>;
+    readonly emailModeSignal: i0.Signal<DbxFirebaseLoginEmailContentMode>;
+    readonly forgotAnchor: ClickableAnchor;
+    readonly doneOrCancelled: EventEmitter<boolean>;
+    static openEmailLoginContext(dbxFirebaseLoginContext: DbxFirebaseLoginContext, config: DbxFirebaseLoginEmailContentComponentConfig): Promise<boolean>;
+    get loginMode(): DbxFirebaseLoginMode;
+    get isLoginMode(): boolean;
+    get isRegisterMode(): boolean;
+    get buttonText(): "Register" | "Log In";
+    readonly handleLoginAction: WorkUsingObservable<DbxFirebaseEmailFormValue>;
+    openRecovery(): void;
+    readonly handleRecoveryAction: WorkUsingContext<DbxFirebaseEmailRecoveryFormValue>;
+    readonly handleRecoverySuccess: DbxActionSuccessHandlerFunction;
+    clickedRecoveryAcknowledged(): void;
+    onCancel(): void;
+    onCancelReset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginEmailContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginEmailContentComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseLoginFacebookComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "facebook";
+    handleLogin(): Promise<_firebase_auth.UserCredential>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginFacebookComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginFacebookComponent, "dbx-firebase-login-facebook", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseLoginGitHubComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "github";
+    handleLogin(): Promise<_firebase_auth.UserCredential>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginGitHubComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginGitHubComponent, "dbx-firebase-login-github", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseLoginGoogleComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "google";
+    handleLogin(): Promise<_firebase_auth.UserCredential>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginGoogleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginGoogleComponent, "dbx-firebase-login-google", never, {}, {}, never, never, true, never>;
+}
+
+type DbxFirebaseLoginListItemInjectionComponentConfig = DbxInjectionComponentConfig & Pick<DbxFirebaseAuthLoginProvider, 'loginMethodType'>;
+/**
+ * Pre-configured login component that displays all configured login types.
+ */
+declare class DbxFirebaseLoginListComponent {
+    readonly dbxFirebaseAuthLoginService: DbxFirebaseAuthLoginService;
+    readonly loginMode: i0.InputSignal<DbxFirebaseLoginMode>;
+    readonly providerTypes: i0.InputSignal<Maybe<ArrayOrValue<string>>>;
+    readonly omitProviderTypes: i0.InputSignal<Maybe<ArrayOrValue<string>>>;
+    readonly providerCategories: i0.InputSignal<Maybe<ArrayOrValue<string>>>;
+    readonly providerTypesSignal: i0.Signal<string[]>;
+    readonly providersSignal: i0.Signal<DbxFirebaseAuthLoginProvider<unknown>[]>;
+    readonly providersInjectionConfigsSignal: i0.Signal<DbxFirebaseLoginListItemInjectionComponentConfig[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginListComponent, "dbx-firebase-login-list", never, { "loginMode": { "alias": "loginMode"; "required": false; "isSignal": true; }; "providerTypes": { "alias": "providerTypes"; "required": false; "isSignal": true; }; "omitProviderTypes": { "alias": "omitProviderTypes"; "required": false; "isSignal": true; }; "providerCategories": { "alias": "providerCategories"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseLoginMicrosoftComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "microsoft";
+    handleLogin(): Promise<_firebase_auth.UserCredential>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginMicrosoftComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginMicrosoftComponent, "dbx-firebase-login-microsoft", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseLoginTermsComponent {
+    readonly dbxFirebaseAuthLoginService: DbxFirebaseAuthLoginService;
+    readonly config: DbxInjectionComponentConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginTermsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginTermsComponent, "dbx-firebase-login-terms", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseLoginTermsSimpleComponent {
+    readonly dbxFirebaseLoginTermsConfig: DbxFirebaseLoginTermsOfServiceUrlsConfig;
+    readonly tosAnchor: ClickableAnchor;
+    readonly privacyAnchor: ClickableAnchor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginTermsSimpleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginTermsSimpleComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseLoginTwitterComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "twitter";
+    handleLogin(): Promise<_firebase_auth.UserCredential>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginTwitterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginTwitterComponent, "dbx-firebase-login-twitter", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Pre-configured register component that displays all configured login types and their registration components.
+ */
+declare class DbxFirebaseRegisterComponent {
+    readonly providerTypes: i0.InputSignal<Maybe<ArrayOrValue<string>>>;
+    readonly omitProviderTypes: i0.InputSignal<Maybe<ArrayOrValue<string>>>;
+    readonly providerCategories: i0.InputSignal<Maybe<ArrayOrValue<string>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseRegisterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseRegisterComponent, "dbx-firebase-register", never, { "providerTypes": { "alias": "providerTypes"; "required": false; "isSignal": true; }; "omitProviderTypes": { "alias": "omitProviderTypes"; "required": false; "isSignal": true; }; "providerCategories": { "alias": "providerCategories"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseRegisterEmailComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "email";
+    handleLogin(): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseRegisterEmailComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseRegisterEmailComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Creates a AuthUserStateObsFunction that derives a user state from the input firebase auth service, and the optional stateForLoggedInUser input
+ *
+ * @param stateForLoggedInUser Optional function that returns an observable for the user's state if they are logged in and not an anonymous user.
+ * @returns
+ */
+declare function authUserStateFromFirebaseAuthServiceFunction(stateForLoggedInUser?: AuthUserStateObsFunction): AuthUserStateObsFunction;
+type StateFromTokenFunction = (token: IdTokenResult$1) => ObservableOrValue<AuthUserState>;
+declare function stateFromTokenForLoggedInUserFunction(stateFromToken: StateFromTokenFunction, defaultState?: AuthUserState): AuthUserStateObsFunction;
+/**
+ * Convenience function to read a value from an IdTokenResult off of the current user.
+ *
+ * @param dbxFirebaseAuthService
+ * @param readValueFromIdToken
+ * @param defaultValue
+ * @returns
+ */
+declare function readValueFromIdToken<T>(dbxFirebaseAuthService: DbxFirebaseAuthService, readValueFromIdToken: (idToken: IdTokenResult$1) => ObservableOrValue<T>, defaultValue: T): Observable<T>;
+
+interface AuthRolesObsWithClaimsServiceConfig<T extends AuthClaimsObject> extends Partial<Pick<DbxFirebaseAuthServiceDelegate, 'isAdminInAuthRoleSet' | 'authUserStateObs'>> {
+    /**
+     * (Optional) alternative to supplying authUserStateObs. Is passed to authUserStateFromFirebaseAuthService.
+     */
+    readonly stateForLoggedInUser?: AuthUserStateObsFunction;
+    /**
+     * (Optional) alternative to supplying authUserStateObs.
+     */
+    readonly stateForLoggedInUserToken?: StateFromTokenFunction;
+    /**
+     * Claims service to use for decoding.
+     */
+    readonly claimsService: AuthRoleClaimsService<T>;
+    /**
+     * Whether or not to also add the current AuthUserState value to decoded roles.
+     */
+    readonly addAuthUserStateToRoles?: boolean;
+}
+declare function authRolesObsWithClaimsService<T extends AuthClaimsObject>(config: AuthRolesObsWithClaimsServiceConfig<T>): (dbxFirebaseAuthService: DbxFirebaseAuthService) => Observable<AuthRoleSet>;
+type DefaultDbxFirebaseAuthServiceDelegateWithClaimsServiceConfig<T extends AuthClaimsObject> = AuthRolesObsWithClaimsServiceConfig<T>;
+declare function defaultDbxFirebaseAuthServiceDelegateWithClaimsService<T extends AuthClaimsObject>(config: DefaultDbxFirebaseAuthServiceDelegateWithClaimsServiceConfig<T>): DbxFirebaseAuthServiceDelegate;
+
+/**
+ * Configuration for provideDbxFirebaseAuth().
+ */
+interface ProvideDbxFirebaseAuthConfig {
+    /**
+     * Optional custom delegate factory for the configured DbxFirebaseAuthService.
+     *
+     * @param injector
+     * @returns
+     */
+    delegateFactory?: (injector: Injector) => DbxFirebaseAuthServiceDelegate;
+}
+/**
+ * Creates EnvironmentProviders for the DbxFirebaseAuthService, and configures the DbxFirebaseAuthService to provide DbxAuthService.
+ *
+ * @param config
+ * @returns
+ */
+declare function provideDbxFirebaseAuth(config?: ProvideDbxFirebaseAuthConfig): EnvironmentProviders;
+
+interface DbxFirebaseDevelopmentWidgetEntry extends Readonly<LabelRef> {
+    /**
+     * Widget entry for this provider.
+     */
+    readonly widget: DbxWidgetEntry;
+}
+
+interface DbxFirebaseDevelopmentPopupContentFormInput {
+    readonly entries: DbxFirebaseDevelopmentWidgetEntry[];
+}
+interface DbxFirebaseDevelopmentPopupContentFormValue {
+    readonly specifier?: Maybe<string>;
+}
+declare class DbxFirebaseDevelopmentPopupContentFormComponent extends AbstractConfigAsyncFormlyFormDirective<DbxFirebaseDevelopmentPopupContentFormValue, DbxFirebaseDevelopmentPopupContentFormInput> {
+    readonly fields$: Observable<FormlyFieldConfig[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDevelopmentPopupContentFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseDevelopmentPopupContentFormComponent, "dbx-firebase-development-popup-content-form", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Corresponds to the enabled value on the DbxFirebaseDevelopmentService.
+ */
+declare const DEFAULT_FIREBASE_DEVELOPMENT_ENABLED_TOKEN: InjectionToken<unknown>;
+/**
+ * Service used for registering widgets used for development.
+ *
+ * Default providers can be configured by the DEFAULT_FIREBASE_AUTH_LOGIN_PROVIDERS_TOKEN injectable value.
+ */
+declare class DbxFirebaseDevelopmentService {
+    readonly enabled: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDevelopmentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseDevelopmentService>;
+}
+
+/**
+ * Directive for showing the development tools snackbar when the app opens up and listening for keybindings for opening the popup.
+ */
+declare class DbxFirebaseDevelopmentDirective implements AfterViewInit {
+    readonly popupService: DbxPopupService;
+    readonly matSnackBar: MatSnackBar;
+    readonly dbxFirebaseDevelopmentService: DbxFirebaseDevelopmentService;
+    ref?: NgPopoverRef<any, any>;
+    get enabled(): boolean;
+    constructor();
+    handleKeyboardEvent(event: KeyboardEvent): void;
+    togglePopup(): void;
+    openPopup(): void;
+    closePopup(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDevelopmentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseDevelopmentDirective, "[dbxFirebaseDevelopment]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Default providers to inject.
+ */
+declare const DEFAULT_FIREBASE_DEVELOPMENT_WIDGET_PROVIDERS_TOKEN: InjectionToken<DbxFirebaseDevelopmentWidgetEntry[]>;
+/**
+ * Service used for registering widgets used for development.
+ *
+ * Default providers can be configured by the DEFAULT_FIREBASE_AUTH_LOGIN_PROVIDERS_TOKEN injectable value.
+ */
+declare class DbxFirebaseDevelopmentWidgetService {
+    readonly dbxWidgetService: DbxWidgetService;
+    private readonly _entries;
+    constructor(defaultEntries: DbxFirebaseDevelopmentWidgetEntry[]);
+    /**
+     * Used to register a provider. If a provider is already registered, this will override it by default.
+     *
+     * @param provider
+     * @param override
+     */
+    register(provider: DbxFirebaseDevelopmentWidgetEntry, override?: boolean): boolean;
+    getEntryWidgetIdentifiers(): DbxWidgetType[];
+    getEntries(): DbxFirebaseDevelopmentWidgetEntry[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDevelopmentWidgetService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseDevelopmentWidgetService>;
+}
+
+/**
+ * Whether or not the scheduler should be enabled.
+ */
+declare const DEFAULT_FIREBASE_DEVELOPMENT_SCHEDULER_ENABLED_TOKEN: InjectionToken<unknown>;
+/**
+ * Service used for hitting the scheduler in the development environment using the
+ */
+declare class DbxFirebaseDevelopmentSchedulerService implements Initialized {
+    readonly dbxAuthService: DbxAuthService;
+    readonly firebaseDevelopmentFunctions: FirebaseDevelopmentFunctions;
+    private readonly _sub;
+    private readonly _enabled;
+    private readonly _timerInterval;
+    private readonly _error;
+    readonly enabled$: Observable<boolean>;
+    readonly running$: Observable<boolean>;
+    readonly timerInterval$: Observable<number>;
+    readonly error$: Observable<boolean>;
+    readonly schedulerList$: Observable<ScheduledFunctionDevelopmentFirebaseFunctionListEntry[]>;
+    init(): void;
+    runScheduledFunction(taskName: string): Promise<_dereekb_firebase.ScheduledFunctionDevelopmentFirebaseFunctionResult>;
+    setTimer(timerInterval: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDevelopmentSchedulerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseDevelopmentSchedulerService>;
+}
+
+interface DbxFirebaseEmulatorConfig {
+    /**
+     * Port to target.
+     */
+    readonly port: number;
+    /**
+     * Defaults to localhost if not provided.
+     */
+    readonly host?: string;
+}
+interface DbxFirebaseEmulatorsConfig {
+    /**
+     * Whether or not to enable the emulators.
+     *
+     * Defaults to false.
+     */
+    readonly useEmulators?: boolean;
+    /**
+     * Default host to target. Defaults to localhost if not provided.
+     */
+    readonly host?: string;
+    /**
+     * emulator UI configuration
+     */
+    readonly ui?: DbxFirebaseEmulatorConfig;
+    /**
+     * Auth emulator configuration
+     */
+    readonly auth?: DbxFirebaseEmulatorConfig;
+    /**
+     * Firestore emulator configuration
+     */
+    readonly firestore?: DbxFirebaseEmulatorConfig;
+    /**
+     * Firestore emulator configuration
+     */
+    readonly storage?: DbxFirebaseEmulatorConfig;
+    /**
+     * Functions emulator configuration
+     */
+    readonly functions?: DbxFirebaseEmulatorConfig;
+    /**
+     * Database emulator configuration
+     */
+    readonly database?: DbxFirebaseEmulatorConfig;
+}
+declare abstract class DbxFirebaseParsedEmulatorsConfig implements DbxFirebaseEmulatorsConfig {
+    abstract readonly useEmulators: boolean;
+    readonly host?: string;
+    /**
+     * Fix used by some components to allow changing 0.0.0.0 to localhost. Defaults to true.
+     */
+    readonly allow0000ToLocalhost?: boolean;
+    readonly ui?: Required<DbxFirebaseEmulatorConfig>;
+    readonly auth?: Required<DbxFirebaseEmulatorConfig>;
+    readonly firestore?: Required<DbxFirebaseEmulatorConfig>;
+    readonly storage?: Required<DbxFirebaseEmulatorConfig>;
+    readonly functions?: Required<DbxFirebaseEmulatorConfig>;
+    readonly database?: Required<DbxFirebaseEmulatorConfig>;
+}
+
+declare class DbxFirebaseEmulatorService {
+    readonly emulatorsConfig: DbxFirebaseParsedEmulatorsConfig;
+    get useEmulators(): boolean;
+    get emulatorUIAnchor(): Maybe<ClickableUrl>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseEmulatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseEmulatorService>;
+}
+
+declare class DbxFirebaseDevelopmentPopupContentComponent {
+    readonly twoColumnsContextStore: TwoColumnsContextStore;
+    readonly dbxAuthService: DbxAuthService;
+    readonly dbxFirebaseDevelopmentWidgetService: DbxFirebaseDevelopmentWidgetService;
+    readonly dbxFirebaseDevelopmentSchedulerService: DbxFirebaseDevelopmentSchedulerService;
+    readonly dbxFirebaseEmulatorService: DbxFirebaseEmulatorService;
+    readonly showEmulatorButton: boolean;
+    readonly emulatorUIAnchor: ClickableAnchor;
+    readonly entries: _dereekb_dbx_firebase.DbxFirebaseDevelopmentWidgetEntry[];
+    private readonly _activeEntrySelector;
+    readonly isLoggedIn$: Observable<boolean>;
+    readonly entries$: Observable<_dereekb_dbx_firebase.DbxFirebaseDevelopmentWidgetEntry[]>;
+    readonly formConfig$: Observable<{
+        entries: _dereekb_dbx_firebase.DbxFirebaseDevelopmentWidgetEntry[];
+    }>;
+    readonly activeEntrySelector$: Observable<Maybe<string>>;
+    readonly currentActiveEntry$: Observable<_dereekb_dbx_firebase.DbxFirebaseDevelopmentWidgetEntry | undefined>;
+    readonly showRight$: Observable<boolean>;
+    readonly activeEntry$: Observable<_dereekb_dbx_firebase.DbxFirebaseDevelopmentWidgetEntry | undefined>;
+    readonly schedulerRunning$: Observable<boolean>;
+    readonly schedulerInterval$: Observable<number>;
+    readonly schedulerError$: Observable<"Error Occured" | "Ok">;
+    readonly formData$: Observable<DbxFirebaseDevelopmentPopupContentFormValue>;
+    readonly schedulerRunningSignal: i0.Signal<boolean | undefined>;
+    readonly schedulerIntervalSignal: i0.Signal<number | undefined>;
+    readonly schedulerErrorSignal: i0.Signal<"Error Occured" | "Ok" | undefined>;
+    readonly activeEntrySignal: i0.Signal<_dereekb_dbx_firebase.DbxFirebaseDevelopmentWidgetEntry | undefined>;
+    readonly rightTitleSignal: i0.Signal<string | undefined>;
+    readonly widgetConfigSignal: i0.Signal<Maybe<Readonly<_dereekb_util.ModelTypeDataPair<unknown, string>>>>;
+    constructor();
+    readonly handleFormUpdate: WorkUsingContext<DbxFirebaseDevelopmentPopupContentFormValue, void>;
+    readonly isFormModified: IsModifiedFunction<DbxFirebaseDevelopmentPopupContentFormValue>;
+    clearSelection(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDevelopmentPopupContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseDevelopmentPopupContentComponent, "dbx-firebase-development-popup-content", never, {}, {}, never, never, true, never>;
+}
+
+declare const DEFAULT_FIREBASE_DEVELOPMENT_POPUP_KEY = "devpopup";
+declare class DbxFirebaseDevelopmentPopupComponent extends AbstractPopupDirective {
+    private readonly popupService;
+    readonly content: i0.Signal<DbxFirebaseDevelopmentPopupContentComponent>;
+    readonly header = "Development Tools";
+    static openPopup(popupService: DbxPopupService, popupKey?: DbxPopupKey): NgPopoverRef;
+    reopen: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDevelopmentPopupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseDevelopmentPopupComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare const DEVELOPMENT_FIREBASE_SERVER_SCHEDULER_WIDGET_KEY = "DEVELOPMENT_FIREBASE_SERVER_SCHEDULER_WIDGET";
+declare function developmentFirebaseServerSchedulerWidgetEntry(): DbxFirebaseDevelopmentWidgetEntry;
+declare class DbxFirebaseDevelopmentSchedulerWidgetComponent {
+    readonly dbxFirebaseDevelopmentSchedulerService: DbxFirebaseDevelopmentSchedulerService;
+    readonly entries$: rxjs.Observable<_dereekb_firebase.ScheduledFunctionDevelopmentFirebaseFunctionListEntry[]>;
+    readonly state$: rxjs.Observable<_dereekb_rxjs.LoadingState<_dereekb_firebase.ScheduledFunctionDevelopmentFirebaseFunctionListEntry[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDevelopmentSchedulerWidgetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseDevelopmentSchedulerWidgetComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+type ScheduledFunctionDevelopmentFirebaseFunctionListEntryWithSelection = DbxValueAsListItem<ScheduledFunctionDevelopmentFirebaseFunctionListEntry>;
+declare class DbxFirebaseDevelopmentSchedulerListComponent extends AbstractDbxSelectionListWrapperDirective<ScheduledFunctionDevelopmentFirebaseFunctionListEntry> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDevelopmentSchedulerListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseDevelopmentSchedulerListComponent, "dbx-firebase-development-scheduler-list", never, {}, {}, never, ["[top]", "[bottom]", "[empty]", "[emptyLoading]", "[end]"], true, never>;
+}
+declare class DbxFirebaseDevelopmentSchedulerListViewComponent extends AbstractDbxSelectionListViewDirective<ScheduledFunctionDevelopmentFirebaseFunctionListEntry> {
+    readonly config: DbxSelectionValueListViewConfig<ScheduledFunctionDevelopmentFirebaseFunctionListEntryWithSelection>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDevelopmentSchedulerListViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseDevelopmentSchedulerListViewComponent, "dbx-firebase-development-scheduler-list-view", never, {}, {}, never, never, true, never>;
+}
+declare class DbxFirebaseDevelopmentSchedulerListViewItemComponent extends AbstractDbxValueListViewItemComponent<ScheduledFunctionDevelopmentFirebaseFunctionListEntry> {
+    readonly dbxFirebaseDevelopmentSchedulerService: DbxFirebaseDevelopmentSchedulerService;
+    get name(): string;
+    readonly handleRun: WorkUsingContext<unknown, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDevelopmentSchedulerListViewItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseDevelopmentSchedulerListViewItemComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Contains components related to logging in.
+ */
+declare class DbxFirebaseDevelopmentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDevelopmentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFirebaseDevelopmentModule, never, [typeof DbxFirebaseDevelopmentPopupContentFormComponent, typeof DbxFirebaseDevelopmentDirective, typeof DbxFirebaseDevelopmentPopupComponent, typeof DbxFirebaseDevelopmentPopupContentComponent, typeof DbxFirebaseDevelopmentSchedulerWidgetComponent, typeof DbxFirebaseDevelopmentSchedulerListComponent, typeof DbxFirebaseDevelopmentSchedulerListViewComponent, typeof DbxFirebaseDevelopmentSchedulerListViewItemComponent], [typeof DbxFirebaseDevelopmentPopupContentFormComponent, typeof DbxFirebaseDevelopmentDirective, typeof DbxFirebaseDevelopmentPopupComponent, typeof DbxFirebaseDevelopmentPopupContentComponent, typeof DbxFirebaseDevelopmentSchedulerWidgetComponent, typeof DbxFirebaseDevelopmentSchedulerListComponent, typeof DbxFirebaseDevelopmentSchedulerListViewComponent, typeof DbxFirebaseDevelopmentSchedulerListViewItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseDevelopmentModule>;
+}
+
+/**
+ * Configuration for provideDbxFirebaseDevelopment().
+ */
+interface ProvideDbxFirebaseDevelopmentConfig {
+    /**
+     * Whether or not to automatically add the developmentFirebaseServerSchedulerWidgetEntry() to the developmentWidgetEntries.
+     *
+     * Defaults to true.
+     */
+    readonly addDevelopmentSchedulerWidget?: boolean;
+    /**
+     * Widgets to add to the DbxFirebaseDevelopmentWidgetService module.
+     *
+     * Configured via the DEFAULT_FIREBASE_DEVELOPMENT_WIDGET_PROVIDERS_TOKEN.
+     */
+    readonly developmentWidgetEntries?: DbxFirebaseDevelopmentWidgetEntry[];
+    /**
+     * Whether or not the development module is currently enabled.
+     *
+     * Corresponds to DEFAULT_FIREBASE_DEVELOPMENT_ENABLED_TOKEN.
+     */
+    readonly enabled?: boolean;
+}
+/**
+ * Creates providers for DbxFirebaseDevelopmentSchedulerService, DbxFirebaseDevelopmentWidgetService, and DbxFirebaseDevelopmentService.
+ *
+ * @param config
+ * @returns
+ */
+declare function provideDbxFirebaseDevelopment(config: ProvideDbxFirebaseDevelopmentConfig): EnvironmentProviders;
+
+interface DbxFirebaseAppCheckConfig extends Partial<Omit<AppCheckOptions, 'provider'>> {
+    reCaptchaV3: string;
+    /**
+     * Whether or not to enable AppCheck debug tokens. AppCheck tokens are only printed into the console, and more actions must be taken.
+     * See https://firebase.google.com/docs/app-check/web/debug-provider for more info.
+     *
+     * Debug tokens are only generated when emulators are disabled, and allowDebugTokens is true.
+     */
+    allowDebugTokens?: boolean;
+    /**
+     * If true, disables AppCheck initialization for this app.
+     */
+    disabled?: boolean;
+    /**
+     * List of routes that app check is authorized to hit.
+     *
+     * If not defined, /api/* allowed by default.
+     */
+    appCheckRoutes?: string[];
+}
+
+declare const DBX_FIREBASE_APP_OPTIONS_TOKEN: InjectionToken<DbxFirebaseAppOptions>;
+/**
+ * Extends FirebaseOptions with additional properties for configuring the underlying client-side Firebase services.
+ */
+interface DbxFirebaseAppOptions extends FirebaseOptions {
+    readonly emulators: DbxFirebaseEmulatorsConfig;
+    /**
+     * Firebase AppCheck handling
+     */
+    readonly appCheck?: DbxFirebaseAppCheckConfig;
+    /**
+     * Passed to the Functions initialization to set the domain to use when sending requests.
+     */
+    readonly functionsRegionOrCustomDomain?: string | undefined;
+    /**
+     * Whether or not to call enableMultiTabIndexedDbPersistence() for firestore at setup time.
+     *
+     * True by default.
+     */
+    readonly enableMultiTabIndexedDbPersistence?: boolean;
+    /**
+     * Whether or not to call enableIndexedDbPersistence() for firestore at setup time.
+     *
+     * True by default if enableMultiTabIndexedDbPersistence is false.
+     */
+    readonly enableIndexedDbPersistence?: boolean;
+    /**
+     * Optional persistent cache setting to pass to the Firestore cache.
+     */
+    readonly persistentCacheSettings?: Omit<PersistentCacheSettings, 'tabManager'>;
+}
+
+/**
+ * Configuration for provideDbxFirebaseApp().
+ */
+interface ProvideDbxFirebaseAppConfig {
+    /**
+     * DbxFirebaseAppOptions for the app.
+     *
+     * Is automatically configured as a provider for the DBX_FIREBASE_APP_OPTIONS_TOKEN.
+     */
+    readonly dbxFirebaseAppOptions: DbxFirebaseAppOptions;
+    /**
+     * Whether or not to provide Firestore configuration.
+     *
+     * True by default.
+     */
+    readonly provideFirestore?: Maybe<boolean>;
+    /**
+     * Whether or not to provide App Check configuration.
+     *
+     * True by default.
+     */
+    readonly provideAppCheck?: Maybe<boolean>;
+    /**
+     * Whether or not to provide Auth configuration.
+     *
+     * True by default.
+     */
+    readonly provideAuth?: Maybe<boolean>;
+    /**
+     * Whether or not to provide Storage configuration.
+     *
+     * True by default.
+     */
+    readonly provideStorage?: Maybe<boolean>;
+    /**
+     * Whether or not to provide Functions configuration.
+     *
+     * True by default.
+     */
+    readonly provideFunctions?: Maybe<boolean>;
+}
+/**
+ * Provides EnvironmentProviders for all Firebase services.
+ *
+ * @param config
+ * @returns EnvironmentProviders
+ */
+declare function provideDbxFirebaseApp(config: ProvideDbxFirebaseAppConfig): EnvironmentProviders;
+
+/**
+ * Config for provideDbxFirebaseEmulator().
+ */
+type ProvideDbxFirebaseEmulatorsConfig = DbxFirebaseEmulatorsConfig;
+/**
+ * Creates EnvironmentProviders for the DbxFirebaseEmulatorService.
+ *
+ * @param config
+ * @returns
+ */
+declare function provideDbxFirebaseEmulator(config: ProvideDbxFirebaseEmulatorsConfig): EnvironmentProviders;
+
+/**
+ * Convenience type used in .environment.ts files for building configuration.
+ */
+type DbxFirebaseEnvironmentOptions = DbxFirebaseAppOptions & Pick<ProvideDbxFirebaseLoginConfig, 'enabledLoginMethods'>;
+
+/**
+ * Token to access the FirestoreContext value.
+ */
+declare const DBX_FIRESTORE_CONTEXT_TOKEN: InjectionToken<unknown>;
+
+/**
+ * Provider factory for the SystemStateFirestoreCollections.
+ *
+ * @param appCollection The app collection class to use.
+ * @returns Provider factory for the SystemStateFirestoreCollections.
+ */
+declare function provideSystemStateFirestoreCollections(appCollection: SystemStateFirestoreCollections): SystemStateFirestoreCollections;
+/**
+ * Provider factory for the NotificationFirestoreCollections.
+ *
+ * @param appCollection The app collection class to use.
+ * @returns Provider factory for the NotificationFirestoreCollections.
+ */
+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.
+ */
+declare function provideStorageFileFirestoreCollections(appCollection: StorageFileFirestoreCollections): StorageFileFirestoreCollections;
+/**
+ * Configuration for provideDbxFirestoreCollection().
+ */
+interface ProvideDbxFirebaseFirestoreCollectionConfig<T> {
+    /**
+     * The app collection class to use.
+     */
+    readonly appCollectionClass: ClassLikeType<T>;
+    /**
+     * The collection factory to use.
+     */
+    readonly collectionFactory: (context: FirestoreContext) => T;
+    /**
+     * Whether or not to provide the SystemStateFirestoreCollections.
+     *
+     * True by default.
+     */
+    readonly provideSystemStateFirestoreCollections?: boolean;
+    /**
+     * Whether or not to provide the NotificationFirestoreCollections.
+     *
+     * 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.
+ *
+ * @param config Configuration for the providers.
+ * @returns EnvironmentProviders
+ */
+declare function provideDbxFirestoreCollection<T>(config: ProvideDbxFirebaseFirestoreCollectionConfig<T>): EnvironmentProviders;
+
+/**
+ * Service that provides access to the app's FirestoreContext.
+ */
+declare class DbxFirestoreContextService {
+    readonly firestoreContext: FirestoreContext<_dereekb_firebase.Firestore>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirestoreContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirestoreContextService>;
+}
+
+/**
+ * Configuration for provideDbxFirebaseFunctions().
+ */
+interface ProvideDbxFirebaseFunctionsConfig<T, M extends FirebaseFunctionsMap = FirebaseFunctionsMap> {
+    /**
+     * The token to use for the functions getter.
+     *
+     * This is typically your LazyFirebaseFunctions result type.
+     */
+    functionsGetterToken: ClassLikeType<T>;
+    /**
+     * Factory function to retrieve the functions getter instance.
+     *
+     * @param functions The Firebase functions instance.
+     * @returns The functions getter instance.
+     */
+    functionsGetterFactory: (functions: Functions) => T;
+    /**
+     * Key of the functions config to use to inject FirebaseDevelopmentFunctions using that same provider.
+     *
+     * Defaults to "developmentFunctions". If false, will not be injected automatically.
+     */
+    developmentFunctionsKey?: string | false;
+    /**
+     * 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<M>;
+}
+/**
+ * Creates EnvironmentProviders for the LazyFirebaseFunctions type for a DbxFirebase app.
+ *
+ * Also provides FirebaseDevelopmentFunctions if developmentFunctionsKey is provided.
+ *
+ * @param config Configuration for provideDbxFirebaseFunctions().
+ * @returns EnvironmentProviders for the LazyFirebaseFunctions type.
+ */
+declare function provideDbxFirebaseFunctions<T, M extends FirebaseFunctionsMap = FirebaseFunctionsMap>(config: ProvideDbxFirebaseFunctionsConfig<T, M>): EnvironmentProviders;
+
+interface DbxFirebaseCollectionLoaderAccessor<T = unknown> {
+    readonly constraints$: Observable<Maybe<ArrayOrValue<FirestoreQueryConstraint>>>;
+    readonly firestoreIteration$: Observable<FirestoreItemPageIterationInstance<T>>;
+    readonly pageLoadingState$: Observable<PageListLoadingState<DocumentDataWithIdAndKey<T>>>;
+    readonly queryChangeWatcher$: Observable<IterationQueryDocChangeWatcher<T>>;
+    /**
+     * Restarts the loader and refreshes items from the beginning.
+     */
+    restart(): void;
+}
+/**
+ * Abstract type that loads models from a configured collection.
+ */
+interface DbxFirebaseCollectionLoader<T = unknown> extends DbxFirebaseCollectionLoaderAccessor<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;
+    /**
+     * Returns an observable that loads up to the given page then emits the page number.
+     *
+     * @param page Page number to load to.
+     */
+    loadToPage(page: PageNumber): Observable<PageNumber>;
+    /**
+     * Loads results until all results have been loaded or the max page limit is reached.
+     */
+    loadAllResults(): Observable<PageNumber>;
+}
+interface DbxFirebaseCollectionLoaderAccessorWithAccumulator<T = unknown> extends DbxFirebaseCollectionLoaderAccessor<T> {
+    readonly snapshotAccumulator$: Observable<FirebaseQuerySnapshotAccumulator<T>>;
+    readonly accumulator$: Observable<FirebaseQueryItemAccumulator<T>>;
+}
+interface DbxFirebaseCollectionLoaderWithAccumulator<T = unknown> extends DbxFirebaseCollectionLoader<T>, DbxFirebaseCollectionLoaderAccessorWithAccumulator<T> {
+    /**
+     * Loads pages until the number of results has been reached, then emits the total number of results.
+     */
+    loadPagesUntilResultsCount(maxResultsCount: number, countFunction?: FirebaseQueryItemAccumulatorNextPageUntilResultsCountFunction<T>): Observable<ItemAccumulatorNextPageUntilResultsCountResult>;
+}
+
+/**
+ * DbxFirebaseCollectionChangeWatcher trigger modes
+ * - auto: will automatically call trigger
+ * - off: will never call trigger
+ */
+type DbxFirebaseCollectionChangeWatcherTriggerMode = 'auto' | 'off';
+type DbxFirebaseCollectionChangeWatcherEvent = Pick<IterationQueryDocChangeWatcherEvent<unknown>, 'time' | 'type'>;
+/**
+ * Used to watch a DbxFirebaseCollectionLoaderAccessor for when the query changes and
+ */
+interface DbxFirebaseCollectionChangeWatcher<S extends DbxFirebaseCollectionLoaderAccessor<any>> {
+    readonly store: S;
+    /**
+     * Current mode observable
+     */
+    readonly mode$: Observable<DbxFirebaseCollectionChangeWatcherTriggerMode>;
+    /**
+     * Stream of events
+     */
+    readonly event$: Observable<DbxFirebaseCollectionChangeWatcherEvent>;
+    readonly hasChangeAvailable$: Observable<boolean>;
+    /**
+     * Current trigger state. Based on the hasChangeAvailable$ state and current mode.
+     */
+    readonly triggered$: Observable<boolean>;
+    /**
+     * Trigger emitter. Only emits when triggered$ is/becomes true.
+     */
+    readonly trigger$: Observable<void>;
+}
+/**
+ * DbxFirebaseCollectionChangeWatcher instance that can be destroyed and the mode changed.
+ */
+interface DbxFirebaseCollectionChangeWatcherInstance<S extends DbxFirebaseCollectionLoaderAccessor<any>> extends DbxFirebaseCollectionChangeWatcher<S>, Destroyable {
+    /**
+     * Changes the mode
+     */
+    setMode(mode: DbxFirebaseCollectionChangeWatcherTriggerMode): void;
+}
+declare function dbxFirebaseCollectionChangeWatcher<S extends DbxFirebaseCollectionLoaderAccessor<any>>(store: S, initialMode?: DbxFirebaseCollectionChangeWatcherTriggerMode): DbxFirebaseCollectionChangeWatcherInstance<S>;
+
+type DbxFirebaseCollectionChangeTriggerFunction<S extends DbxFirebaseCollectionLoaderAccessor<any>> = (instance: DbxFirebaseCollectionChangeTriggerInstance<S>) => ObservableOrValue<void>;
+/**
+ * Restarts the store.
+ *
+ * @param instance
+ * @returns
+ */
+declare const DEFAULT_FIREBASE_COLLECTION_CHANGE_TRIGGER_FUNCTION: DbxFirebaseCollectionChangeTriggerFunction<any>;
+interface DbxFirebaseCollectionChangeTriggerInstanceConfig<S extends DbxFirebaseCollectionLoaderAccessor<any>> {
+    readonly watcher: DbxFirebaseCollectionChangeWatcher<S> & Partial<Destroyable>;
+    /**
+     * Whether or not to also destroy the watcher when the trigger instance is destroyed.
+     *
+     * Defaults to false.
+     */
+    readonly destroyWatcherOnDestroy?: boolean;
+    /**
+     * Initial trigger function to use.
+     *
+     * By default restarts the store.
+     */
+    readonly triggerFunction?: Maybe<DbxFirebaseCollectionChangeTriggerFunction<S>>;
+}
+interface DbxFirebaseCollectionChangeTrigger<S extends DbxFirebaseCollectionLoaderAccessor<any>> {
+    readonly watcher: DbxFirebaseCollectionChangeWatcher<S>;
+    setTriggerFunction?: Maybe<DbxFirebaseCollectionChangeTriggerFunction<S>>;
+}
+declare class DbxFirebaseCollectionChangeTriggerInstance<S extends DbxFirebaseCollectionLoaderAccessor<any>> implements DbxFirebaseCollectionChangeTrigger<S>, Initialized, Destroyable {
+    readonly watcher: DbxFirebaseCollectionChangeWatcher<S>;
+    private readonly _config;
+    private readonly _triggerFunction;
+    private readonly _sub;
+    constructor(config: DbxFirebaseCollectionChangeTriggerInstanceConfig<S>);
+    get config(): DbxFirebaseCollectionChangeTriggerInstanceConfig<S>;
+    init(): void;
+    destroy(): void;
+    get triggerFunction(): Maybe<DbxFirebaseCollectionChangeTriggerFunction<S>>;
+    set triggerFunction(triggerFunction: Maybe<DbxFirebaseCollectionChangeTriggerFunction<S>>);
+}
+/**
+ * Creates a new DbxFirebaseCollectionChangeWatcher, set the modes to "auto", and creates a new DbxFirebaseCollectionChangeTriggerInstance.
+ *
+ * If no trigger function is provided it will default to resetting the store.
+ *
+ * NOTE: Don't forget to initialize the DbxFirebaseCollectionChangeTriggerInstance and handle other lifecycle changes.
+ *
+ * @param store
+ * @param triggerFunction
+ * @returns
+ */
+declare function dbxFirebaseCollectionChangeTriggerForStore<S extends DbxFirebaseCollectionLoaderAccessor<any>>(store: S, triggerFunction?: Maybe<DbxFirebaseCollectionChangeTriggerFunction<S>>): DbxFirebaseCollectionChangeTriggerInstance<S>;
+declare function dbxFirebaseCollectionChangeTriggerForWatcher<S extends DbxFirebaseCollectionLoaderAccessor<any>>(watcher: DbxFirebaseCollectionChangeWatcher<S>, triggerFunction?: Maybe<DbxFirebaseCollectionChangeTriggerFunction<S>>): DbxFirebaseCollectionChangeTriggerInstance<S>;
+declare function dbxFirebaseCollectionChangeTrigger<S extends DbxFirebaseCollectionLoaderAccessor<any>>(config: DbxFirebaseCollectionChangeTriggerInstanceConfig<S>): DbxFirebaseCollectionChangeTriggerInstance<S>;
+
+/**
+ * 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.).
+ */
+type DbxFirebaseCollectionMode = 'query' | 'references';
+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>>;
+    /**
+     * Whether or not to wait for non-null constraints before beginning the iteration.
+     *
+     * Defaults to true.
+     */
+    readonly waitForNonNullConstraints?: Maybe<boolean>;
+}
+type DbxFirebaseCollectionLoaderInstanceData<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> = DbxFirebaseCollectionLoaderAccessor<T>;
+/**
+ * DbxFirebaseModelLoader implementation within an instance.
+ */
+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, _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, _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>;
+    readonly firestoreIteration$: Observable<FirestoreItemPageIterationInstance<T>>;
+    readonly queryChangeWatcher$: Observable<IterationQueryDocChangeWatcher<T>>;
+    readonly snapshotAccumulator$: Observable<FirebaseQuerySnapshotAccumulator<T>>;
+    readonly hasNext$: Observable<boolean>;
+    readonly canLoadMore$: Observable<boolean>;
+    readonly hasNextAndCanLoadMore$: Observable<boolean>;
+    readonly snapshotAccumulatorDocumentRefs$: Observable<DocumentReference<T>[][]>;
+    readonly snapshotAccumulatorDocuments$: Observable<D[][]>;
+    readonly accumulator$: Observable<FirebaseQueryItemAccumulator<T>>;
+    readonly accumulatorPage$: Observable<PageNumber>;
+    /**
+     * Passthrough for currentAllItems$ from the accumulator.
+     */
+    readonly currentAccumulatorItems$: Observable<DocumentDataWithIdAndKey<T>[][]>;
+    /**
+     * Passthrough for allItems$ from the accumulator.
+     */
+    readonly accumulatorItems$: Observable<DocumentDataWithIdAndKey<T>[][]>;
+    /**
+     * Returns true if the first page result has one or more documents.
+     */
+    readonly hasDocuments$: Observable<boolean>;
+    readonly allDocumentRefs$: Observable<DocumentReference<T>[]>;
+    readonly allDocuments$: Observable<D[]>;
+    readonly allDocumentData$: Observable<DocumentDataWithIdAndKey<T>[]>;
+    readonly pageLoadingState$: Observable<PageListLoadingState<DocumentDataWithIdAndKey<T>>>;
+    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>;
+    set itemsPerPage(itemsPerPage: Maybe<number>);
+    get constraints(): Maybe<ArrayOrValue<FirestoreQueryConstraint>>;
+    set constraints(constraints: Maybe<ArrayOrValue<FirestoreQueryConstraint>>);
+    get waitForNonNullConstraints(): Maybe<boolean>;
+    set waitForNonNullConstraints(waitForNonNullConstraints: Maybe<boolean>);
+    get collection(): Maybe<FirestoreCollectionLike<T, D>>;
+    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;
+    setWaitForNonNullConstraints(waitForNonNullConstraints: Maybe<boolean>): void;
+    setCollection(firestoreCollection: Maybe<FirestoreCollectionLike<T, D>>): void;
+    loadPagesUntilResultsCount(maxResultsLimit: GetterOrValue<number>, countResultsFunction?: FirebaseQueryItemAccumulatorNextPageUntilResultsCountFunction<T> | undefined): Observable<ItemAccumulatorNextPageUntilResultsCountResult>;
+    loadToPage(page: PageNumber): Observable<PageNumber>;
+    loadAllResults(): Observable<PageNumber>;
+}
+declare function dbxFirebaseCollectionLoaderInstance<T, D extends FirestoreDocument<T> = FirestoreDocument<T>>(config: DbxFirebaseCollectionLoaderInstanceInitConfig<T, D>): DbxFirebaseCollectionLoaderInstance<T, D>;
+declare function dbxFirebaseCollectionLoaderInstanceWithCollection<T, D extends FirestoreDocument<T> = FirestoreDocument<T>>(collection: Maybe<FirestoreCollectionLike<T, D>>): DbxFirebaseCollectionLoaderInstance<T, D>;
+
+/**
+ * Abstract type that loads document snapshots from keys, refs, or documents.
+ */
+interface DbxLimitedFirebaseDocumentLoader<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>> {
+    /**
+     * Keys of the documents
+     */
+    readonly keys$: Observable<FirestoreModelKey[]>;
+    /**
+     * Refs of the documents
+     */
+    readonly refs$: Observable<DocumentReference<T>[]>;
+    /**
+     * Ids of the documents
+     */
+    readonly ids$: Observable<FirestoreModelId[]>;
+    /**
+     * Documents to load.
+     */
+    readonly documents$: Observable<D[]>;
+    /**
+     * Snapshots of the documents
+     */
+    readonly snapshots$: Observable<DocumentSnapshot<T>[]>;
+    /**
+     * Data from the documents.
+     */
+    readonly data$: Observable<DocumentDataWithIdAndKey<T>[]>;
+    /**
+     * Snapshot stream of the documents
+     */
+    readonly snapshotsStream$: Observable<DocumentSnapshot<T>[]>;
+    /**
+     * Data stream of the documents.
+     */
+    readonly dataStream$: Observable<DocumentDataWithIdAndKey<T>[]>;
+    /**
+     * Loading state for the document data.
+     */
+    readonly pageLoadingState$: Observable<PageListLoadingState<DocumentDataWithIdAndKey<T>>>;
+    /**
+     * Loading state for the streamed document data.
+     */
+    readonly pageLoadingStateStream$: Observable<PageListLoadingState<DocumentDataWithIdAndKey<T>>>;
+    /**
+     * Sets the keys of the models to load.
+     *
+     * @param constraints
+     */
+    setKeys(keys: Maybe<ObservableOrValue<ArrayOrValue<FirestoreModelKey>>>): void;
+    /**
+     * Sets the document references to load.
+     *
+     * @param constraints
+     */
+    setRefs(refs: Maybe<ObservableOrValue<ArrayOrValue<DocumentReference<T>>>>): void;
+    /**
+     * Sets the documents to load from.
+     *
+     * @param constraints
+     */
+    setDocuments(docs: Maybe<ObservableOrValue<ArrayOrValue<D>>>): void;
+}
+interface DbxFirebaseDocumentLoader<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends DbxLimitedFirebaseDocumentLoader<T, D> {
+    /**
+     * Sets the ids of the models to load.
+     *
+     * @param constraints
+     */
+    setIds(ids: Maybe<ObservableOrValue<ArrayOrValue<FirestoreModelId>>>): void;
+}
+
+interface DbxFirebaseDocumentLoaderInstanceInitConfig<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends LimitedFirestoreDocumentAccessor<T, D> = LimitedFirestoreDocumentAccessor<T, D>> {
+    readonly accessor: A;
+}
+/**
+ * DbxLimitedFirebaseDocumentLoader implementation within an instance.
+ */
+declare class DbxLimitedFirebaseDocumentLoaderInstance<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends LimitedFirestoreDocumentAccessor<T, D> = LimitedFirestoreDocumentAccessor<T, D>> implements DbxLimitedFirebaseDocumentLoader<T>, Destroyable {
+    readonly accessor: A;
+    protected readonly _documents: BehaviorSubject<Maybe<D[]>>;
+    protected readonly _restart: Subject<void>;
+    protected readonly _sub: SubscriptionObject<rxjs.Unsubscribable>;
+    readonly documents$: Observable<D[]>;
+    readonly keys$: Observable<string[]>;
+    readonly ids$: Observable<string[]>;
+    readonly refs$: Observable<DocumentReference<unknown>[]>;
+    readonly snapshots$: Observable<DocumentSnapshot<T>[]>;
+    readonly data$: Observable<DocumentDataWithIdAndKey<T>[]>;
+    /**
+     * Snapshot stream of the documents
+     */
+    readonly snapshotsStream$: Observable<DocumentSnapshot<T>[]>;
+    /**
+     * Data streamd of the documents.
+     */
+    readonly dataStream$: Observable<DocumentDataWithIdAndKey<T>[]>;
+    readonly pageLoadingState$: Observable<PageListLoadingState<DocumentDataWithIdAndKey<T>>>;
+    readonly pageLoadingStateStream$: Observable<PageListLoadingState<DocumentDataWithIdAndKey<T>>>;
+    constructor(initConfig: DbxFirebaseDocumentLoaderInstanceInitConfig<T, D, A>);
+    destroy(): void;
+    restart(): void;
+    setKeys(keys: Maybe<ObservableOrValue<ArrayOrValue<FirestoreModelKey>>>): void;
+    setRefs(refs: Maybe<ObservableOrValue<ArrayOrValue<DocumentReference<T>>>>): void;
+    setDocuments(docs: Maybe<ObservableOrValue<ArrayOrValue<D>>>): void;
+}
+declare function dbxLimitedFirebaseDocumentLoaderInstance<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends LimitedFirestoreDocumentAccessor<T, D> = LimitedFirestoreDocumentAccessor<T, D>>(config: DbxFirebaseDocumentLoaderInstanceInitConfig<T, D, A>): DbxLimitedFirebaseDocumentLoaderInstance<T, D, A>;
+declare function dbxLimitedFirebaseDocumentLoaderInstanceWithAccessor<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends LimitedFirestoreDocumentAccessor<T, D> = LimitedFirestoreDocumentAccessor<T, D>>(accessor: A): DbxLimitedFirebaseDocumentLoaderInstance<T, D, A>;
+declare class DbxFirebaseDocumentLoaderInstance<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends FirestoreDocumentAccessor<T, D> = FirestoreDocumentAccessor<T, D>> extends DbxLimitedFirebaseDocumentLoaderInstance<T, D, A> implements DbxFirebaseDocumentLoader<T>, Destroyable {
+    setIds(ids: Maybe<ObservableOrValue<ArrayOrValue<FirestoreModelKey>>>): void;
+}
+declare function dbxFirebaseDocumentLoaderInstance<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends FirestoreDocumentAccessor<T, D> = FirestoreDocumentAccessor<T, D>>(config: DbxFirebaseDocumentLoaderInstanceInitConfig<T, D, A>): DbxFirebaseDocumentLoaderInstance<T, D, A>;
+declare function dbxFirebaseDocumentLoaderInstanceWithAccessor<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends FirestoreDocumentAccessor<T, D> = FirestoreDocumentAccessor<T, D>>(accessor: A): DbxFirebaseDocumentLoaderInstance<T, D, A>;
+
+/**
+ * Service instance that exposes roles for a specific model.
+ */
+interface DbxFirebaseInContextFirebaseModelRolesServiceInstance<R extends GrantedRole = GrantedRole> {
+    readonly key$: Observable<FirestoreModelKey>;
+    readonly roleReader$: Observable<GrantedRoleMapReader<R>>;
+    readonly roleMap$: Observable<GrantedRoleMap<R>>;
+    readonly hasNoAccess$: Observable<boolean>;
+    truthMap<M extends GrantedRoleTruthMapObject<any, R>>(input: M): Observable<GrantedRoleTruthMap<M>>;
+    hasAnyRoles(roles: IterableOrValue<R>): Observable<boolean>;
+    hasAllRoles(roles: IterableOrValue<R>): Observable<boolean>;
+    hasRoles(setIncludes: SetIncludesMode, roles: IterableOrValue<R>): Observable<boolean>;
+    containsAnyRoles(roles: IterableOrValue<R>): Observable<boolean>;
+    containsAllRoles(roles: IterableOrValue<R>): Observable<boolean>;
+    containsRoles(setIncludes: SetIncludesMode, roles: IterableOrValue<R>): Observable<boolean>;
+}
+/**
+ * DbxFirebaseInContextFirebaseModelRolesServiceInstance extension that provides access to the underlying model.
+ */
+interface DbxFirebaseInContextFirebaseModelInfoServiceInstance<D extends FirestoreDocument<any>, R extends GrantedRole = GrantedRole> extends DbxFirebaseInContextFirebaseModelRolesServiceInstance<R> {
+    readonly modelType$: Observable<FirestoreModelType>;
+    readonly model$: Observable<D>;
+    /**
+     * Reads the data from the model once and returns the current state without streaming, if it exists or can be retrieved.
+     */
+    readonly snapshotData$: Observable<Maybe<FirestoreDocumentData<D>>>;
+    snapshotStream(mode: FirestoreAccessorStreamMode): Observable<DocumentSnapshot<FirestoreDocumentData<D>>>;
+    snapshotDataStream(mode: FirestoreAccessorStreamMode, options?: SnapshotOptions): Observable<FirestoreDocumentData<D>>;
+}
+
+type DbxFirebaseInContextFirebaseModelServiceInstanceFactory<S extends InContextFirebaseModelsService<any>, C extends FirebasePermissionErrorContext = FirebasePermissionErrorContext> = <D extends FirestoreDocument<any>, R extends GrantedRole = GrantedRole>(type: S extends InContextFirebaseModelsService<infer Y> ? (Y extends FirebaseModelsService<infer X, infer C> ? keyof X : never) : never, keyObs: ObservableOrValue<ModelKey>) => DbxFirebaseInContextFirebaseModelServiceInstance<D, R, C>;
+declare function dbxFirebaseInContextFirebaseModelServiceInstanceFactory<S extends InContextFirebaseModelsService<any>, C extends FirebasePermissionErrorContext = FirebasePermissionErrorContext>(context$: Observable<S>): DbxFirebaseInContextFirebaseModelServiceInstanceFactory<S, C>;
+interface DbxFirebaseInContextFirebaseModelServiceInstance<D extends FirestoreDocument<any>, R extends GrantedRole = GrantedRole, C extends FirebasePermissionErrorContext = FirebasePermissionErrorContext> extends DbxFirebaseInContextFirebaseModelInfoServiceInstance<D, R> {
+    readonly modelService$: Observable<InModelContextFirebaseModelService<C, FirestoreDocumentData<D>, D, R>>;
+}
+/**
+ * Creates a new DbxFirebaseInContextFirebaseModelServiceInstance.
+ *
+ * Wraps an InModelContextFirebaseModelService observable and provides different piped observables.
+ */
+declare function dbxFirebaseInContextFirebaseModelServiceInstance<D extends FirestoreDocument<any>, R extends GrantedRole = GrantedRole, C extends FirebasePermissionErrorContext = FirebasePermissionErrorContext>(modelService$: Observable<InModelContextFirebaseModelService<C, FirestoreDocumentData<D>, D, R>>): DbxFirebaseInContextFirebaseModelServiceInstance<D, R, C>;
+
+/**
+ * Used for retrieving contexts for a specific model type/identity.
+ */
+declare abstract class DbxFirebaseModelContextService {
+    /**
+     * Creates a new DbxFirebaseInContextFirebaseModelInfoServiceInstance for the input model key.
+     *
+     * @param key$
+     */
+    abstract modelInfoInstance<D extends FirestoreDocument<any> = any, R extends GrantedRole = GrantedRole>(keyObs: ObservableOrValue<FirestoreModelKey>): Observable<DbxFirebaseInContextFirebaseModelInfoServiceInstance<D, R>>;
+}
+type DbxFirebaseModelContextServiceInfoInstanceFactory = <D extends FirestoreDocument<any>, R extends GrantedRole = GrantedRole>(keyObs: ObservableOrValue<FirestoreModelKey>) => Observable<DbxFirebaseInContextFirebaseModelInfoServiceInstance<D, R>>;
+interface DbxFirebaseModelContextServiceInfoInstanceFactoryConfig<S extends InContextFirebaseModelsService<any>, C extends FirebasePermissionErrorContext = FirebasePermissionErrorContext> {
+    readonly modelService: DbxFirebaseInContextFirebaseModelServiceInstanceFactory<S, C>;
+    readonly entityMap$: Observable<FirestoreModelIdentityTypeMap>;
+}
+declare function dbxFirebaseModelContextServiceInfoInstanceFactory<S extends InContextFirebaseModelsService<any>, C extends FirebasePermissionErrorContext = FirebasePermissionErrorContext>(config: DbxFirebaseModelContextServiceInfoInstanceFactoryConfig<S, C>): DbxFirebaseModelContextServiceInfoInstanceFactory;
+/**
+ * Operator function that builds a FirestoreModelIdentityTypeMap from the input context and shares the replay.
+ *
+ * Since the output won't change with different contexts, the map is built once and then shared.
+ *
+ * @returns
+ */
+declare function firebaseContextServiceEntityMap<T extends InContextFirebaseModelsService<any>>(): OperatorFunction<T, FirestoreModelIdentityTypeMap>;
+
+/**
+ * Factory function for creating a DbxFirebaseModelContextService instance.
+ */
+type DbxFirebaseModelContextServiceFactory<T extends DbxFirebaseModelContextService> = (injector: Injector) => T;
+interface ProvideDbxFirebaseModelContextServiceConfig<T extends DbxFirebaseModelContextService> {
+    readonly dbxFirebaseModelContextServiceClass: ClassType<T>;
+    readonly dbxFirebaseModelContextServiceFactory?: DbxFirebaseModelContextServiceFactory<T>;
+}
+/**
+ * Creates EnvironmentProviders that provides a DbxFirebaseModelContextService and the configured class instance.
+ *
+ * @param config Configuration
+ * @returns EnvironmentProviders
+ */
+declare function provideDbxFirebaseModelContextService<T extends DbxFirebaseModelContextService>(config: ProvideDbxFirebaseModelContextServiceConfig<T>): EnvironmentProviders;
+
+/**
+ * Configuration provided in the root module for configuring entries.
+ */
+declare abstract class DbxFirebaseModelTypesServiceConfig {
+    /**
+     * Entries to register.
+     */
+    abstract entries: DbxFirebaseModelTypesServiceEntry[];
+}
+interface DbxFirebaseModelTypesServiceEntry<T = unknown> extends Omit<DbxModelTypeInfo, 'canSegueToView' | 'modelType'> {
+    /**
+     * Identity of the item being registered.
+     */
+    readonly identity: FirestoreModelIdentity;
+    /**
+     * Creates the DbxFirebaseModelDisplayInfo for the input data.
+     *
+     * If no icon is provided, it uses the default icon configured in this entry.
+     *
+     * @param value
+     * @returns
+     */
+    readonly displayInfoFactory: FactoryWithRequiredInput<DbxFirebaseModelDisplayInfo, T>;
+}
+type DbxFirebaseModelDisplayInfo = IconAndTitle;
+interface DbxFirebaseModelTypeInfo<T = unknown> extends DbxModelTypeInfo, Pick<DbxFirebaseModelTypesServiceEntry<T>, 'identity' | 'displayInfoFactory'> {
+}
+type DbxFirebaseModelTypesMap = DbxModelTypesMap<DbxFirebaseModelTypeInfo>;
+/**
+ * Provides model type information about models registered within Firebase.
+ *
+ * Automatically configures the DbxModelTypesService.
+ */
+declare class DbxFirebaseModelTypesService {
+    readonly dbxFirebaseModelContextService: DbxFirebaseModelContextService;
+    readonly dbxModelTypesService: DbxModelTypesService<any>;
+    constructor(initialConfig: DbxFirebaseModelTypesServiceConfig);
+    getDisplayInfo<T>(typeInfo: DbxFirebaseModelTypeInfo<T>, data: T): DbxFirebaseModelDisplayInfo;
+    getDefaultDisplayInfo<T = unknown>(typeInfo: DbxFirebaseModelTypeInfo<T>): {
+        title: string;
+        icon: string;
+    };
+    register(entries: ArrayOrValue<DbxFirebaseModelTypesServiceEntry>): void;
+    currentInfoForType(type: FirestoreCollectionType): Observable<Maybe<DbxFirebaseModelTypeInfo>>;
+    infoForType(type: FirestoreCollectionType): Observable<DbxFirebaseModelTypeInfo>;
+    instanceForKey<D extends FirestoreDocument<any> = any, R extends GrantedRole = GrantedRole>(key$: ObservableOrValue<FirestoreModelKey>): DbxFirebaseModelTypesServiceInstance<D, R>;
+    instancePairsForKeys(keys: ArrayOrValue<ObservableOrValue<FirestoreModelKey>>): Observable<DbxFirebaseModelTypesServiceInstancePair<any, string>[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelTypesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseModelTypesService>;
+}
+/**
+ * Information pair for an instance.
+ */
+interface DbxFirebaseModelTypesServiceInstancePair<D extends FirestoreDocument<any> = any, R extends GrantedRole = GrantedRole> {
+    readonly key: FirestoreModelKey;
+    readonly instance: DbxFirebaseModelTypesServiceInstance<D, R>;
+    readonly displayInfo: DbxFirebaseModelDisplayInfo;
+    readonly segueRef: Maybe<ClickableAnchorLinkSegueRef>;
+}
+type DbxFirebaseModelTypesServiceInstancePairForKeysFactory = (keys: ArrayOrValue<ObservableOrValue<FirestoreModelKey>>) => Observable<DbxFirebaseModelTypesServiceInstancePair[]>;
+declare function dbxFirebaseModelTypesServiceInstancePairForKeysFactory(service: DbxFirebaseModelTypesService): DbxFirebaseModelTypesServiceInstancePairForKeysFactory;
+/**
+ * DbxFirebaseModelTypesService instance
+ */
+interface DbxFirebaseModelTypesServiceInstance<D extends FirestoreDocument<any> = any, R extends GrantedRole = GrantedRole> {
+    readonly modelInfoInstance$: Observable<DbxFirebaseInContextFirebaseModelInfoServiceInstance<D, R>>;
+    readonly dbxFirebaseModelTypesService: DbxFirebaseModelTypesService;
+    readonly key$: Observable<string>;
+    readonly modelType$: Observable<string>;
+    readonly snapshotData$: Observable<Maybe<FirestoreDocumentData<D>>>;
+    readonly safeTypeInfo$: Observable<Maybe<DbxFirebaseModelTypeInfo<unknown>>>;
+    readonly typeInfo$: Observable<DbxFirebaseModelTypeInfo<unknown>>;
+    readonly identity$: Observable<FirestoreModelIdentity>;
+    readonly segueRef$: Observable<Maybe<SegueRef>>;
+    readonly displayInfo$: Observable<DbxFirebaseModelDisplayInfo>;
+    readonly clickableSegueRef$: Observable<Maybe<ClickableAnchorLinkSegueRef>>;
+    readonly safeInstancePair$: Observable<Maybe<DbxFirebaseModelTypesServiceInstancePair>>;
+    readonly instancePair$: Observable<DbxFirebaseModelTypesServiceInstancePair>;
+}
+declare function dbxFirebaseModelTypesServiceInstance<D extends FirestoreDocument<any> = any, R extends GrantedRole = GrantedRole>(modelInfoInstance$: Observable<DbxFirebaseInContextFirebaseModelInfoServiceInstance<D, R>>, dbxFirebaseModelTypesService: DbxFirebaseModelTypesService): DbxFirebaseModelTypesServiceInstance<D, R>;
+
+interface DbxFirebaseModelTrackerFilterItem {
+    readonly instancePair: DbxFirebaseModelTypesServiceInstancePair;
+    readonly identity: FirestoreModelIdentity;
+}
+interface DbxFirebaseModelTrackerHistoryFilter {
+    /**
+     * Whether or not to exclude the values instead of include them.
+     */
+    readonly invertFilter?: boolean;
+    /**
+     * Identity types to filter on.
+     */
+    readonly identity?: Maybe<ArrayOrValue<FirestoreModelIdentity>>;
+    /**
+     * Arbitrary filter function to filter individual items.
+     */
+    readonly filterItem?: ObservableDecisionFunction<DbxFirebaseModelTrackerFilterItem>;
+}
+declare class DbxFirebaseModelTrackerService {
+    readonly dbxModelTrackerService: DbxModelTrackerService;
+    readonly dbxFirebaseModelTypesService: DbxFirebaseModelTypesService;
+    readonly historyKeys$: Observable<string[]>;
+    readonly historyPairs$: Observable<DbxFirebaseModelTypesServiceInstancePair<any, string>[]>;
+    readonly filterItemHistoryPairs$: Observable<DbxFirebaseModelTrackerFilterItem[]>;
+    /**
+     * Filters from historyPairs$ using the input filter configuration, if it is provided.
+     *
+     * @param filter
+     * @returns
+     */
+    filterHistoryPairs(filter?: Maybe<DbxFirebaseModelTrackerHistoryFilter>): Observable<DbxFirebaseModelTypesServiceInstancePair[]>;
+    loadHistoryKeys(): Observable<string[]>;
+    loadHistoryPairs(): Observable<DbxFirebaseModelTypesServiceInstancePair[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelTrackerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseModelTrackerService>;
+}
+
+declare class DbxFirebaseModelHistoryComponent {
+    readonly dbxFirebaseModelTrackerService: DbxFirebaseModelTrackerService;
+    readonly anchorForItem: i0.InputSignal<Maybe<AnchorForValueFunction<DbxFirebaseModelTypesServiceInstancePair<any, string>>>>;
+    readonly historyFilter: i0.InputSignal<Maybe<DbxFirebaseModelTrackerHistoryFilter>>;
+    readonly historyPairs$: Observable<DbxFirebaseModelTypesServiceInstancePair<any, string>[]>;
+    readonly state: Observable<ListLoadingState<DbxFirebaseModelTypesServiceInstancePair>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelHistoryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseModelHistoryComponent, "dbx-firebase-model-history", never, { "anchorForItem": { "alias": "anchorForItem"; "required": false; "isSignal": true; }; "historyFilter": { "alias": "historyFilter"; "required": false; "isSignal": true; }; }, {}, never, ["[empty]"], true, never>;
+}
+
+interface DbxFirebaseModelHistoryPopoverConfig {
+    /**
+     * Custom icon
+     *
+     * Defaults to "history"
+     */
+    readonly icon?: string;
+    /**
+     * Custom header text
+     *
+     * Defaults to "History"
+     */
+    readonly header?: string;
+    /**
+     * Custom empty text when no items exist.
+     */
+    readonly emptyText?: string;
+    /**
+     * Origin to add the popover to.
+     */
+    readonly origin: ElementRef;
+    /**
+     * Optional config to pass to the DbxFirebaseHistoryComponent
+     */
+    readonly historyFilter?: Maybe<DbxFirebaseModelTrackerHistoryFilter>;
+    /**
+     * Anchor
+     */
+    readonly anchorForItem?: Maybe<AnchorForValueFunction<DbxFirebaseModelTypesServiceInstancePair>>;
+}
+type DbxFirebaseModelHistoryPopoverConfigWithoutOrigin = Omit<DbxFirebaseModelHistoryPopoverConfig, 'origin'>;
+declare const DEFAULT_DBX_FIREBASE_MODEL_HISTORY_COMPONENT_POPOVER_KEY = "history";
+declare class DbxFirebaseModelHistoryPopoverComponent extends AbstractPopoverDirective<unknown, DbxFirebaseModelHistoryPopoverConfig> {
+    static openPopover(popupService: DbxPopoverService, { origin, header, icon, emptyText, historyFilter, anchorForItem }: DbxFirebaseModelHistoryPopoverConfig, popoverKey?: DbxPopoverKey): NgPopoverRef;
+    get config(): DbxFirebaseModelHistoryPopoverConfig;
+    readonly icon: string;
+    readonly header: string;
+    readonly emptyText: string;
+    readonly historyFilter: Maybe<DbxFirebaseModelTrackerHistoryFilter>;
+    readonly anchorForItem: Maybe<AnchorForValueFunction<DbxFirebaseModelTypesServiceInstancePair<any, string>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelHistoryPopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseModelHistoryPopoverComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+type DbxFirebaseModelHistoryPopoverButtonConfig = DbxFirebaseModelHistoryPopoverConfigWithoutOrigin;
+declare class DbxFirebaseModelHistoryPopoverButtonComponent extends AbstractPopoverRefDirective<unknown, unknown> {
+    private readonly _dbxPopoverService;
+    readonly buttonElement: i0.Signal<ElementRef<any>>;
+    readonly config: i0.InputSignal<DbxFirebaseModelHistoryPopoverConfigWithoutOrigin | undefined>;
+    protected _makePopoverRef(origin?: Maybe<ElementRef>): NgPopoverRef<unknown, unknown>;
+    showHistoryPopover(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelHistoryPopoverButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseModelHistoryPopoverButtonComponent, "dbx-firebase-model-history-popover-button", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface DbxFirebaseSourceSelectLoadSourceConfig<M, D extends FirestoreDocument<any> = any, R extends GrantedRole = GrantedRole> extends Pick<DbxFirebaseModelTrackerHistoryFilter, 'filterItem'> {
+    /**
+     * Source label. Defaults to "History".
+     */
+    readonly label?: string;
+    /**
+     * Type of model to pull from the history.
+     */
+    readonly identity: FirestoreModelIdentity;
+    /**
+     * Maps a result instance to the target meta type
+     */
+    readonly mapToMeta: MapFunction<DbxFirebaseModelTypesServiceInstancePair<D, R>, Observable<M>>;
+    /**
+     * Tracker service to load history values from.
+     */
+    readonly dbxFirebaseModelTrackerService: DbxFirebaseModelTrackerService;
+}
+/**
+ * Configures a SourceSelectLoadSource using the DbxFirebaseModelTrackerService to load models of a specific identity.
+ *
+ * @param config
+ * @returns
+ */
+declare function dbxFirebaseSourceSelectLoadSource<M>(config: DbxFirebaseSourceSelectLoadSourceConfig<M>): SourceSelectLoadSource<M>;
+
+/**
+ * Provides read-only accessors to a single model/document.
+ */
+interface DbxFirebaseDocumentReadOnlyStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> {
+    /**
+     * String used to identify the store. Typically only for debugging UI purposes.
+     */
+    readonly storeName$: Observable<Maybe<string>>;
+    readonly firestoreCollectionLike$: Observable<FirestoreCollectionLike<T, D>>;
+    readonly firestoreCollection$: Observable<FirestoreCollection<T, D>>;
+    readonly currentInputId$: Observable<Maybe<FirestoreModelId>>;
+    readonly inputId$: Observable<FirestoreModelId>;
+    readonly currentInputKey$: Observable<Maybe<FirestoreModelKey>>;
+    readonly inputKey$: Observable<FirestoreModelKey>;
+    readonly currentInputRef$: Observable<Maybe<DocumentReference<T>>>;
+    readonly inputRef$: Observable<DocumentReference<T>>;
+    readonly streamMode$: Observable<FirestoreAccessorStreamMode>;
+    readonly currentDocument$: Observable<Maybe<D>>;
+    readonly document$: Observable<D>;
+    readonly currentId$: Observable<Maybe<FirestoreModelId>>;
+    readonly currentKey$: Observable<Maybe<FirestoreModelKey>>;
+    readonly id$: Observable<FirestoreModelId>;
+    readonly key$: Observable<FirestoreModelKey>;
+    readonly ref$: Observable<DocumentReference<T>>;
+    readonly hasRef$: Observable<boolean>;
+    readonly flatKey$: Observable<FlatFirestoreModelKey>;
+    readonly twoWayFlatKey$: Observable<TwoWayFlatFirestoreModelKey>;
+    readonly keyModelIds$: Observable<FirestoreModelId[]>;
+    readonly keyPairs$: Observable<FirestoreModelCollectionAndIdPair[]>;
+    readonly keyPairObject$: Observable<FirestoreModelCollectionAndIdPairObject>;
+    readonly documentLoadingState$: Observable<LoadingState<D>>;
+    readonly snapshot$: Observable<DocumentSnapshot<T>>;
+    readonly snapshotLoadingState$: Observable<LoadingState<DocumentSnapshot<T>>>;
+    readonly currentData$: Observable<Maybe<DocumentDataWithIdAndKey<T>>>;
+    readonly data$: Observable<DocumentDataWithIdAndKey<T>>;
+    readonly dataLoadingState$: Observable<LoadingState<DocumentDataWithIdAndKey<T>>>;
+    readonly isLoadingData$: Observable<boolean>;
+    readonly currentExists$: Observable<boolean>;
+    readonly exists$: Observable<boolean>;
+    readonly modelIdentity$: Observable<FirestoreModelIdentity>;
+}
+/**
+ * Provides accessors to a single model/document.
+ */
+interface DbxFirebaseDocumentStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends DbxFirebaseDocumentReadOnlyStore<T, D>, LockSetComponent {
+    /**
+     * Sets the name of the store.
+     */
+    readonly setStoreName: (observableOrValue: ObservableOrValue<Maybe<string>>) => Subscription;
+    /**
+     * Sets the id of the document to load.
+     */
+    readonly setId: (observableOrValue: ObservableOrValue<Maybe<FirestoreModelId>>) => Subscription;
+    /**
+     * Sets the key of the document to load.
+     */
+    readonly setKey: (observableOrValue: ObservableOrValue<Maybe<FirestoreModelKey>>) => Subscription;
+    /**
+     * Sets the key of the document to load using a TwoWayFlatFirestoreModelKey.
+     */
+    readonly setFlatKey: (observableOrValue: ObservableOrValue<Maybe<TwoWayFlatFirestoreModelKey>>) => Subscription;
+    /**
+     * Sets the ref of the document to load.
+     */
+    readonly setRef: (observableOrValue: ObservableOrValue<Maybe<DocumentReference<T>>>) => Subscription;
+    /**
+     * Clears the key/id/ref and current document from the store.
+     */
+    readonly clearRefs: () => void;
+    /**
+     * Sets the stream mode.
+     */
+    readonly setStreamMode: (observableOrValue: ObservableOrValue<FirestoreAccessorStreamMode>) => Subscription;
+    /**
+     * Sets the FirestoreCollection to retrieve documents from.
+     */
+    readonly setFirestoreCollection: (() => void) | ((observableOrValue: ObservableOrValue<Maybe<FirestoreCollection<T, D>>>) => Subscription);
+    /**
+     * Sets the FirestoreCollectionLike to retrieve documents from.
+     */
+    readonly setFirestoreCollectionLike: (() => void) | ((observableOrValue: ObservableOrValue<Maybe<FirestoreCollectionLike<T, D>>>) => Subscription);
+}
+
+/**
+ * Provides a source of entities.
+ */
+declare abstract class DbxFirebaseModelEntitiesSource {
+    /**
+     * Observable of a LoadingState of entity values.
+     */
+    abstract readonly entities$: Observable<LoadingState<DbxFirebaseModelEntity[]>>;
+}
+/**
+ * A model entity.
+ */
+interface DbxFirebaseModelEntity {
+    /**
+     * Model identity for the entity.
+     *
+     * Used for sorting/grouping by expected entity type.
+     */
+    readonly modelIdentity: FirestoreModelIdentity;
+    /**
+     * Optional name for
+     */
+    readonly name?: Maybe<string>;
+    /**
+     * An associated store for the document, if it is available.
+     */
+    readonly store?: Maybe<DbxFirebaseDocumentReadOnlyStore<any, any>>;
+}
+interface DbxFirebaseModelEntityWithStore<T = any, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends DbxFirebaseModelEntity {
+    /**
+     * An associated store for the document, if it is available.
+     */
+    readonly store: DbxFirebaseDocumentReadOnlyStore<T, D>;
+}
+/**
+ * Returns true if the input entity has a defined store.
+ *
+ * @param entity
+ * @returns
+ */
+declare function isDbxFirebaseModelEntityWithStore<T = any, D extends FirestoreDocument<T> = FirestoreDocument<T>>(entity: DbxFirebaseModelEntity): entity is DbxFirebaseModelEntityWithStore<T, D>;
+/**
+ * An entity that has a key.
+ */
+interface DbxFirebaseModelEntityWithKey extends DbxFirebaseModelEntity {
+    /**
+     * The key of the target document.
+     */
+    readonly key: ModelKey;
+}
+/**
+ * An entity that has a key and a store.
+ */
+interface DbxFirebaseModelEntityWithKeyAndStore<T = any, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends Omit<DbxFirebaseModelEntityWithKey, 'store'>, DbxFirebaseModelEntityWithStore<T, D> {
+}
+
+interface DbxFirebaseModelEntitiesWidgetEntry {
+    /**
+     * Widget type to respond to.
+     */
+    readonly identity: FirestoreModelIdentity;
+    /**
+     * The priority to use when sorting the entities.
+     *
+     * Higher values are displayed first in the list.
+     */
+    readonly sortPriority?: Maybe<number>;
+    /**
+     * Widget component that is specific to this entity.
+     */
+    readonly entityComponentClass?: Maybe<Type<unknown>>;
+    /**
+     * Overrides the "common" widget component used for all entities.
+     */
+    readonly commonComponentClass?: Maybe<Type<unknown>>;
+    /**
+     * Optional widget component that is specific to this entity that provides additional debug information, and is displayed after the common widget.
+     */
+    readonly debugComponentClass?: Maybe<Type<unknown>>;
+}
+/**
+ * Configuration provided in the root module for configuring entries.
+ */
+declare abstract class DbxFirebaseModelEntitiesWidgetServiceConfig {
+    /**
+     * Entries to register.
+     */
+    abstract entries: DbxFirebaseModelEntitiesWidgetEntry[];
+    /**
+     * The default "common" widget component used for all entities.
+     */
+    abstract commonComponentClass?: Maybe<Type<unknown>>;
+    /**
+     * The default "debug" widget component used for all entities.
+     */
+    abstract debugComponentClass?: Maybe<Type<unknown>>;
+}
+/**
+ * Service used to register widgets used for model entities.
+ */
+declare class DbxFirebaseModelEntitiesWidgetService {
+    private _commonComponentClass;
+    private _debugComponentClass;
+    private readonly _entries;
+    private readonly _sortPriorityMap;
+    constructor();
+    getCommonComponentClass(): Maybe<Type<unknown>>;
+    setCommonComponentClass(componentClass: Maybe<Type<unknown>>): void;
+    getDebugComponentClass(): Maybe<Type<unknown>>;
+    setDebugComponentClass(componentClass: Maybe<Type<unknown>>): void;
+    /**
+     * Used to register one or more entries.
+     *
+     * If an entry with the same identity is already registered, this will override it by default.
+     *
+     * @param entries The entries to register
+     * @param override Whether to override existing entries (default: true)
+     */
+    register(entries: ArrayOrValue<DbxFirebaseModelEntitiesWidgetEntry>, override?: boolean): void;
+    getAllRegisteredWidgetIdentities(): FirestoreModelIdentity[];
+    getWidgetEntry(identity: FirestoreModelIdentity): DbxFirebaseModelEntitiesWidgetEntry;
+    getWidgetEntries(identities: Iterable<FirestoreModelIdentity>): DbxFirebaseModelEntitiesWidgetEntry[];
+    getSortPriorityMap(): Map<FirestoreModelIdentity, number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelEntitiesWidgetService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseModelEntitiesWidgetService>;
+}
+
+interface DbxFirebaseModelEntitiesComponentAllEntities {
+    readonly entities: DbxFirebaseModelEntityWithKeyAndStore[];
+    readonly registeredEntities: DbxFirebaseModelEntityWithKeyAndStore[];
+    readonly unregisteredEntities: DbxFirebaseModelEntityWithKeyAndStore[];
+    readonly onlyShowRegisteredTypes?: Maybe<boolean>;
+}
+declare class DbxFirebaseModelEntitiesComponent {
+    readonly entitiesWidgetService: DbxFirebaseModelEntitiesWidgetService;
+    /**
+     * Whether the accordion should allow multiple expanded panels.
+     */
+    readonly multi: i0.InputSignal<boolean>;
+    /**
+     * If true, will only show entities that have a registered widget entry.
+     *
+     * Defaults to true.
+     */
+    readonly onlyShowRegisteredTypes: i0.InputSignal<Maybe<boolean>>;
+    /**
+     * If true, will show unregistered entities, even if onlyShowRegisteredTypes is true.
+     */
+    readonly showUnregisteredTypesSignal: i0.WritableSignal<Maybe<boolean>>;
+    readonly onlyShowRegisteredTypesSignal: i0.Signal<Maybe<boolean>>;
+    readonly onlyShowRegisteredTypes$: Observable<Maybe<boolean>>;
+    readonly entities: i0.InputSignal<Observable<LoadingState<DbxFirebaseModelEntity[]>> | undefined>;
+    readonly entities$: Observable<LoadingState<DbxFirebaseModelEntity[]>>;
+    readonly allEntitiesState$: Observable<LoadingState<DbxFirebaseModelEntitiesComponentAllEntities>>;
+    readonly allEntities$: Observable<Maybe<DbxFirebaseModelEntitiesComponentAllEntities>>;
+    readonly allEntitiesSignal: i0.Signal<Maybe<DbxFirebaseModelEntitiesComponentAllEntities>>;
+    readonly entitiesWithKeysSignal: i0.Signal<DbxFirebaseModelEntityWithKeyAndStore<any, _dereekb_firebase.FirestoreDocument<any, _dereekb_firebase.FirestoreModelIdentity>>[] | undefined>;
+    readonly unregisteredEntitiesCountSignal: i0.Signal<number>;
+    readonly showViewUnregisteredEntitiesButtonSignal: i0.Signal<boolean | _dereekb_util.MaybeNot>;
+    readonly hasNoEntitiesSignal: i0.Signal<boolean>;
+    readonly context: _dereekb_rxjs.MutableLoadingStateContext<unknown, LoadingState<DbxFirebaseModelEntitiesComponentAllEntities>, _dereekb_rxjs.LoadingContextEvent & LoadingState<DbxFirebaseModelEntitiesComponentAllEntities>>;
+    clickShowUnregisteredEntities(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelEntitiesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseModelEntitiesComponent, "dbx-firebase-model-entities", never, { "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "onlyShowRegisteredTypes": { "alias": "onlyShowRegisteredTypes"; "required": false; "isSignal": true; }; "entities": { "alias": "entities"; "required": false; "isSignal": true; }; }, {}, never, ["[empty]"], true, never>;
+}
+
+interface DbxFirebaseModelEntitiesPopoverConfig {
+    /**
+     * Custom icon
+     *
+     * Defaults to "history"
+     */
+    readonly icon?: string;
+    /**
+     * Custom header text
+     *
+     * Defaults to "Entities"
+     */
+    readonly header?: string;
+    /**
+     * Custom empty text when no entities exist.
+     */
+    readonly emptyText?: string;
+    /**
+     * Origin to add the popover to.
+     */
+    readonly origin: ElementRef;
+    /**
+     * Observable of entities to display.
+     */
+    readonly entities$: Observable<LoadingState<DbxFirebaseModelEntity[]>>;
+    /**
+     * Whether or not to only show entities that have a registered widget entry.
+     */
+    readonly onlyShowRegisteredTypes?: Maybe<boolean>;
+    /**
+     * Additional popover configuration.
+     */
+    readonly popoverSizingConfig?: Maybe<DbxPopoverConfigSizing>;
+    /**
+     * Injector to use for the popover.
+     */
+    readonly injector?: Maybe<Injector>;
+}
+type DbxFirebaseModelEntitiesPopoverConfigWithoutOrigin = Omit<DbxFirebaseModelEntitiesPopoverConfig, 'origin' | 'entities$'>;
+declare const DEFAULT_DBX_FIREBASE_MODEL_ENTITIES_COMPONENT_POPOVER_KEY = "entities";
+declare class DbxFirebaseModelEntitiesPopoverComponent extends AbstractPopoverDirective<unknown, DbxFirebaseModelEntitiesPopoverConfig> {
+    readonly entities$: Observable<LoadingState<DbxFirebaseModelEntity[]>> | undefined;
+    static openPopover(popupService: DbxPopoverService, config: DbxFirebaseModelEntitiesPopoverConfig, popoverKey?: DbxPopoverKey): NgPopoverRef;
+    get config(): DbxFirebaseModelEntitiesPopoverConfig;
+    readonly icon: string;
+    readonly header: string;
+    readonly emptyText: string;
+    readonly onlyShowRegisteredTypes: Maybe<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelEntitiesPopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseModelEntitiesPopoverComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+interface DbxFirebaseModelEntitiesPopoverButtonConfig extends DbxFirebaseModelEntitiesPopoverConfigWithoutOrigin {
+    /**
+     * The display configuration for the button.
+     */
+    readonly buttonDisplay?: Maybe<DbxButtonDisplay>;
+    /**
+     * The style configuration for the button.
+     */
+    readonly buttonStyle?: Maybe<DbxButtonStyle>;
+}
+declare class DbxFirebaseModelEntitiesPopoverButtonComponent extends AbstractPopoverRefDirective<unknown, unknown> {
+    private readonly _dbxPopoverService;
+    readonly entitiesSource: DbxFirebaseModelEntitiesSource;
+    readonly buttonElement: i0.Signal<ElementRef<any>>;
+    readonly config: i0.InputSignal<DbxFirebaseModelEntitiesPopoverButtonConfig | undefined>;
+    readonly buttonDisplaySignal: i0.Signal<DbxButtonDisplay>;
+    readonly buttonStyleSignal: i0.Signal<Maybe<DbxButtonStyle>>;
+    protected _makePopoverRef(origin?: Maybe<ElementRef>): NgPopoverRef<unknown, unknown>;
+    showEntitiesPopover(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelEntitiesPopoverButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseModelEntitiesPopoverButtonComponent, "dbx-firebase-model-entities-popover-button", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Factory for DbxFirebaseModelEntitiesWidgetServiceConfig.
+ */
+type DbxFirebaseModelEntitiesWidgetServiceConfigFactory = (injector: Injector) => DbxFirebaseModelEntitiesWidgetServiceConfig;
+/**
+ * Configuration for provideDbxFirebaseModelEntitiesWidgetService().
+ */
+interface ProvideDbxFirebaseModelEntitiesWidgetServiceConfig {
+    /**
+     * Factory for DbxFirebaseModelEntitiesWidgetServiceConfig.
+     */
+    readonly dbxFirebaseModelEntitiesWidgetServiceConfigFactory: DbxFirebaseModelEntitiesWidgetServiceConfigFactory;
+}
+/**
+ * Creates EnvironmentProviders for DbxFirebaseModelEntitiesWidgetService.
+ *
+ * @param config Configuration
+ * @returns EnvironmentProviders
+ */
+declare function provideDbxFirebaseModelEntitiesWidgetService(config: ProvideDbxFirebaseModelEntitiesWidgetServiceConfig): EnvironmentProviders;
+
+/**
+ * A unique number for a store entry.
+ */
+type DbxFirebaseDocumentStoreContextStoreEntryNumber = number;
+/**
+ * A specifiy entry in the store.
+ *
+ * Used for caching information about a specific store.
+ */
+interface DbxFirebaseDocumentStoreContextStoreEntry {
+    /**
+     * The number the entry was assigned when added to the store.
+     */
+    readonly entryNumber: DbxFirebaseDocumentStoreContextStoreEntryNumber;
+    /**
+     * The referenced document store.
+     */
+    readonly store: DbxFirebaseDocumentStore<unknown>;
+    readonly modelIdentity?: Maybe<FirestoreModelIdentity>;
+}
+interface DbxFirebaseDocumentStoreContextStoreEntryWithIdentity extends Omit<DbxFirebaseDocumentStoreContextStoreEntry, 'modelIdentity'> {
+    readonly modelIdentity: FirestoreModelIdentity;
+}
+interface DbxFirebaseDocumentStoreContextStoreState {
+    /**
+     * The next entry number to use for a new store.
+     */
+    readonly nextEntryNumber: DbxFirebaseDocumentStoreContextStoreEntryNumber;
+    /**
+     * The current number of entries
+     */
+    readonly currentEntryCount: number;
+    /**
+     * The map of all current stores.
+     *
+     * The map uses the store as the key for it's corresponding entry that contains additional information about the store.
+     */
+    readonly stores: Map<DbxFirebaseDocumentStore<unknown>, DbxFirebaseDocumentStoreContextStoreEntry>;
+    /**
+     * The last time the stores map was changed.
+     */
+    readonly lastStoresChangeAt: Date;
+}
+declare class DbxFirebaseDocumentStoreContextStore extends ComponentStore<DbxFirebaseDocumentStoreContextStoreState> {
+    constructor();
+    readonly stores$: Observable<Map<DbxFirebaseDocumentStore<unknown, _dereekb_firebase.FirestoreDocument<unknown, FirestoreModelIdentity>>, DbxFirebaseDocumentStoreContextStoreEntry>>;
+    readonly lastStoresChangeAt$: Observable<Maybe<Date>>;
+    readonly entriesGroupedByIdentity$: Observable<DbxFirebaseDocumentStoreContextStoreEntryWithIdentity[]>;
+    readonly addStore: (observableOrValue: DbxFirebaseDocumentStore<unknown, _dereekb_firebase.FirestoreDocument<unknown, FirestoreModelIdentity>> | Observable<DbxFirebaseDocumentStore<unknown, _dereekb_firebase.FirestoreDocument<unknown, FirestoreModelIdentity>>>) => rxjs.Subscription;
+    readonly removeStore: (observableOrValue: DbxFirebaseDocumentStore<unknown, _dereekb_firebase.FirestoreDocument<unknown, FirestoreModelIdentity>> | Observable<DbxFirebaseDocumentStore<unknown, _dereekb_firebase.FirestoreDocument<unknown, FirestoreModelIdentity>>>) => rxjs.Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDocumentStoreContextStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseDocumentStoreContextStore>;
+}
+
+declare const dbxFirebaseDocumentStoreContextModelEntitiesSourceFactory: (storeContextStore: DbxFirebaseDocumentStoreContextStore) => DbxFirebaseModelEntitiesSource;
+declare class DbxFirebaseDocumentStoreContextModelEntitiesSourceDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDocumentStoreContextModelEntitiesSourceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseDocumentStoreContextModelEntitiesSourceDirective, "[dbxFirebaseDocumentStoreContextModelEntitiesSource]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * An abstract DbxFirebase widget component that injects the entity data and provides some common accessors.
+ */
+declare abstract class AbstractDbxFirebaseModelEntityWidgetDirective<T = any, D extends FirestoreDocument<T> = FirestoreDocument<T>> {
+    readonly entityData: DbxFirebaseModelEntityWithStore<T, D>;
+    readonly store: _dereekb_dbx_firebase.DbxFirebaseDocumentReadOnlyStore<T, D>;
+    readonly data$: rxjs.Observable<_dereekb_firebase.DocumentDataWithIdAndKey<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxFirebaseModelEntityWidgetDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxFirebaseModelEntityWidgetDirective<any, any>, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A debug widget component that displays entity data and metadata.
+ */
+declare class DbxFirebaseModelEntitiesDebugWidgetComponent extends AbstractDbxFirebaseModelEntityWidgetDirective {
+    readonly currentKey: Signal<Maybe<string>>;
+    readonly currentData: Signal<any>;
+    readonly contentSignal: Signal<Maybe<DownloadTextContent>>;
+    readonly context: _dereekb_rxjs.MutableLoadingStateContext<unknown, _dereekb_rxjs.LoadingState<any>, _dereekb_rxjs.LoadingContextEvent & _dereekb_rxjs.LoadingState<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelEntitiesDebugWidgetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseModelEntitiesDebugWidgetComponent, "dbx-firebase-model-entities-debug-widget", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Injection token for providing DbxFirebaseModelEntityWithStore context to dynamically loaded widgets.
+ */
+declare const DBX_FIREBASE_MODEL_ENTITY_WITH_STORE_TOKEN: InjectionToken<DbxFirebaseModelEntityWithStore<any, any>>;
+/**
+ * Contains the DbxInjectionComponentConfig for the different injected components a DbxFirebaseModelEntity
+ */
+interface DbxFirebaseModelEntitiesWidgetInjectionConfig {
+    readonly entry: DbxFirebaseModelEntitiesWidgetEntry;
+    readonly entity: DbxFirebaseModelEntityWithStore;
+    readonly entityComponentConfig?: Maybe<DbxInjectionComponentConfig<unknown>>;
+    readonly commonComponentConfig?: Maybe<DbxInjectionComponentConfig<unknown>>;
+    readonly debugComponentConfig?: Maybe<DbxInjectionComponentConfig<unknown>>;
+}
+/**
+ * Factory function used to create a DbxFirebaseModelEntitiesWidgetInjectionConfig given the input.
+ */
+type DbxFirebaseModelEntitiesWidgetInjectionConfigFactory = (entry: DbxFirebaseModelEntitiesWidgetEntry, entity: DbxFirebaseModelEntityWithStore) => DbxFirebaseModelEntitiesWidgetInjectionConfig;
+/**
+ * Creates a DbxFirebaseModelEntitiesWidgetInjectionConfigFactory.
+ *
+ * @param injector Optional injector to use for the components.
+ * @returns
+ */
+declare function dbxFirebaseModelEntityWidgetInjectionConfigFactory(injector?: Maybe<Injector>): DbxFirebaseModelEntitiesWidgetInjectionConfigFactory;
+
+/**
+ * An interactive display for a FirestoreModelKey.
+ */
+declare class DbxFirebaseModelKeyComponent {
+    readonly dbxFirebaseModelTypesService: DbxFirebaseModelTypesService;
+    readonly modelKey: i0.InputSignal<string | undefined>;
+    readonly modelKeyIdSignal: i0.Signal<string | undefined>;
+    readonly oneWayFlatModelKeySignal: i0.Signal<string | undefined>;
+    readonly twoWayFlatModelKeySignal: i0.Signal<string | undefined>;
+    readonly modelKey$: rxjs.Observable<string | undefined>;
+    readonly modelTypeInstance$: rxjs.Observable<DbxFirebaseModelTypesServiceInstance<any, string> | undefined>;
+    readonly modelIdentity$: rxjs.Observable<_dereekb_firebase.FirestoreModelIdentity | undefined>;
+    readonly typeInfo$: rxjs.Observable<Maybe<_dereekb_dbx_firebase.DbxFirebaseModelTypeInfo<unknown>>>;
+    readonly modelTypeInstanceSignal: i0.Signal<DbxFirebaseModelTypesServiceInstance<any, string> | undefined>;
+    readonly modelIdentitySignal: i0.Signal<_dereekb_firebase.FirestoreModelIdentity | undefined>;
+    readonly typeInfoSignal: i0.Signal<Maybe<_dereekb_dbx_firebase.DbxFirebaseModelTypeInfo<unknown>>>;
+    readonly typeCanSegueToView: i0.Signal<boolean>;
+    readonly sref$: rxjs.Observable<Maybe<dist_packages_dbx_core_types_dereekb_dbx_core.SegueRef<object>>>;
+    readonly srefSignal: i0.Signal<Maybe<dist_packages_dbx_core_types_dereekb_dbx_core.SegueRef<object>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelKeyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseModelKeyComponent, "dbx-firebase-model-key", never, { "modelKey": { "alias": "modelKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type DbxFirebaseModelTypeInstanceListItem = DbxValueAsListItem<DbxFirebaseModelTypesServiceInstancePair>;
+/**
+ * Renders an item as configured from the DbxFirebaseModelTypesServiceInstancePair.
+ */
+declare class DbxFirebaseModelTypeInstanceListComponent extends AbstractDbxSelectionListWrapperDirective<DbxFirebaseModelTypesServiceInstancePair> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelTypeInstanceListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseModelTypeInstanceListComponent, "dbx-firebase-model-type-instance-list", never, {}, {}, never, ["[top]", "[bottom]", "[empty]", "[emptyLoading]", "[end]"], true, never>;
+}
+declare class DbxFirebaseModelTypeInstanceListViewComponent extends AbstractDbxSelectionListViewDirective<DbxFirebaseModelTypesServiceInstancePair> {
+    readonly config: DbxSelectionValueListViewConfig<DbxFirebaseModelTypeInstanceListItem>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelTypeInstanceListViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseModelTypeInstanceListViewComponent, "dbx-firebase-model-type-instance-list-view", never, {}, {}, never, never, true, never>;
+}
+declare class DbxFirebaseModelTypeInstanceListViewItemComponent extends AbstractDbxValueListViewItemComponent<DbxFirebaseModelTypesServiceInstancePair> {
+    readonly title: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelTypeInstanceListViewItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseModelTypeInstanceListViewItemComponent, "dbx-firebase-model-type-instance-list-view-item", never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class DbxFirebaseDocumentStoreTwoWayKeyProvider {
+    abstract readonly twoWayFlatKey$: Observable<TwoWayFlatFirestoreModelKey>;
+}
+/**
+ * Configures Providers for a DbxFirebaseDocumentStoreTwoWayKeyProvider.
+ */
+declare function provideDbxFirebaseDocumentStoreTwoWayKeyProvider<S extends DbxFirebaseDocumentStoreTwoWayKeyProvider>(sourceType: Type<S>): Provider[];
+
+/**
+ * Abstract directive that contains a DbxFirebaseDocumentStore and provides an interface for communicating with other directives.
+ */
+declare abstract class DbxFirebaseDocumentStoreDirective<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseDocumentStore<T, D> = DbxFirebaseDocumentStore<T, D>> implements DbxFirebaseDocumentStoreTwoWayKeyProvider, DbxRouteModelIdDirectiveDelegate, DbxRouteModelKeyDirectiveDelegate {
+    readonly storeName: i0.ModelSignal<Maybe<string>>;
+    readonly documentId: i0.ModelSignal<Maybe<string>>;
+    readonly key: i0.ModelSignal<Maybe<string>>;
+    readonly flatKey: i0.ModelSignal<Maybe<string>>;
+    readonly ref: i0.ModelSignal<Maybe<DocumentReference<T>>>;
+    readonly streamMode: i0.ModelSignal<FirestoreAccessorStreamMode>;
+    private readonly _storeName$;
+    private readonly _documentId$;
+    private readonly _key$;
+    private readonly _flatKey$;
+    private readonly _ref$;
+    private readonly _streamMode$;
+    private readonly _store;
+    readonly store$: Observable<S>;
+    readonly exists$: Observable<boolean>;
+    readonly document$: Observable<D>;
+    readonly documentLoadingState$: Observable<_dereekb_rxjs.LoadingState<D>>;
+    readonly id$: Observable<string>;
+    readonly key$: Observable<string>;
+    readonly twoWayFlatKey$: Observable<string>;
+    readonly ref$: Observable<DocumentReference<T>>;
+    readonly snapshot$: Observable<_dereekb_firebase.DocumentSnapshot<T>>;
+    readonly snapshotLoadingState$: Observable<_dereekb_rxjs.LoadingState<_dereekb_firebase.DocumentSnapshot<T>>>;
+    readonly modelIdentity$: Observable<_dereekb_firebase.FirestoreModelIdentity>;
+    readonly data$: Observable<_dereekb_firebase.DocumentDataWithIdAndKey<T>>;
+    readonly loadingState$: Observable<_dereekb_rxjs.LoadingState<_dereekb_firebase.DocumentDataWithIdAndKey<T>>>;
+    constructor(store: S);
+    get store(): S;
+    setStoreName(storeName: Maybe<string>): void;
+    setDocumentId(documentId: Maybe<FirestoreModelId>): void;
+    setKey(key: Maybe<FirestoreModelKey>): void;
+    setFlatKey(flatKey: Maybe<TwoWayFlatFirestoreModelKey>): void;
+    setRef(ref: Maybe<DocumentReference<T>>): void;
+    setStreamMode(streamMode: FirestoreAccessorStreamMode): void;
+    /**
+     * Replaces the internal store.
+     */
+    replaceStore(store: S): void;
+    useRouteModelIdParamsObservable(idFromParams: Observable<Maybe<ModelKey>>): Subscription;
+    useRouteModelKeyParamsObservable(keyFromParams: Observable<Maybe<TwoWayFlatFirestoreModelKey>>): Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDocumentStoreDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseDocumentStoreDirective<any, any, any>, never, never, { "storeName": { "alias": "storeName"; "required": false; "isSignal": true; }; "documentId": { "alias": "documentId"; "required": false; "isSignal": true; }; "key": { "alias": "key"; "required": false; "isSignal": true; }; "flatKey": { "alias": "flatKey"; "required": false; "isSignal": true; }; "ref": { "alias": "ref"; "required": false; "isSignal": true; }; "streamMode": { "alias": "streamMode"; "required": false; "isSignal": true; }; }, { "storeName": "storeNameChange"; "documentId": "documentIdChange"; "key": "keyChange"; "flatKey": "flatKeyChange"; "ref": "refChange"; "streamMode": "streamModeChange"; }, never, never, true, 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
+ */
+declare function provideDbxFirebaseDocumentStoreDirective<S extends DbxFirebaseDocumentStoreDirective<any, any, any>>(sourceType: Type<S>): Provider[];
+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[];
+
+/**
+ * Used with a DbxFirebaseDocumentStoreDirective to emit model viewed events.
+ */
+declare class DbxFirebaseModelViewedEventDirective {
+    readonly dbxFirebaseDocumentStoreDirective: DbxFirebaseDocumentStoreDirective<unknown, _dereekb_firebase.FirestoreDocument<unknown, _dereekb_firebase.FirestoreModelIdentity>, _dereekb_dbx_firebase.DbxFirebaseDocumentStore<unknown, _dereekb_firebase.FirestoreDocument<unknown, _dereekb_firebase.FirestoreModelIdentity>>>;
+    readonly dbxModelObjectStateService: DbxModelObjectStateService;
+    readonly dbxFirebaseModelTypesService: DbxFirebaseModelTypesService;
+    readonly modelViewContext: i0.InputSignal<Maybe<string>>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelViewedEventDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseModelViewedEventDirective, "[dbxFirebaseModelViewedEvent]", never, { "modelViewContext": { "alias": "dbxFirebaseModelViewedEvent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+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.
+     */
+    readonly hasNext$: Observable<boolean>;
+    /**
+     * Whether or not the iterator can load more pages.
+     */
+    readonly canLoadMore$: Observable<boolean>;
+    /**
+     * Whether or not the iterator has more pages to load and can load more pages.
+     */
+    readonly hasNextAndCanLoadMore$: Observable<boolean>;
+    /**
+     * Returns true if the collection has documents.
+     */
+    readonly hasDocuments$: Observable<boolean>;
+    /**
+     * Returns all document references loaded by the accumulator.
+     */
+    readonly allDocumentRefs$: Observable<DocumentReference<T>[]>;
+    /**
+     * Returns all documents loaded by the accomulator.
+     */
+    readonly allDocuments$: Observable<D[]>;
+    /**
+     * 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;
+    setWaitForNonNullConstraints(observableOrValue: ObservableOrValue<Maybe<boolean>>): Subscription;
+    next(observableOrValue: ObservableOrValue<void>): void;
+    restart(observableOrValue: ObservableOrValue<void>): void;
+    readonly setFirestoreCollection: (() => void) | ((observableOrValue: ObservableOrValue<Maybe<FirestoreCollectionLike<T, D>>>) => Subscription);
+}
+interface DbxFirebaseCollectionStoreContextState<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends Omit<DbxFirebaseCollectionLoaderInstanceInitConfig<T, D>, 'collection'> {
+    readonly firestoreCollection?: Maybe<FirestoreCollectionLike<T, D>>;
+}
+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;
+    readonly setWaitForNonNullConstraints: (observableOrValue: Maybe<boolean> | Observable<Maybe<boolean>>) => Subscription;
+    readonly next: (observableOrValue?: void | Observable<void> | undefined) => Subscription;
+    readonly restart: (observableOrValue?: void | Observable<void> | undefined) => Subscription;
+    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>>;
+    readonly pageLoadingState$: Observable<PageListLoadingState<DocumentDataWithIdAndKey<T>>>;
+    readonly snapshotAccumulator$: Observable<FirebaseQuerySnapshotAccumulator<T>>;
+    readonly accumulator$: Observable<FirebaseQueryItemAccumulator<T>>;
+    readonly hasNext$: Observable<boolean>;
+    readonly canLoadMore$: Observable<boolean>;
+    readonly hasNextAndCanLoadMore$: Observable<boolean>;
+    readonly hasDocuments$: Observable<boolean>;
+    readonly allDocumentRefs$: Observable<DocumentReference<T>[]>;
+    readonly allDocuments$: Observable<D[]>;
+    readonly allDocumentData$: Observable<DocumentDataWithIdAndKey<T>[]>;
+    readonly setFirestoreCollection: (() => void) | ((observableOrValue: FirestoreCollectionLike<T, D, _dereekb_firebase.LimitedFirestoreDocumentAccessor<T, D>> | Observable<FirestoreCollectionLike<T, D, _dereekb_firebase.LimitedFirestoreDocumentAccessor<T, D>> | null | undefined> | null | undefined) => Subscription);
+    loadToPage(page: PageNumber): Observable<PageNumber>;
+    loadPagesUntilResultsCount(maxResultsCount: number, countFunction?: FirebaseQueryItemAccumulatorNextPageUntilResultsCountFunction<T> | undefined): Observable<ItemAccumulatorNextPageUntilResultsCountResult>;
+    loadAllResults(): Observable<PageNumber>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxFirebaseCollectionStore<any, any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AbstractDbxFirebaseCollectionStore<any, any, any>>;
+}
+
+/**
+ * Abstract directive that contains a DbxFirebaseCollectionStore and provides an interface for communicating with other directives.
+ */
+declare abstract class DbxFirebaseCollectionStoreDirective<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseCollectionStore<T, D> = DbxFirebaseCollectionStore<T, D>> {
+    readonly collectionMode: i0.ModelSignal<DbxFirebaseCollectionMode>;
+    readonly collectionKeys: i0.ModelSignal<Maybe<string[]>>;
+    readonly collectionRefs: i0.ModelSignal<Maybe<DocumentReference<T>[]>>;
+    readonly maxPages: i0.ModelSignal<Maybe<number>>;
+    readonly itemsPerPage: i0.ModelSignal<Maybe<number>>;
+    readonly constraints: i0.ModelSignal<Maybe<ArrayOrValue<FirestoreQueryConstraint<unknown>>>>;
+    readonly waitForNonNullConstraints: i0.ModelSignal<Maybe<boolean>>;
+    private readonly _collectionMode;
+    private readonly _collectionKeys;
+    private readonly _collectionRefs;
+    private readonly _maxPages;
+    private readonly _itemsPerPage;
+    private readonly _constraints;
+    private readonly _waitForNonNullConstraints;
+    private readonly _store;
+    readonly store$: rxjs.Observable<S>;
+    readonly pageLoadingState$: rxjs.Observable<_dereekb_rxjs.PageListLoadingState<_dereekb_firebase.DocumentDataWithIdAndKey<T>>>;
+    constructor(store: S);
+    get store(): S;
+    /**
+     * 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;
+    setWaitForNonNullConstraints(waitForNonNullConstraints: Maybe<boolean>): void;
+    next(): void;
+    restart(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseCollectionStoreDirective<any, any, any>, 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, true, 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
+ */
+declare function provideDbxFirebaseCollectionStoreDirective<S extends DbxFirebaseCollectionStoreDirective<any, any, any>>(sourceType: Type<S>): Provider[];
+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[];
+
+/**
+ * Directive that connects a host DbxListView to a DbxFirebaseCollectionStoreDirective to pass data for rendering items from a collection and query parameters.
+ */
+declare class DbxFirebaseCollectionListDirective<T> {
+    readonly dbxFirebaseCollectionStoreDirective: DbxFirebaseCollectionStoreDirective<T, _dereekb_firebase.FirestoreDocument<T, _dereekb_firebase.FirestoreModelIdentity>, _dereekb_dbx_firebase.DbxFirebaseCollectionStore<T, _dereekb_firebase.FirestoreDocument<T, _dereekb_firebase.FirestoreModelIdentity>>>;
+    readonly dbxListViewWrapper: DbxListViewWrapper<any, any>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseCollectionListDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseCollectionListDirective<any>, "[dbxFirebaseCollectionList]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Used to watch query doc changes and respond to them accordingly.
+ */
+declare class DbxFirebaseCollectionChangeDirective<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseCollectionStore<T, D> = DbxFirebaseCollectionStore<T, D>> implements DbxFirebaseCollectionChangeWatcher<S> {
+    readonly dbxFirebaseCollectionStoreDirective: DbxFirebaseCollectionStoreDirective<T, D, S>;
+    readonly mode: i0.InputSignalWithTransform<DbxFirebaseCollectionChangeWatcherTriggerMode, "" | DbxFirebaseCollectionChangeWatcherTriggerMode>;
+    private readonly _watcher;
+    private readonly _trigger;
+    readonly mode$: Observable<DbxFirebaseCollectionChangeWatcherTriggerMode>;
+    readonly event$: Observable<DbxFirebaseCollectionChangeWatcherEvent>;
+    readonly hasChangeAvailable$: Observable<boolean>;
+    readonly triggered$: Observable<boolean>;
+    readonly trigger$: Observable<void>;
+    protected readonly modeEffect: i0.EffectRef;
+    get store(): S;
+    constructor();
+    restart(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseCollectionChangeDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseCollectionChangeDirective<any, any, any>, "[dbxFirebaseCollectionChange]", never, { "mode": { "alias": "dbxFirebaseCollectionChange"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type DbxFirebaseCollectionHasChangeDirectiveMode = 'all' | IterationQueryDocChangeWatcherChangeType;
+/**
+ * Structural directive that displays the content when the target change is detected.
+ *
+ * Can specify which changes to appear on.
+ */
+declare class DbxFirebaseCollectionHasChangeDirective extends AbstractIfDirective {
+    readonly directive: DbxFirebaseCollectionChangeDirective<unknown, _dereekb_firebase.FirestoreDocument<unknown, _dereekb_firebase.FirestoreModelIdentity>, _dereekb_dbx_firebase.DbxFirebaseCollectionStore<unknown, _dereekb_firebase.FirestoreDocument<unknown, _dereekb_firebase.FirestoreModelIdentity>>>;
+    readonly mode: i0.InputSignalWithTransform<DbxFirebaseCollectionHasChangeDirectiveMode, "" | DbxFirebaseCollectionHasChangeDirectiveMode>;
+    readonly show$: Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseCollectionHasChangeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseCollectionHasChangeDirective, "[dbxFirebaseCollectionHasChange]", never, { "mode": { "alias": "dbxFirebaseCollectionHasChange"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that implements DbxFirebaseDocumentStoreTwoWayKeyProvider and passes the twoWayFlatKey from a host DbxFirebaseDocumentStoreDirective.
+ */
+declare class DbxFirebaseDocumentStoreTwoWayModelKeySourceDirective implements DbxFirebaseDocumentStoreTwoWayKeyProvider {
+    readonly dbxFirebaseDocumentStoreDirective: DbxFirebaseDocumentStoreDirective<unknown, _dereekb_firebase.FirestoreDocument<unknown, _dereekb_firebase.FirestoreModelIdentity>, _dereekb_dbx_firebase.DbxFirebaseDocumentStore<unknown, _dereekb_firebase.FirestoreDocument<unknown, _dereekb_firebase.FirestoreModelIdentity>>>;
+    readonly twoWayFlatKey$: Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDocumentStoreTwoWayModelKeySourceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseDocumentStoreTwoWayModelKeySourceDirective, "[dbxFirebaseDocumentStoreTwoWayModelKeySource]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Used for providing an id from the twoWayFlatKey$ from a DbxFirebaseDocumentStoreTwoWayKeyProvider.
+ */
+declare class DbxFirebaseDocumentStoreIdFromTwoWayModelKeyDirective {
+    readonly dbxFirebaseDocumentStoreDirective: DbxFirebaseDocumentStoreDirective<unknown, _dereekb_firebase.FirestoreDocument<unknown, _dereekb_firebase.FirestoreModelIdentity>, _dereekb_dbx_firebase.DbxFirebaseDocumentStore<unknown, _dereekb_firebase.FirestoreDocument<unknown, _dereekb_firebase.FirestoreModelIdentity>>>;
+    readonly dbxFirebaseDocumentStoreTwoWayKeyProvider: DbxFirebaseDocumentStoreTwoWayKeyProvider;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDocumentStoreIdFromTwoWayModelKeyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseDocumentStoreIdFromTwoWayModelKeyDirective, "[dbxFirebaseDocumentStoreIdFromTwoWayModelKey]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseModelStoreModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelStoreModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFirebaseModelStoreModule, never, [typeof DbxFirebaseCollectionListDirective, typeof DbxFirebaseCollectionChangeDirective, typeof DbxFirebaseCollectionHasChangeDirective, typeof DbxFirebaseDocumentStoreTwoWayModelKeySourceDirective, typeof DbxFirebaseDocumentStoreIdFromTwoWayModelKeyDirective], [typeof DbxFirebaseCollectionListDirective, typeof DbxFirebaseCollectionChangeDirective, typeof DbxFirebaseCollectionHasChangeDirective, typeof DbxFirebaseDocumentStoreTwoWayModelKeySourceDirective, typeof DbxFirebaseDocumentStoreIdFromTwoWayModelKeyDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseModelStoreModule>;
+}
+
+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
+ */
+declare function firebaseCollectionStoreCreateFunction<I, O extends OnCallCreateModelResult = OnCallCreateModelResult>(store: DbxFirebaseCollectionStore<any, any>, fn: ModelFirebaseCreateFunction<I, O>): DbxFirebaseCollectionStoreCreateFunction<I, O>;
+type DbxFirebaseCollectionStoreCrudFunction<I, O = void> = (input: I) => Observable<LoadingState<O>>;
+/**
+ * Creates a DbxfirebaseDocumentStoreCrudFunction from the input ModelFirebaseCrudFunction.
+ *
+ * @param fn
+ * @returns
+ */
+declare function firebaseCollectionStoreCrudFunction<I, O = void>(fn: ModelFirebaseCrudFunction<I, O>): DbxFirebaseCollectionStoreCrudFunction<I, O>;
+
+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> {
+    protected constructor(initialState?: C);
+    readonly storeName$: Observable<Maybe<string>>;
+    readonly currentFirestoreCollectionLike$: Observable<Maybe<FirestoreCollectionLike<T, D>>>;
+    readonly currentFirestoreCollection$: Observable<Maybe<FirestoreCollection<T, D>>>;
+    readonly firestoreCollectionLike$: Observable<FirestoreCollectionLike<T, D>>;
+    readonly firestoreCollection$: Observable<FirestoreCollection<T, D>>;
+    readonly currentInputId$: Observable<Maybe<FirestoreModelId>>;
+    readonly inputId$: Observable<FirestoreModelId>;
+    readonly currentInputKey$: Observable<Maybe<FirestoreModelKey>>;
+    readonly inputKey$: Observable<FirestoreModelKey>;
+    readonly currentInputRef$: Observable<Maybe<DocumentReference<T>>>;
+    readonly inputRef$: Observable<DocumentReference<T>>;
+    readonly streamMode$: Observable<FirestoreAccessorStreamMode>;
+    readonly currentDocument$: Observable<Maybe<D>>;
+    /**
+     * Whether or not an id/ref/key has been input and currentDocument is not null.
+     */
+    readonly hasRef$: Observable<boolean>;
+    readonly document$: Observable<D>;
+    readonly documentLoadingState$: Observable<LoadingState<D>>;
+    readonly currentId$: Observable<Maybe<FirestoreModelId>>;
+    readonly currentKey$: Observable<Maybe<FirestoreModelKey>>;
+    readonly id$: Observable<FirestoreModelId>;
+    readonly key$: Observable<FirestoreModelKey>;
+    readonly keyModelIds$: Observable<FirestoreModelId[]>;
+    readonly keyPairs$: Observable<FirestoreModelCollectionAndIdPair[]>;
+    readonly keyPairObject$: Observable<FirestoreModelCollectionAndIdPairObject>;
+    readonly ref$: Observable<DocumentReference<T>>;
+    readonly flatKey$: Observable<FlatFirestoreModelKey>;
+    readonly twoWayFlatKey$: Observable<FlatFirestoreModelKey>;
+    readonly snapshot$: Observable<DocumentSnapshot<T>>;
+    readonly snapshotLoadingState$: Observable<LoadingState<DocumentSnapshot<T>>>;
+    readonly dataLoadingState$: Observable<LoadingState<DocumentDataWithIdAndKey<T>>>;
+    readonly currentData$: Observable<Maybe<DocumentDataWithIdAndKey<T>>>;
+    readonly data$: Observable<DocumentDataWithIdAndKey<T>>;
+    readonly isLoadingData$: Observable<boolean>;
+    /**
+     * Returns false while hasRef$ is false, and then returns exists$.
+     */
+    readonly currentExists$: Observable<boolean>;
+    readonly exists$: Observable<boolean>;
+    readonly doesNotExist$: Observable<boolean>;
+    readonly modelIdentity$: Observable<FirestoreModelIdentity>;
+    readonly setStoreName: (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;
+    readonly setId: (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;
+    readonly setKey: (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;
+    readonly setFlatKey: (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;
+    readonly setRef: (observableOrValue: Maybe<DocumentReference<T>> | Observable<Maybe<DocumentReference<T>>>) => Subscription;
+    readonly setStreamMode: (observableOrValue: FirestoreAccessorStreamMode | Observable<FirestoreAccessorStreamMode>) => Subscription;
+    readonly clearRefs: () => void;
+    readonly setFirestoreCollection: (() => void) | ((observableOrValue: Maybe<FirestoreCollection<T, D>> | Observable<Maybe<FirestoreCollection<T, D>>>) => Subscription);
+    readonly setFirestoreCollectionLike: (() => void) | ((observableOrValue: Maybe<FirestoreCollectionLike<T, D, _dereekb_firebase.LimitedFirestoreDocumentAccessor<T, D>>> | Observable<Maybe<FirestoreCollectionLike<T, D, _dereekb_firebase.LimitedFirestoreDocumentAccessor<T, D>>>>) => Subscription);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxFirebaseDocumentStore<any, any, any>, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AbstractDbxFirebaseDocumentStore<any, any, any>>;
+}
+/**
+ * AbstractDbxFirebaseDocumentWithParentStore extension for use with RootSingleItemFirestoreCollection.
+ */
+declare class AbstractRootSingleItemDbxFirebaseDocument<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, C extends DbxFirebaseDocumentStoreContextState<T, D> = DbxFirebaseDocumentStoreContextState<T, D>> extends AbstractDbxFirebaseDocumentStore<T, D, C> {
+    protected constructor(initialState?: C);
+    /**
+     * Sets the SingleItemFirestoreCollection to use.
+     */
+    readonly setFirestoreCollection: (() => void) | ((observableOrValue: Maybe<FirestoreCollection<T, D>> | Observable<Maybe<FirestoreCollection<T, D>>>) => Subscription);
+    /**
+     * Does nothing on a AbstractRootSingleItemDbxFirebaseDocument.
+     *
+     * Ref is set with the FirestoreCollection
+     */
+    readonly setId: (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;
+    /**
+     * Does nothing on a AbstractRootSingleItemDbxFirebaseDocument.
+     *
+     * Ref is set with the FirestoreCollection
+     */
+    readonly setKey: (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;
+    /**
+     * Does nothing on a AbstractRootSingleItemDbxFirebaseDocument.
+     *
+     * Ref is set with the FirestoreCollection
+     */
+    readonly setRef: (observableOrValue: Maybe<DocumentReference<T>> | Observable<Maybe<DocumentReference<T>>>) => Subscription;
+    readonly clearRefs: () => void;
+}
+interface DbxFirebaseDocumentStoreContextState<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> {
+    readonly storeName?: Maybe<string>;
+    readonly firestoreCollectionLike?: Maybe<FirestoreCollectionLike<T, D>>;
+    readonly firestoreCollection?: Maybe<FirestoreCollection<T, D>>;
+    readonly streamMode?: FirestoreAccessorStreamMode;
+    readonly id?: Maybe<FirestoreModelId>;
+    readonly key?: Maybe<FirestoreModelKey>;
+    readonly ref?: Maybe<DocumentReference<T>>;
+}
+
+type DbxFirebaseDocumentStoreCreateFunction<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
+ */
+declare function firebaseDocumentStoreCreateFunction<I, O extends OnCallCreateModelResult = OnCallCreateModelResult>(store: DbxFirebaseDocumentStore<any, any>, fn: ModelFirebaseCreateFunction<I, O>): DbxFirebaseDocumentStoreCreateFunction<I, O>;
+type DbxFirebaseDocumentStoreCrudFunction<I, O = void> = (input: I) => Observable<LoadingState<O>>;
+/**
+ * Creates a DbxfirebaseDocumentStoreCrudFunction from the input ModelFirebaseCrudFunction.
+ *
+ * @param fn
+ * @returns
+ */
+declare function firebaseDocumentStoreCrudFunction<I, O = void>(fn: ModelFirebaseCrudFunction<I, O>): DbxFirebaseDocumentStoreCrudFunction<I, O>;
+/**
+ * A parameter that refers to a specific key.
+ */
+type DbxFirebaseDocumentStoreFunctionParams = TargetModelParams | InferredTargetModelParams;
+/**
+ * Used for the input to related functions
+ */
+type DbxFirebaseDocumentStoreFunctionParamsInput<I extends DbxFirebaseDocumentStoreFunctionParams> = PartialOnKeys<I, 'key'>;
+type DbxFirebaseDocumentStoreFunction<I extends DbxFirebaseDocumentStoreFunctionParams, O = void> = DbxFirebaseDocumentStoreCrudFunction<DbxFirebaseDocumentStoreFunctionParamsInput<I>, O>;
+/**
+ * Creates a DbxfirebaseDocumentStoreCrudFunction for read.
+ *
+ * The store's current key is always injected into the params of the request.
+ *
+ * For functions that do not require the store's current key, use firebaseDocumentStoreCrudFunction() instead.
+ *
+ * @param store
+ * @param fn
+ * @returns
+ */
+declare function firebaseDocumentStoreReadFunction<I extends DbxFirebaseDocumentStoreFunctionParams, O>(store: DbxFirebaseDocumentStore<any, any>, fn: ModelFirebaseReadFunction<I, O>): DbxFirebaseDocumentStoreFunction<I, O>;
+/**
+ * Creates a DbxFirebaseDocumentStoreFunction for update.
+ *
+ * The store's current key is always injected into the params of the request.
+ *
+ * @param store
+ * @param fn
+ * @returns
+ */
+declare function firebaseDocumentStoreUpdateFunction<I extends DbxFirebaseDocumentStoreFunctionParams, O = void>(store: DbxFirebaseDocumentStore<any, any>, fn: ModelFirebaseUpdateFunction<I, O>): DbxFirebaseDocumentStoreFunction<I, O>;
+/**
+ * Creates a DbxFirebaseDocumentStoreFunction for delete.
+ *
+ * The store's current key is always injected into the params of the request.
+ *
+ * @param store
+ * @param fn
+ * @returns
+ */
+declare function firebaseDocumentStoreDeleteFunction<I extends DbxFirebaseDocumentStoreFunctionParams, O = void>(store: DbxFirebaseDocumentStore<any, any>, fn: ModelFirebaseDeleteFunction<I, O>): DbxFirebaseDocumentStoreFunction<I, O>;
+
+interface DbxFirebaseComponentStoreWithParentContextState<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>> {
+    readonly parent?: Maybe<PD>;
+    readonly collectionFactory?: Maybe<FirestoreCollectionWithParentFactory<T, PT, D, PD>>;
+}
+type DbxFirebaseComponentStoreSetParentEffectFunction<PD> = (parent: Observable<Maybe<PD>>) => Subscription;
+type DbxFirebaseComponentStoreWithParentSetParentEffectFunction<PD> = (observableOrValue: ObservableOrValue<Maybe<PD>>) => Subscription;
+type DbxFirebaseComponentStoreWithParentSetParentStoreEffectFunction<PT, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>> = (observableOrValue: ObservableOrValue<DbxFirebaseDocumentStore<PT, PD>>) => Subscription;
+interface DbxFirebaseComponentStoreWithParent<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>, A extends FirestoreCollectionLike<T, D> = FirestoreCollectionLike<T, D>> extends LockSetComponentStore<object>, Pick<ComponentStore<DbxFirebaseComponentStoreWithParentContextState<T, PT, D, PD>>, 'effect'> {
+    readonly currentParent$: Observable<Maybe<PD>>;
+    readonly parent$: Observable<PD>;
+    readonly currentCollectionFactory$: Observable<Maybe<FirestoreCollectionWithParentFactory<T, PT, D, PD>>>;
+    readonly collectionFactory$: Observable<FirestoreCollectionWithParentFactory<T, PT, D, PD>>;
+    readonly _setParent: DbxFirebaseComponentStoreSetParentEffectFunction<PD>;
+    readonly _setParentDocument: (() => void) | ((observableOrValue: ObservableOrValue<Maybe<PD>>) => Subscription);
+    readonly setFirestoreCollection: (() => void) | ((observableOrValue: ObservableOrValue<Maybe<A>>) => Subscription);
+}
+declare function setParentStoreEffect<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>, A extends FirestoreCollectionLike<T, D> = FirestoreCollectionLike<T, D>>(store: DbxFirebaseComponentStoreWithParent<T, PT, D, PD, A>): DbxFirebaseComponentStoreWithParentSetParentStoreEffectFunction<PT, PD>;
+
+/**
+ * Whether or not to load values from a parent or a group.
+ */
+type DbxFirebaseComponentStoreWithParentSourceMode = 'parent' | 'group';
+interface DbxFirebaseCollectionWithParentStoreContextState<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>> extends DbxFirebaseCollectionStoreContextState<T, D>, DbxFirebaseComponentStoreWithParentContextState<T, PT, D, PD> {
+    readonly mode?: Maybe<DbxFirebaseComponentStoreWithParentSourceMode>;
+    readonly collectionGroup?: Maybe<FirestoreCollectionGroup<T, D>>;
+}
+type DbxFirebaseComponentStoreWithParentSetParentSourceModeFunction = (observableOrValue: ObservableOrValue<Maybe<DbxFirebaseComponentStoreWithParentSourceMode>>) => Subscription;
+interface DbxFirebaseCollectionWithParentStore<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>> extends DbxFirebaseCollectionStore<T, D>, DbxFirebaseComponentStoreWithParent<T, PT, D, PD> {
+    readonly setSourceMode: DbxFirebaseComponentStoreWithParentSetParentSourceModeFunction;
+    readonly setCollectionGroup: (observableOrValue: FirestoreCollectionGroup<T, D> | Observable<FirestoreCollectionGroup<T, D>>) => Subscription;
+    readonly currentCollectionGroup$: Observable<Maybe<FirestoreCollectionGroup<T, D>>>;
+    readonly collectionGroup$: Observable<FirestoreCollectionGroup<T, D>>;
+}
+/**
+ * Abstract DbxFirebaseCollectionStore that has a parent document from which is derives it's FiresbaseCollection from.
+ */
+declare class AbstractDbxFirebaseCollectionWithParentStore<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>, C extends DbxFirebaseCollectionWithParentStoreContextState<T, PT, D, PD> = DbxFirebaseCollectionWithParentStoreContextState<T, PT, D, PD>> extends AbstractDbxFirebaseCollectionStore<T, D, C> implements DbxFirebaseCollectionWithParentStore<T, PT, D, PD> {
+    constructor(state: C, defaultSourceMode?: DbxFirebaseComponentStoreWithParentSourceMode);
+    readonly setParentStore: DbxFirebaseComponentStoreWithParentSetParentStoreEffectFunction<PT, PD>;
+    readonly setSourceMode: DbxFirebaseComponentStoreWithParentSetParentSourceModeFunction;
+    readonly currentParent$: Observable<Maybe<PD>>;
+    readonly parent$: Observable<PD>;
+    readonly currentCollectionFactory$: Observable<Maybe<FirestoreCollectionWithParentFactory<T, PT, D, PD>>>;
+    readonly collectionFactory$: Observable<FirestoreCollectionWithParentFactory<T, PT, D, PD>>;
+    readonly currentCollectionGroup$: Observable<Maybe<FirestoreCollectionGroup<T, D>>>;
+    readonly collectionGroup$: Observable<FirestoreCollectionGroup<T, D>>;
+    /**
+     * Sets the collection factory function to use.
+     */
+    readonly setCollectionFactory: (observableOrValue: FirestoreCollectionWithParentFactory<T, PT, D, PD> | Observable<FirestoreCollectionWithParentFactory<T, PT, D, PD>>) => Subscription;
+    /**
+     * Sets the collection group to use.
+     */
+    readonly setCollectionGroup: (observableOrValue: Maybe<FirestoreCollectionGroup<T, D>> | Observable<Maybe<FirestoreCollectionGroup<T, D>>>) => Subscription;
+    /**
+     * Sets the parent on the current state.
+     */
+    readonly _setParentDocument: (() => void) | ((observableOrValue: Maybe<PD> | Observable<Maybe<PD>>) => Subscription) | (PD extends void ? () => void : (observableOrValue: Maybe<PD> | Observable<Maybe<PD>>) => Subscription);
+    readonly _setParent: DbxFirebaseComponentStoreSetParentEffectFunction<PD>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxFirebaseCollectionWithParentStore<any, any, any, any, any>, [{ optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AbstractDbxFirebaseCollectionWithParentStore<any, any, any, any, any>>;
+}
+
+interface DbxFirebaseDocumentWithParentStoreContextState<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>> extends DbxFirebaseDocumentStoreContextState<T, D>, DbxFirebaseComponentStoreWithParentContextState<T, PT, D, PD> {
+}
+interface DbxFirebaseDocumentWithParentStore<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>> extends DbxFirebaseDocumentStore<T, D>, DbxFirebaseComponentStoreWithParent<T, PT, D, PD, FirestoreCollection<T, D>> {
+}
+/**
+ * Abstract DbxFirebaseDocumentStore that has a parent document from which is derives it's FiresbaseCollection from.
+ */
+declare class AbstractDbxFirebaseDocumentWithParentStore<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>, C extends DbxFirebaseDocumentWithParentStoreContextState<T, PT, D, PD> = DbxFirebaseDocumentWithParentStoreContextState<T, PT, D, PD>> extends AbstractDbxFirebaseDocumentStore<T, D, C> implements DbxFirebaseDocumentWithParentStore<T, PT, D, PD> {
+    readonly setParentStore: DbxFirebaseComponentStoreWithParentSetParentStoreEffectFunction<PT, PD>;
+    readonly setParent: DbxFirebaseComponentStoreWithParentSetParentEffectFunction<PD>;
+    readonly _setParent: DbxFirebaseComponentStoreWithParentSetParentEffectFunction<PD>;
+    /**
+     * Returns the parent model key given the current key value.
+     */
+    readonly keyParentKey$: Observable<Maybe<string>>;
+    readonly currentParent$: Observable<Maybe<PD>>;
+    readonly currentParentKey$: Observable<Maybe<FirestoreModelKey>>;
+    readonly parent$: Observable<PD>;
+    readonly parentKey$: Observable<Maybe<FirestoreModelKey>>;
+    readonly currentCollectionFactory$: Observable<Maybe<FirestoreCollectionWithParentFactory<T, PT, D, PD>>>;
+    readonly collectionFactory$: Observable<FirestoreCollectionWithParentFactory<T, PT, D, PD>>;
+    /**
+     * Sets the collection factory function to use.
+     */
+    readonly setCollectionFactory: (observableOrValue: FirestoreCollectionWithParentFactory<T, PT, D, PD> | Observable<FirestoreCollectionWithParentFactory<T, PT, D, PD>>) => Subscription;
+    /**
+     * Sets the parent on the current state.
+     */
+    readonly _setParentDocument: (() => void) | ((observableOrValue: Maybe<PD> | Observable<Maybe<PD>>) => Subscription) | (PD extends void ? () => void : (observableOrValue: Maybe<PD> | Observable<Maybe<PD>>) => Subscription);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxFirebaseDocumentWithParentStore<any, any, any, any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AbstractDbxFirebaseDocumentWithParentStore<any, any, any, any, any>>;
+}
+/**
+ * AbstractDbxFirebaseDocumentWithParentStore extension for use with SingleItemFirestoreCollection.
+ */
+declare class AbstractSingleItemDbxFirebaseDocument<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>, C extends DbxFirebaseDocumentWithParentStoreContextState<T, PT, D, PD> = DbxFirebaseDocumentWithParentStoreContextState<T, PT, D, PD>> extends AbstractDbxFirebaseDocumentWithParentStore<T, PT, D, PD, C> {
+    /**
+     * Sets the SingleItemFirestoreCollection to use.
+     */
+    readonly setFirestoreCollection: (() => void) | ((observableOrValue: Maybe<FirestoreCollection<T, D>> | Observable<Maybe<FirestoreCollection<T, D>>>) => Subscription);
+    /**
+     * Does nothing on a AbstractSingleItemDbxFirebaseDocument.
+     *
+     * Ref is set with the FirestoreCollection
+     */
+    readonly setId: (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;
+    /**
+     * Does nothing on a AbstractSingleItemDbxFirebaseDocument.
+     *
+     * Ref is set with the FirestoreCollection
+     */
+    readonly setKey: (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;
+    /**
+     * Does nothing on a AbstractSingleItemDbxFirebaseDocument.
+     *
+     * Ref is set with the FirestoreCollection
+     */
+    readonly setRef: (observableOrValue: Maybe<DocumentReference<T>> | Observable<Maybe<DocumentReference<T>>>) => Subscription;
+    readonly clearRefs: () => void;
+}
+
+/**
+ * Abstract directive that contains a DbxFirebaseCollectionWithParentStore and provides an interface for communicating with other directives.
+ */
+declare abstract class DbxFirebaseCollectionWithParentStoreDirective<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>, S extends DbxFirebaseCollectionWithParentStore<T, PT, D, PD> = DbxFirebaseCollectionWithParentStore<T, PT, D, PD>> extends DbxFirebaseCollectionStoreDirective<T, D, S> {
+    readonly sourceMode: i0.ModelSignal<Maybe<DbxFirebaseComponentStoreWithParentSourceMode>>;
+    private readonly _sourceMode$;
+    constructor(store: S);
+    setSourceMode(sourceMode: Maybe<DbxFirebaseComponentStoreWithParentSourceMode>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseCollectionWithParentStoreDirective<any, any, any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseCollectionWithParentStoreDirective<any, any, any, any, any>, never, never, { "sourceMode": { "alias": "sourceMode"; "required": false; "isSignal": true; }; }, { "sourceMode": "sourceModeChange"; }, never, never, true, never>;
+}
+/**
+ * Configures providers for a DbxFirebaseCollectionWithParentStoreDirective.
+ *
+ * Can optionally also provide the actual store type to include in the providers array so it is instantiated by Angular.
+ *
+ * @param sourceType
+ */
+declare function provideDbxFirebaseCollectionWithParentStoreDirective<S extends DbxFirebaseCollectionWithParentStoreDirective<any, any, any, any, any>>(sourceType: Type<S>): Provider[];
+declare function provideDbxFirebaseCollectionWithParentStoreDirective<S extends DbxFirebaseCollectionWithParentStore<any, any, any, any>, C extends DbxFirebaseCollectionWithParentStoreDirective<any, any, any, any, S> = DbxFirebaseCollectionWithParentStoreDirective<any, any, any, any, S>>(sourceType: Type<C>, storeType?: Type<S>): Provider[];
+
+/**
+ * Injection token for DbxFirebaseDocumentStoreContextStore.
+ */
+declare const DBX_FIREBASE_DOCUMENT_STORE_CONTEXT_STORE_TOKEN: InjectionToken<DbxFirebaseDocumentStoreContextStore[]>;
+/**
+ * Provides the DbxFirebaseDocumentStoreContextStore.
+ */
+declare function provideDbxFirebaseDocumentStoreContextStore(): Provider[];
+/**
+ * Links a DbxFirebaseDocumentStore to parent DbxFirebaseDocumentStoreContextStore instances.
+ *
+ * This should be called in an Angular injection context.
+ */
+declare function linkDocumentStoreToParentContextStores(store: DbxFirebaseDocumentStore<any, any>): void;
+
+/**
+ * Directive that provides a DbxFirebaseDocumentStoreContextStore.
+ */
+declare class DbxFirebaseDocumentStoreContextStoreDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseDocumentStoreContextStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseDocumentStoreContextStoreDirective, "[dbxFirebaseDocumentStoreContextStore]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SystemStateCollectionStore extends AbstractDbxFirebaseCollectionStore<SystemState, SystemStateDocument> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SystemStateCollectionStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SystemStateCollectionStore>;
+}
+
+declare class DbxFirebaseSystemStateCollectionStoreDirective extends DbxFirebaseCollectionStoreDirective<SystemState, SystemStateDocument, SystemStateCollectionStore> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseSystemStateCollectionStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseSystemStateCollectionStoreDirective, "[dbxFirebaseSystemStateCollection]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SystemStateDocumentStore<T extends SystemStateStoredData = SystemStateStoredData> extends AbstractDbxFirebaseDocumentStore<SystemState<T>, SystemStateDocument<T>> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SystemStateDocumentStore<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SystemStateDocumentStore<any>>;
+}
+
+/**
+ * Abstract class used for accessing a SystemStateDocumentStore's data.
+ */
+declare abstract class AbstractSystemStateDocumentStoreAccessor<T extends SystemStateStoredData = SystemStateStoredData> {
+    readonly systemStateDocumentStore: SystemStateDocumentStore<T>;
+    readonly documentData$: Observable<_dereekb_firebase.DocumentDataWithIdAndKey<SystemState<T>>>;
+    readonly data$: Observable<T>;
+    readonly dataState$: Observable<LoadingState<T>>;
+    readonly exists$: Observable<boolean>;
+    readonly doesNotExist$: Observable<boolean>;
+    readonly type$: Observable<SystemStateTypeIdentifier>;
+    constructor(type: SystemStateTypeIdentifier);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractSystemStateDocumentStoreAccessor<any>, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AbstractSystemStateDocumentStoreAccessor<any>>;
+}
+
+declare class DbxFirebaseSystemStateDocumentStoreDirective<T extends SystemStateStoredData = SystemStateStoredData> extends DbxFirebaseDocumentStoreDirective<SystemState<T>, SystemStateDocument<T>, SystemStateDocumentStore<T>> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseSystemStateDocumentStoreDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseSystemStateDocumentStoreDirective<any>, "[dbxFirebaseSystemStateDocument]", never, {}, {}, never, never, true, never>;
+}
+
+declare const DBX_FIREBASE_MODEL_DOES_NOT_EXIST_ERROR = "DOES_NOT_EXIST";
+declare function modelDoesNotExistError(): _dereekb_util.ReadableErrorWithCode<_dereekb_util.ReadableError>;
+
+declare class DbxFirebaseModelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFirebaseModelModule, never, never, [typeof DbxFirebaseModelStoreModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseModelModule>;
+}
+
+/**
+ * Client-side service used for retrieving notification templates.
+ */
+declare class DbxFirebaseNotificationTemplateService {
+    readonly appNotificationTemplateTypeInfoRecordService: AppNotificationTemplateTypeInfoRecordService;
+    notificationItemSubjectMessagePairForNotificationSummaryItem<D extends NotificationItemMetadata = {}>(item: NotificationItem<D>): NotificationItemSubjectMessagePair<D>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationTemplateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseNotificationTemplateService>;
+}
+
+type NotificationItemWithSelection = DbxValueAsListItem<NotificationItem>;
+declare class DbxFirebaseNotificationItemListComponent extends AbstractDbxSelectionListWrapperDirective<NotificationItem> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationItemListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseNotificationItemListComponent, "dbx-firebase-notificationitem-list", never, {}, {}, never, ["[top]", "[bottom]", "[empty]", "[emptyLoading]", "[end]"], true, never>;
+}
+declare class DbxFirebaseNotificationItemListViewComponent extends AbstractDbxSelectionListViewDirective<NotificationItem> {
+    readonly config: DbxSelectionValueListViewConfig<NotificationItemWithSelection>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationItemListViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseNotificationItemListViewComponent, "dbx-firebase-notificationitem-list-view", never, {}, {}, never, never, true, never>;
+}
+declare class DbxFirebaseNotificationItemListViewItemComponent extends AbstractDbxValueListViewItemComponent<NotificationItem> {
+    readonly dbxFirebaseNotificationTemplateService: DbxFirebaseNotificationTemplateService;
+    readonly pairGetter: _dereekb_util.CachedFactoryWithInput<_dereekb_firebase.NotificationItemSubjectMessagePair<{}>, unknown>;
+    get subject(): string;
+    get message(): string;
+    get date(): Date;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationItemListViewItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseNotificationItemListViewItemComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseNotificationItemContentComponent {
+    readonly subject: i0.InputSignal<Maybe<string>>;
+    readonly message: i0.InputSignal<Maybe<string>>;
+    readonly date: i0.InputSignal<Maybe<Date>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationItemContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseNotificationItemContentComponent, "dbx-firebase-notificationitem-content", never, { "subject": { "alias": "subject"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "date": { "alias": "date"; "required": false; "isSignal": true; }; }, {}, never, ["[header]", "[premessage]", "*"], true, never>;
+}
+
+declare class DbxFirebaseNotificationItemViewComponent<D extends NotificationItemMetadata = {}> {
+    readonly item: i0.InputSignal<Maybe<NotificationItem<D>>>;
+    readonly configSignal: i0.Signal<DbxWidgetViewComponentConfig<unknown> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationItemViewComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseNotificationItemViewComponent<any>, "dbx-firebase-notificationitem-view", never, { "item": { "alias": "item"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class AbstractDbxFirebaseNotificationItemWidgetComponent<D extends NotificationItemMetadata = {}> extends AbstractDbxWidgetComponent<NotificationItem<D>> {
+    get notificationItem(): NotificationItem<D>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxFirebaseNotificationItemWidgetComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxFirebaseNotificationItemWidgetComponent<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseNotificationItemDefaultViewComponent extends AbstractDbxFirebaseNotificationItemWidgetComponent {
+    get subject(): _dereekb_util.Maybe<string>;
+    get message(): _dereekb_util.Maybe<string>;
+    get date(): Date;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationItemDefaultViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseNotificationItemDefaultViewComponent, "dbx-firebase-notificationitem-view-default", never, {}, {}, never, never, true, never>;
+}
+
+interface DbxFirebaseNotificationItemStorePopoverParams {
+    /**
+     * Custom icon
+     *
+     * Defaults to "history"
+     */
+    readonly icon?: string;
+    /**
+     * Custom header text
+     *
+     * Defaults to "History"
+     */
+    readonly header?: string;
+    /**
+     * Custom empty text when no items exist.
+     */
+    readonly emptyText?: string;
+    /**
+     * Origin to add the popover to.
+     */
+    readonly origin: ElementRef;
+    /**
+     * Items loading state.
+     */
+    readonly notificationItemsLoadingState$: Observable<LoadingState<NotificationItem[]>>;
+    /**
+     * Anchor
+     */
+    readonly makeNotificationItemAnchor?: Maybe<AnchorForValueFunction<NotificationItem>>;
+}
+declare const DEFAULT_DBX_FIREBASE_NOTIFICATION_ITEM_STORE_POPOVER_KEY = "notification-item-store-notifications";
+declare class DbxFirebaseNotificationItemStorePopoverComponent extends AbstractPopoverDirective<unknown, DbxFirebaseNotificationItemStorePopoverParams> {
+    static openPopover(popupService: DbxPopoverService, { origin, header, icon, emptyText, makeNotificationItemAnchor, notificationItemsLoadingState$ }: DbxFirebaseNotificationItemStorePopoverParams, popoverKey?: DbxPopoverKey): NgPopoverRef;
+    readonly params: DbxFirebaseNotificationItemStorePopoverParams;
+    readonly icon: string;
+    readonly header: string;
+    readonly emptyText: string;
+    readonly makeNotificationItemAnchor: Maybe<AnchorForValueFunction<NotificationItem<{}>>>;
+    readonly notificationItemsLoadingState$: Observable<LoadingState<NotificationItem<{}>[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationItemStorePopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseNotificationItemStorePopoverComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+type DbxFirebaseNotificationItemStorePopoverButtonConfig = DbxFirebaseNotificationItemStorePopoverParams;
+declare class DbxFirebaseNotificationItemStorePopoverButtonComponent extends AbstractPopoverRefDirective<unknown, unknown> {
+    private readonly _dbxPopoverService;
+    private readonly _dbxFirebaseNotificationItemStore;
+    readonly buttonElement: i0.Signal<Maybe<ElementRef<any>>>;
+    readonly config: i0.InputSignal<Maybe<Partial<DbxFirebaseNotificationItemStorePopoverParams>>>;
+    showNotificationsPopover(): void;
+    protected _makePopoverRef(origin?: ElementRef): NgPopoverRef<unknown, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationItemStorePopoverButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseNotificationItemStorePopoverButtonComponent, "dbx-firebase-notification-item-store-popover-button", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface DbxFirebaseNotificationItemStoreState {
+    /**
+     * The NotificationSummary to pull items from
+     */
+    readonly items: NotificationItem[];
+    /**
+     * The currently selected id
+     */
+    readonly selectedId: Maybe<NotificationId>;
+}
+/**
+ * Store used for selecting a specific NotificationItem from a list of notification items.
+ */
+declare class DbxFirebaseNotificationItemStore extends ComponentStore<DbxFirebaseNotificationItemStoreState> {
+    constructor();
+    readonly items$: rxjs.Observable<NotificationItem<{}>[]>;
+    readonly selectedId$: rxjs.Observable<Maybe<string>>;
+    readonly selectedItem$: rxjs.Observable<NotificationItem<{}> | undefined>;
+    readonly setItems: (observableOrValue: NotificationItem<{}>[] | rxjs.Observable<NotificationItem<{}>[]>) => rxjs.Subscription;
+    readonly setSelectedId: (() => void) | ((observableOrValue: Maybe<string> | rxjs.Observable<Maybe<string>>) => rxjs.Subscription);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationItemStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseNotificationItemStore>;
+}
+
+declare class NotificationDocumentStore extends AbstractDbxFirebaseDocumentWithParentStore<Notification, NotificationBox, NotificationDocument, NotificationBoxDocument> {
+    readonly notificationFunctions: NotificationFunctions;
+    constructor();
+    readonly createdAt$: rxjs.Observable<_dereekb_util.Maybe<Date>>;
+    readonly nextSendAt$: rxjs.Observable<_dereekb_util.Maybe<Date>>;
+    readonly sendType$: rxjs.Observable<_dereekb_firebase.NotificationSendType>;
+    readonly sendAttemptsCount$: rxjs.Observable<number>;
+    readonly isUnique$: rxjs.Observable<_dereekb_util.Maybe<boolean>>;
+    readonly sendNotification: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.SendNotificationParams, _dereekb_firebase.SendNotificationResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationDocumentStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationDocumentStore>;
+}
+
+declare class DbxFirebaseNotificationDocumentStoreDirective extends DbxFirebaseDocumentStoreDirective<Notification, NotificationDocument, NotificationDocumentStore> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationDocumentStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseNotificationDocumentStoreDirective, "[dbxFirebaseNotificationDocument]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NotificationBoxDocumentStore extends AbstractDbxFirebaseDocumentStore<NotificationBox, NotificationBoxDocument> {
+    readonly notificationFunctions: NotificationFunctions;
+    constructor();
+    readonly createdAt$: rxjs.Observable<_dereekb_util.Maybe<Date>>;
+    readonly recipients$: rxjs.Observable<_dereekb_firebase.NotificationBoxRecipient[]>;
+    readonly updateNotificationBox: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.UpdateNotificationBoxParams, void>;
+    readonly updateNotificationBoxRecipient: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.UpdateNotificationBoxRecipientParams, void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationBoxDocumentStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationBoxDocumentStore>;
+}
+
+declare class NotificationCollectionStore extends AbstractDbxFirebaseCollectionWithParentStore<Notification, NotificationBox, NotificationDocument, NotificationBoxDocument> {
+    constructor(parent: NotificationBoxDocumentStore);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationCollectionStore, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationCollectionStore>;
+}
+
+declare class DbxFirebaseNotificationCollectionStoreDirective extends DbxFirebaseCollectionWithParentStoreDirective<Notification, NotificationBox, NotificationDocument, NotificationBoxDocument, NotificationCollectionStore> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationCollectionStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseNotificationCollectionStoreDirective, "[dbxFirebaseNotificationCollection]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFirebaseNotificationBoxDocumentStoreDirective extends DbxFirebaseDocumentStoreDirective<NotificationBox, NotificationBoxDocument, NotificationBoxDocumentStore> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationBoxDocumentStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseNotificationBoxDocumentStoreDirective, "[dbxFirebaseNotificationBoxDocument]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NotificationBoxCollectionStore extends AbstractDbxFirebaseCollectionStore<NotificationBox, NotificationBoxDocument> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationBoxCollectionStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationBoxCollectionStore>;
+}
+
+declare class DbxFirebaseNotificationBoxCollectionStoreDirective extends DbxFirebaseCollectionStoreDirective<NotificationBox, NotificationBoxDocument, NotificationBoxCollectionStore> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationBoxCollectionStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseNotificationBoxCollectionStoreDirective, "[dbxFirebaseNotificationBoxCollection]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NotificationSummaryCollectionStore extends AbstractDbxFirebaseCollectionStore<NotificationSummary, NotificationSummaryDocument> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationSummaryCollectionStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationSummaryCollectionStore>;
+}
+
+declare class DbxFirebaseNotificationSummaryCollectionStoreDirective extends DbxFirebaseCollectionStoreDirective<NotificationSummary, NotificationSummaryDocument, NotificationSummaryCollectionStore> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationSummaryCollectionStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseNotificationSummaryCollectionStoreDirective, "[dbxFirebaseNotificationSummaryCollection]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NotificationSummaryDocumentStore extends AbstractDbxFirebaseDocumentStore<NotificationSummary, NotificationSummaryDocument> {
+    readonly notificationFunctions: NotificationFunctions;
+    constructor();
+    readonly notificationItemsLoadingState$: Observable<LoadingState<NotificationItem<any>[]>>;
+    readonly createdAt$: Observable<Maybe<Date>>;
+    readonly lastReadAt$: Observable<Maybe<Date>>;
+    readonly lastUpdateAt$: Observable<Maybe<Date>>;
+    readonly notificationItems$: Observable<NotificationItem<{}>[]>;
+    readonly needsSync$: Observable<Maybe<boolean>>;
+    notificationItemsLoadingState<D extends NotificationItemMetadata = {}>(): Observable<LoadingState<NotificationItem<D>[]>>;
+    unreadNotificationItems<D extends NotificationItemMetadata = {}>(checkLastReadIfCreatedBeforeObs?: ObservableOrValue<Maybe<Date>>): Observable<UnreadNotificationItemsResult<D>>;
+    readonly updateNotificationSummary: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.UpdateNotificationSummaryParams, void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationSummaryDocumentStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationSummaryDocumentStore>;
+}
+
+declare class DbxFirebaseNotificationSummaryDocumentStoreDirective extends DbxFirebaseDocumentStoreDirective<NotificationSummary, NotificationSummaryDocument, NotificationSummaryDocumentStore> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationSummaryDocumentStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseNotificationSummaryDocumentStoreDirective, "[dbxFirebaseNotificationSummaryDocument]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NotificationUserCollectionStore extends AbstractDbxFirebaseCollectionStore<NotificationUser, NotificationUserDocument> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationUserCollectionStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationUserCollectionStore>;
+}
+
+declare class DbxFirebaseNotificationUserCollectionStoreDirective extends DbxFirebaseCollectionStoreDirective<NotificationUser, NotificationUserDocument, NotificationUserCollectionStore> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationUserCollectionStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseNotificationUserCollectionStoreDirective, "[dbxFirebaseNotificationUserCollection]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NotificationUserDocumentStore extends AbstractDbxFirebaseDocumentStore<NotificationUser, NotificationUserDocument> {
+    readonly notificationFunctions: NotificationFunctions;
+    constructor();
+    readonly updateNotificationUser: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.UpdateNotificationUserParams, void>;
+    readonly resyncNotificationUser: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.ResyncNotificationUserParams, _dereekb_firebase.ResyncNotificationUserResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationUserDocumentStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationUserDocumentStore>;
+}
+
+declare class DbxFirebaseNotificationUserDocumentStoreDirective extends DbxFirebaseDocumentStoreDirective<NotificationUser, NotificationUserDocument, NotificationUserDocumentStore> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationUserDocumentStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseNotificationUserDocumentStoreDirective, "[dbxFirebaseNotificationUserDocument]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Prefix used by all widgets.
+ *
+ * Does not include the "-" between the prefix and the template type returned by dbxWidgetTypeForNotificationTemplateType().
+ */
+declare const FIREBASE_NOTIFICATION_ITEM_WIDGET_TYPE_PREFIX: string;
+declare const DEFAULT_FIREBASE_NOTIFICATION_ITEM_WIDGET_TYPE: DbxWidgetType;
+declare function dbxWidgetTypeForNotificationTemplateType(notificationTemplateType: NotificationTemplateType): DbxWidgetType;
+/**
+ * Used for registering a DbxFirebaseNotificationItemWidgetEntry.
+ *
+ * The notificationTemplateType should be known by the app, otherwise a warning may be thrown.
+ */
+interface DbxFirebaseNotificationItemWidgetEntryRegistration extends Omit<DbxWidgetEntry, 'type'> {
+    readonly notificationTemplateType: NotificationTemplateType;
+}
+/**
+ * A widget used for DbxFirebaseNotificationItem views.
+ */
+interface DbxFirebaseNotificationItemWidgetEntry {
+    readonly notificationTemplateType: NotificationTemplateType;
+    readonly notificationTemplateTypeInfo: NotificationTemplateTypeInfo;
+    readonly widget: DbxWidgetEntry;
+}
+
+/**
+ * Service used for registering widgets used for notification items.
+ */
+declare class DbxFirebaseNotificationItemWidgetService {
+    readonly dbxWidgetService: DbxWidgetService;
+    readonly dbxFirebaseNotificationTemplateService: DbxFirebaseNotificationTemplateService;
+    private readonly _entries;
+    /**
+     * Used to register a item widget. If widget for the given type is already registered, this will override it by default.
+     *
+     * @param provider
+     * @param override
+     */
+    register(provider: DbxFirebaseNotificationItemWidgetEntryRegistration, override?: boolean): boolean;
+    registerDefaultWidget(entry: Omit<DbxWidgetEntry, 'type'>, override?: boolean): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationItemWidgetService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseNotificationItemWidgetService>;
+}
+
+/**
+ * Configuration for DbxFirebaseNotificationModule.
+ */
+interface ProvideDbxFirebaseNotificationsConfig {
+    readonly appNotificationTemplateTypeInfoRecordService: AppNotificationTemplateTypeInfoRecordService;
+    /**
+     * The default notification item widget to register with the DbxFirebaseNotificationItemWidgetService.
+     *
+     * If not defined, will automatically register the default widget.
+     *
+     * If false, will not register anything.
+     */
+    readonly defaultNotificationItemWidget?: DbxWidgetEntry['componentClass'] | false;
+}
+/**
+ * Creates EnvironmentProviders that provides a DbxFirebaseNotificationTemplateService, DbxFirebaseNotificationItemWidgetService and AppNotificationTemplateTypeInfoRecordService.
+ *
+ * @param config Configuration
+ * @returns EnvironmentProviders
+ */
+declare function provideDbxFirebaseNotifications(config: ProvideDbxFirebaseNotificationsConfig): EnvironmentProviders;
+
+interface DbxFirebaseStorageFileDownloadUrlPair {
+    readonly id: StorageFileId;
+    readonly downloadUrl: StorageFileSignedDownloadUrl;
+    /**
+     * Mime type, if available.
+     */
+    readonly mimeType?: Maybe<ContentTypeMimeType>;
+    /**
+     * Expiration in seconds since epoch.
+     */
+    readonly expiresAt: UnixDateTimeSecondsNumber;
+}
+type DbxFirebaseStorageFileDownloadUrlPairString = `${UnixDateTimeSecondsNumber}_${StorageFileSignedDownloadUrl}`;
+type DbxFirebaseStorageFileDownloadUrlPairsRecord = Record<StorageFileId, DbxFirebaseStorageFileDownloadUrlPairString>;
+interface DbxFirebaseStorageFileDownloadUserCache {
+    readonly uid: FirebaseAuthUserId;
+    readonly pairs: DbxFirebaseStorageFileDownloadUrlPairsRecord;
+}
+/**
+ * Token that corresponds to a StorageAccessor<DbxFirebaseStorageFileDownloadUserCache> that is used by DbxModelViewTrackerStorage.
+ */
+declare const DBX_FIREBASE_STORAGEFILE_DOWNLOAD_STORAGE_ACCESSOR_TOKEN: InjectionToken<unknown>;
+/**
+ * Used for managing DbxModelViewTrackerEvent storage.
+ */
+declare class DbxFirebaseStorageFileDownloadStorage {
+    static readonly DEFAULT_MAX_DOWNLOAD_URLS = 100;
+    readonly authService: DbxFirebaseAuthService;
+    readonly storageAccessor: StorageAccessor<DbxFirebaseStorageFileDownloadUserCache>;
+    addDownloadUrl({ id, downloadUrl, expiresAt, mimeType }: DbxFirebaseStorageFileDownloadUrlPair): Observable<void>;
+    /**
+     * Returns the cached download URL pair for the given key.
+     *
+     * The pair may be expired.
+     *
+     * @param key
+     * @returns
+     */
+    getDownloadUrlPair(input: FirestoreModelIdInput): Observable<DbxFirebaseStorageFileDownloadUrlPair | undefined>;
+    getAllDownloadUrlPairsRecord(uid: FirebaseAuthUserId): Observable<DbxFirebaseStorageFileDownloadUrlPairsRecord>;
+    getCurrentUserDownloadCache(): Observable<DbxFirebaseStorageFileDownloadUserCache>;
+    getUserDownloadCache(uid: FirebaseAuthUserId): Observable<DbxFirebaseStorageFileDownloadUserCache>;
+    clearCurrentUserDownloadCache(): Observable<void>;
+    clearUserDownloadCache(uid: FirebaseAuthUserId): Observable<void>;
+    private _getUserDownloadCacheForStorageKey;
+    getStorageKeyForUid(uid: FirebaseAuthUserId): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageFileDownloadStorage, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseStorageFileDownloadStorage>;
+}
+
+type DbxFirebaseStorageFileDownloadServiceCustomSourceDownloadFunction = (params: DownloadStorageFileParams, storageFileId: StorageFileId) => Promise<DownloadStorageFileResult>;
+/**
+ * Used as a custom source for downloading StorageFiles.
+ */
+interface DbxFirebaseStorageFileDownloadServiceCustomSource {
+    /**
+     * Retrieves the download result for the StorageFile using the input parameters.
+     *
+     * @param storageFileId
+     * @returns
+     */
+    downloadStorageFileResult: DbxFirebaseStorageFileDownloadServiceCustomSourceDownloadFunction;
+}
+declare function dbxFirebaseStorageFileDownloadServiceCustomSourceFromObs(obsForInput: (params: DownloadStorageFileParams, storageFileId: StorageFileId) => Observable<LoadingState<DownloadStorageFileResult>>): DbxFirebaseStorageFileDownloadServiceCustomSource;
+/**
+ * Service used for retrieving download links for StorageFiles.
+ */
+declare class DbxFirebaseStorageFileDownloadService {
+    /**
+     * Expiration duration for cached download URLs.
+     */
+    protected _expiresAfterTime: Milliseconds;
+    /**
+     * When reading cached values, this buffer is added to the expiration time to prevent the URL from expiring while it is being used.
+     */
+    protected _expiresAfterTimeBuffer: Seconds;
+    readonly storageFileFunctions: StorageFileFunctions;
+    readonly storageFileDownloadStorage: DbxFirebaseStorageFileDownloadStorage;
+    getExpiresAfterTime(): number;
+    setExpiresAfterTime(expiresAfter: number): void;
+    /**
+     * Returns an observable that returns the cached download URL pair for the StorageFile, and emits null once it expires.
+     *
+     * @param storageFileIdOrKey
+     * @returns
+     */
+    getCachedDownloadPairForStorageFile(storageFileIdOrKey: StorageFileId | StorageFileKey): Observable<Maybe<DbxFirebaseStorageFileDownloadUrlPair>>;
+    /**
+     * Retrieves the download URL for the StorageFile using the default parameters.
+     *
+     * These URLs are cached locally to prevent extra/redundant calls to the server.
+     *
+     * @param storageFileIdOrKey
+     * @returns
+     */
+    downloadPairForStorageFile(storageFileIdOrKey: StorageFileId | StorageFileKey): Observable<DbxFirebaseStorageFileDownloadUrlPair>;
+    /**
+     * Retrieves the download URL for the StorageFile using the default parameters and pulled from the input source, if applicable.
+     *
+     * If no source is provided, uses the default internal source.
+     *
+     * These URLs are cached locally to prevent extra/redundant calls to the server.
+     *
+     * @param storageFileIdOrKey
+     * @returns
+     */
+    downloadPairForStorageFileUsingSource(storageFileIdOrKey: StorageFileId | StorageFileKey, source: Maybe<DbxFirebaseStorageFileDownloadServiceCustomSource>): Observable<DbxFirebaseStorageFileDownloadUrlPair>;
+    /**
+     * Adds the given download URL pair to the cache.
+     */
+    addPairForStorageFileToCache(downloadUrlPair: DbxFirebaseStorageFileDownloadUrlPair): void;
+    /**
+     * Creates a new download URL for the StorageFile.
+     *
+     * @param storageFileIdOrKey
+     * @param inputParams
+     * @returns
+     */
+    createDownloadPairForStorageFile(storageFileIdOrKey: StorageFileId | StorageFileKey, inputParams?: Omit<DownloadStorageFileParams, 'key'>): Promise<DbxFirebaseStorageFileDownloadUrlPair>;
+    private _createDownloadPairForStorageFileUsingSource;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageFileDownloadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseStorageFileDownloadService>;
+}
+
+interface DbxFirebaseStorageFileDownloadDetails {
+    readonly downloadUrl: StorageFileDownloadUrl;
+    readonly mimeType?: Maybe<ContentTypeMimeType>;
+    readonly expiresAt?: Maybe<Date>;
+}
+/**
+ * Source configuration for the DbxFirebaseStorageFileDownloadButtonComponent.
+ */
+interface DbxFirebaseStorageFileDownloadButtonSource {
+    /**
+     * A static StorageFileKey to use.
+     */
+    readonly storageFileKey?: MaybeObservableOrValue<StorageFileKey>;
+    /**
+     * Whether or not to pre-load the download url from the source.
+     *
+     * Defaults to false.
+     */
+    readonly preload?: Maybe<boolean>;
+    /**
+     * The expected mime type of the StorageFile to use when previewing.
+     */
+    readonly storageFileEmbedMimeType?: MaybeObservableOrValue<ContentTypeMimeType | string>;
+    /**
+     * Custom source to use with the DbxFirebaseStorageFileDownloadService. A more simple alternative to using handleGetDownloadUrl().
+     */
+    readonly customSource?: Maybe<DbxFirebaseStorageFileDownloadServiceCustomSource>;
+    /**
+     * Optional custom work to use to get the download URL.
+     *
+     * If provided, customSource is ignored.
+     */
+    readonly handleGetDownloadUrl?: Maybe<WorkUsingContext<StorageFileKey, DbxFirebaseStorageFileDownloadUrlPair>>;
+    /**
+     * Optional custom success handler for the download URL.
+     */
+    readonly handleGetDownloadUrlSuccess?: (value: DbxFirebaseStorageFileDownloadUrlPair) => void;
+    /**
+     * Optional custom error handler for the download URL.
+     */
+    readonly handleGetDownloadUrlError?: (error: unknown) => void;
+    /**
+     * Called when the download details change.
+     */
+    readonly downloadDetailsChangeCallback?: Maybe<(downloadDetails: Maybe<DbxFirebaseStorageFileDownloadDetails>) => void>;
+}
+/**
+ * Configuration for the DbxFirebaseStorageFileDownloadButtonComponent.
+ */
+interface DbxFirebaseStorageFileDownloadButtonConfig {
+    readonly buttonStyle?: Maybe<DbxButtonStyle>;
+    readonly previewButtonStyle?: Maybe<DbxButtonStyle>;
+    /**
+     * Whether or not to show a preview button.
+     *
+     * Defaults to true.
+     */
+    readonly showPreviewButton?: Maybe<boolean>;
+    readonly icon?: Maybe<string>;
+    readonly text?: Maybe<string>;
+    readonly downloadReadyIcon?: Maybe<string>;
+    readonly downloadReadyText?: Maybe<string>;
+    readonly previewIcon?: Maybe<string>;
+    readonly previewText?: Maybe<string>;
+    /**
+     * Optional custom function to open a preview dialog. If not provided, the default preview dialog provided by the DbxWebFilePreviewService will be used.
+     *
+     * The function can return undefined, in which case the default preview dialog will be used.
+     */
+    readonly openCustomPreview?: Maybe<(downloadUrl: StorageFileDownloadUrl, embedMimeType?: Maybe<string>) => Maybe<MatDialogRef<any>>>;
+    /**
+     * Whether or not to pre-load the download url from the source.
+     *
+     * Defaults to false.
+     *
+     * @deprecated use the preload property on the source/DbxFirebaseStorageFileDownloadButtonSource instead.
+     */
+    readonly preload?: Maybe<boolean>;
+}
+declare class DbxFirebaseStorageFileDownloadButtonComponent {
+    readonly matDialog: MatDialog;
+    readonly dbxWebFilePreviewService: DbxWebFilePreviewService;
+    readonly dbxFirebaseStorageFileDownloadService: DbxFirebaseStorageFileDownloadService;
+    /**
+     * The StorageFileKey to set up the download button for.
+     */
+    readonly storageFileKey: i0.InputSignal<Maybe<string>>;
+    /**
+     * The download URL to use for the download button.
+     */
+    readonly storageFileDownloadUrl: i0.InputSignal<Maybe<string>>;
+    /**
+     * The MIME type to use the embed component.
+     */
+    readonly embedMimeType: i0.InputSignal<Maybe<string>>;
+    /**
+     * Whether or not to show a preview button.
+     *
+     * Defaults to true.
+     */
+    readonly showPreviewButton: i0.InputSignal<Maybe<boolean>>;
+    /**
+     * Whether or not to pre-load the download URL from the source.
+     */
+    readonly preload: i0.InputSignal<Maybe<boolean>>;
+    /**
+     * Output event emitted when the download details change.
+     */
+    readonly downloadDetailsChange: i0.OutputEmitterRef<Maybe<DbxFirebaseStorageFileDownloadDetails>>;
+    readonly config: i0.InputSignal<Maybe<DbxFirebaseStorageFileDownloadButtonConfig>>;
+    readonly source: i0.InputSignal<Maybe<DbxFirebaseStorageFileDownloadButtonSource>>;
+    readonly source$: Observable<Maybe<DbxFirebaseStorageFileDownloadButtonSource>>;
+    readonly configSignal: i0.Signal<DbxFirebaseStorageFileDownloadButtonConfig>;
+    readonly preloadSignal: i0.Signal<boolean>;
+    readonly downloadUrlSignal: i0.WritableSignal<Maybe<string>>;
+    readonly downloadMimeTypeSignal: i0.WritableSignal<Maybe<string>>;
+    readonly downloadUrlExpiresAtSignal: i0.WritableSignal<Maybe<DateOrUnixDateTimeSecondsNumber>>;
+    readonly storageFileKeyFromInput$: Observable<Maybe<string>>;
+    readonly storageFileKeyFromSource$: Observable<Maybe<StorageFileKey>>;
+    readonly storageFileKey$: Observable<Maybe<StorageFileKey>>;
+    readonly storageFileKeySignal: i0.Signal<Maybe<string>>;
+    readonly hasDownloadUrlSignal: i0.Signal<boolean>;
+    readonly buttonStyleSignal: i0.Signal<DbxButtonStyle>;
+    readonly previewButtonStyleSignal: i0.Signal<DbxButtonStyle>;
+    readonly iconSignal: i0.Signal<Maybe<string>>;
+    readonly textSignal: i0.Signal<Maybe<string>>;
+    readonly previewIconSignal: i0.Signal<Maybe<string>>;
+    readonly previewTextSignal: i0.Signal<Maybe<string>>;
+    readonly anchorSignal: i0.Signal<Maybe<ClickableAnchor>>;
+    readonly storageFileDownloadUrlEffect: i0.EffectRef;
+    readonly showPreviewButtonSignal: i0.Signal<boolean>;
+    readonly openCustomPreviewSignal: i0.Signal<Maybe<(downloadUrl: StorageFileDownloadUrl, embedMimeType?: Maybe<string>) => Maybe<MatDialogRef<any>>>>;
+    readonly handleOpenPreviewDialog: DbxActionDialogFunction;
+    readonly cachedUrlForStorageFileKey$: Observable<Maybe<DbxFirebaseStorageFileDownloadUrlPair>>;
+    readonly cachedUrlForStorageFileKeySignal: i0.Signal<Maybe<DbxFirebaseStorageFileDownloadUrlPair>>;
+    readonly cachedUrlEffect: i0.EffectRef;
+    readonly downloadUrlExpiresAtDate$: Observable<Maybe<Date>>;
+    readonly downloadUrlExpiresAtDateSignal: i0.Signal<Maybe<Date>>;
+    readonly downloadUrlHasExpired$: Observable<boolean>;
+    readonly downloadUrlHasExpiredSignal: i0.Signal<boolean | undefined>;
+    readonly downloadUrlHasExpiredEffect: i0.EffectRef;
+    readonly downloadDetailsSignal: i0.Signal<DbxFirebaseStorageFileDownloadDetails | undefined>;
+    readonly downloadDetailsChangedEffect: i0.EffectRef;
+    readonly sourceDownloadDetailsChangeCallbackEffect: i0.EffectRef;
+    readonly handleGetDownloadUrl: WorkUsingContext<StorageFileKey, DbxFirebaseStorageFileDownloadUrlPair>;
+    readonly handleGetDownloadUrlSuccess: (value: DbxFirebaseStorageFileDownloadUrlPair) => void;
+    readonly handleGetDownloadUrlError: (error: unknown) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageFileDownloadButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseStorageFileDownloadButtonComponent, "dbx-firebase-storagefile-download-button", never, { "storageFileKey": { "alias": "storageFileKey"; "required": false; "isSignal": true; }; "storageFileDownloadUrl": { "alias": "storageFileDownloadUrl"; "required": false; "isSignal": true; }; "embedMimeType": { "alias": "embedMimeType"; "required": false; "isSignal": true; }; "showPreviewButton": { "alias": "showPreviewButton"; "required": false; "isSignal": true; }; "preload": { "alias": "preload"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "source": { "alias": "source"; "required": false; "isSignal": true; }; }, { "downloadDetailsChange": "downloadDetailsChange"; }, never, never, true, never>;
+}
+
+/**
+ * The stage of the upload process.
+ *
+ * - configuration: The initial stage where the upload store is being configured.
+ * - files: The stage where the files are to be selected.
+ * - uploading: The stage where the files are being uploaded.
+ * - success: The stage where the files have been successfully uploaded.
+ * - error: The stage where the upload has failed.
+ */
+type DbxFirebaseStorageFileUploadStoreUploadStage = 'configuration' | 'files' | 'uploading' | 'success' | 'error';
+/**
+ * The accepted file types for the upload.
+ *
+ * If unset, then all file types are accepted.
+ */
+type DbxFirebaseStorageFileUploadStoreAllowedTypes = FileAcceptFilterTypeString[];
+/**
+ * The progress of a file being uploaded.
+ *
+ * File progresses are automatically created for all files when one file's progress is
+ */
+interface DbxFirebaseStorageFileUploadStoreFileProgress<T = unknown> {
+    /**
+     * The file being uploaded.
+     */
+    readonly file: File;
+    /**
+     * The accessor file for the file, if available.
+     */
+    readonly fileRef?: Maybe<FirebaseStorageAccessorFile>;
+    /**
+     * The upload reference info for the file, if available.
+     */
+    readonly uploadRef?: Maybe<T>;
+    /**
+     * The number of bytes that have been transferred for this file.
+     */
+    readonly bytesTransferred?: Maybe<number>;
+    /**
+     * The total number of bytes to be uploaded.
+     */
+    readonly totalBytes?: Maybe<number>;
+    /**
+     * The progress of the upload.
+     *
+     * If unset, then the file has not started uploading.
+     */
+    readonly progress?: Maybe<PercentDecimal>;
+    /**
+     * If true, the upload has failed for this file.
+     */
+    readonly failed?: boolean;
+    /**
+     * The error that occurred during the upload for this file.
+     */
+    readonly error?: unknown;
+}
+interface DbxFirebaseStorageFileUploadStoreState {
+    /**
+     * The default accepted file types for the upload.
+     *
+     * This may be set by the component.
+     */
+    readonly componentFileTypesAccepted?: Maybe<DbxFirebaseStorageFileUploadStoreAllowedTypes>;
+    /**
+     * If true, the component allows multiple files to be selected.
+     *
+     * Defaults to undefined.
+     */
+    readonly isComponentMultiUploadAllowed?: Maybe<boolean>;
+    /**
+     * The accepted file types for the upload.
+     *
+     * Is used to filter the files that can be selected for upload.
+     *
+     * Overrides the componentFileTypesAccepted value if set.
+     */
+    readonly fileTypesAccepted?: Maybe<DbxFirebaseStorageFileUploadStoreAllowedTypes>;
+    /**
+     * If true, allow selecting multiple files for upload.
+     *
+     * If isComponentMultiUploadAllowed is false, then this value is ignored.
+     */
+    readonly isMultiUploadAllowed?: Maybe<boolean>;
+    /**
+     * Path to upload the file(s) to.
+     *
+     * Must be set before uploading.
+     */
+    readonly uploadPath?: Maybe<StoragePathInput>;
+    /**
+     * The current file(s) to upload.
+     */
+    readonly files?: Maybe<File[]>;
+    /**
+     * The progress of the upload for each file.
+     *
+     * Only set while one or more files are being uploaded.
+     */
+    readonly latestProgressEvent?: Maybe<StorageFileUploadFilesEvent>;
+    /**
+     * If true, the upload handler is working.
+     */
+    readonly isUploadHandlerWorking?: Maybe<boolean>;
+    /**
+     * The final upload result for the files.
+     *
+     * Only set after the upload has completed.
+     */
+    readonly uploadResult?: Maybe<StorageFileUploadFilesFinalResult>;
+}
+/**
+ * Store used for selecting a specific NotificationItem from a list of notification items.
+ */
+declare class DbxFirebaseStorageFileUploadStore extends ComponentStore<DbxFirebaseStorageFileUploadStoreState> {
+    constructor();
+    readonly componentFileTypesAccepted$: rxjs.Observable<Maybe<DbxFirebaseStorageFileUploadStoreAllowedTypes>>;
+    readonly isComponentMultiUploadAllowed$: rxjs.Observable<Maybe<boolean>>;
+    readonly fileTypesAllowed$: rxjs.Observable<DbxFirebaseStorageFileUploadStoreAllowedTypes>;
+    readonly fileTypesAcceptString$: rxjs.Observable<string>;
+    readonly isMultiUploadAllowed$: rxjs.Observable<Maybe<boolean>>;
+    readonly uploadPath$: rxjs.Observable<Maybe<StoragePathInput>>;
+    readonly currentFiles$: rxjs.Observable<Maybe<File[]>>;
+    readonly files$: rxjs.Observable<File[]>;
+    readonly isUploadHandlerWorking$: rxjs.Observable<Maybe<boolean>>;
+    readonly latestProgressEvent$: rxjs.Observable<Maybe<StorageFileUploadFilesEvent>>;
+    readonly currentUploadResult$: rxjs.Observable<Maybe<StorageFileUploadFilesFinalResult>>;
+    readonly uploadResult$: rxjs.Observable<StorageFileUploadFilesFinalResult>;
+    readonly setComponentFileTypesAccepted: (() => void) | ((observableOrValue: Maybe<DbxFirebaseStorageFileUploadStoreAllowedTypes> | rxjs.Observable<Maybe<DbxFirebaseStorageFileUploadStoreAllowedTypes>>) => rxjs.Subscription);
+    readonly setIsComponentMultiUploadAllowed: (() => void) | ((observableOrValue: Maybe<boolean> | rxjs.Observable<Maybe<boolean>>) => rxjs.Subscription);
+    readonly setUploadPath: (() => void) | ((observableOrValue: Maybe<StoragePathInput> | rxjs.Observable<Maybe<StoragePathInput>>) => rxjs.Subscription);
+    readonly setFileTypesAccepted: (() => void) | ((observableOrValue: Maybe<ArrayOrValue<string>> | rxjs.Observable<Maybe<ArrayOrValue<string>>>) => rxjs.Subscription);
+    /**
+     * Sets the file list to upload.
+     *
+     * If the upload handler is working, the file list cannot be changed.
+     */
+    readonly setFiles: (() => void) | ((observableOrValue: Maybe<File[]> | rxjs.Observable<Maybe<File[]>>) => rxjs.Subscription);
+    readonly setIsMultiUploadAllowed: (() => void) | ((observableOrValue: Maybe<boolean> | rxjs.Observable<Maybe<boolean>>) => rxjs.Subscription);
+    /**
+     * Flags the upload handler to begin working.
+     *
+     * Once the upload handler is flagged, it cannot be unset until the upload handler has finished.
+     */
+    readonly setIsUploadHandlerWorking: (observableOrValue: boolean | rxjs.Observable<boolean>) => rxjs.Subscription;
+    /**
+     * Sets the latest progress event.
+     */
+    readonly setLatestProgressEvent: (() => void) | ((observableOrValue: Maybe<StorageFileUploadFilesEvent> | rxjs.Observable<Maybe<StorageFileUploadFilesEvent>>) => rxjs.Subscription);
+    /**
+     * Updates the upload progress for one or more files.
+     */
+    /**
+     * Sets the upload result.
+     */
+    readonly setUploadResult: (() => void) | ((observableOrValue: Maybe<StorageFileUploadFilesFinalResult> | rxjs.Observable<Maybe<StorageFileUploadFilesFinalResult>>) => rxjs.Subscription);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageFileUploadStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseStorageFileUploadStore>;
+}
+
+declare class StorageFileCollectionStore extends AbstractDbxFirebaseCollectionStore<StorageFile, StorageFileDocument> {
+    readonly storageFileFunctions: StorageFileFunctions;
+    constructor();
+    readonly initializeAllStorageFilesFromUpload: _dereekb_dbx_firebase.DbxFirebaseCollectionStoreCreateFunction<_dereekb_firebase.InitializeAllStorageFilesFromUploadsParams, _dereekb_firebase.InitializeAllStorageFilesFromUploadsResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageFileCollectionStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageFileCollectionStore>;
+}
+
+declare class DbxFirebaseStorageFileCollectionStoreDirective extends DbxFirebaseCollectionStoreDirective<StorageFile, StorageFileDocument, StorageFileCollectionStore> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageFileCollectionStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseStorageFileCollectionStoreDirective, "[dbxFirebaseStorageFileCollection]", never, {}, {}, never, never, true, never>;
+}
+
+declare class StorageFileDocumentStore extends AbstractDbxFirebaseDocumentStore<StorageFile, StorageFileDocument> {
+    readonly storageFileFunctions: StorageFileFunctions;
+    constructor();
+    readonly createStorageFileFromUpload: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreCreateFunction<_dereekb_firebase.CreateStorageFileParams, _dereekb_firebase.OnCallCreateModelResult>;
+    readonly initializeStorageFileFromUpload: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreCreateFunction<_dereekb_firebase.InitializeStorageFileFromUploadParams, _dereekb_firebase.OnCallCreateModelResult>;
+    readonly initializeAllStorageFilesFromUpload: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreCrudFunction<_dereekb_firebase.InitializeAllStorageFilesFromUploadsParams, _dereekb_firebase.InitializeAllStorageFilesFromUploadsResult>;
+    readonly updateStorageFile: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.UpdateStorageFileParams, void>;
+    readonly processStorageFile: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.ProcessStorageFileParams, _dereekb_firebase.ProcessStorageFileResult>;
+    readonly deleteStorageFile: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.DeleteStorageFileParams, void>;
+    readonly downloadStorageFile: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.DownloadStorageFileParams, _dereekb_firebase.DownloadStorageFileResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageFileDocumentStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageFileDocumentStore>;
+}
+
+declare class DbxFirebaseStorageFileDocumentStoreDirective extends DbxFirebaseDocumentStoreDirective<StorageFile, StorageFileDocument, StorageFileDocumentStore> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageFileDocumentStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseStorageFileDocumentStoreDirective, "[dbxFirebaseStorageFileDocument]", never, {}, {}, never, never, true, never>;
+}
+
+declare class StorageFileGroupDocumentStore extends AbstractDbxFirebaseDocumentStore<StorageFileGroup, StorageFileGroupDocument> {
+    readonly storageFileFunctions: StorageFileFunctions;
+    constructor();
+    readonly updateStorageFileGroup: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.UpdateStorageFileGroupParams, void>;
+    readonly regenerateStorageFileGroupContent: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreCrudFunction<_dereekb_firebase.RegenerateStorageFileGroupContentParams, _dereekb_firebase.RegenerateStorageFileGroupContentResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageFileGroupDocumentStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageFileGroupDocumentStore>;
+}
+
+declare class DbxFirebaseStorageFileGroupDocumentStoreDirective extends DbxFirebaseDocumentStoreDirective<StorageFileGroup, StorageFileGroupDocument, StorageFileGroupDocumentStore> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageFileGroupDocumentStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseStorageFileGroupDocumentStoreDirective, "[dbxFirebaseStorageFileGroupDocument]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Service that provides access to the app's FirebaseStorageContext.
+ */
+declare class DbxFirebaseStorageService implements FirebaseStorageAccessor {
+    readonly storageContext: FirebaseStorageContext<_dereekb_firebase.FirebaseStorage>;
+    defaultBucket(): string;
+    file(path: StoragePathInput): FirebaseStorageAccessorFile;
+    folder(path: StoragePathInput): FirebaseStorageAccessorFolder;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseStorageService>;
+}
+
+/**
+ * Creates a new observable for uploading a file.
+ */
+type StorageFileUploadHandlerFunction = (file: File) => Promise<StorageFileUploadHandlerInstance>;
+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.
+ */
+interface StorageFileUploadHandler {
+    /**
+     * Uploads a file, and returns the file progress as it is uploading.
+     */
+    readonly uploadFile: StorageFileUploadHandlerFunction;
+}
+/**
+ * Configuration for a single file upload.
+ */
+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.
+ */
+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.
+ */
+type StorageFileUploadConfigFactory = (file: File) => PromiseOrValue<StorageFileUploadConfig>;
+/**
+ * Configuration for StorageFileUploadHandler().
+ */
+interface StorageFileUploadHandlerConfig {
+    readonly storageService: DbxFirebaseStorageService;
+    readonly storageFileUploadConfigFactory: StorageFileUploadConfigFactory;
+}
+/**
+ * Default implementation of StorageFileUploadHandler.
+ */
+declare function storageFileUploadHandler(config: StorageFileUploadHandlerConfig): StorageFileUploadHandler;
+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;
+}
+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>;
+}
+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;
+}
+interface StorageFileUploadFilesFinalResult {
+    readonly startTime: Date;
+    readonly endTime: Date;
+    readonly fileResults: StorageFileUploadFilesFinalFileResult[];
+    readonly successFileResults: StorageFileUploadFilesFinalFileResult[];
+    readonly errorFileResults: StorageFileUploadFilesFinalFileResult[];
+}
+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
+ */
+declare function storageFileUploadFiles(input: StorageFileUploadFilesInput): StorageFileUploadFilesInstance;
+
+/**
+ * Connects a DbxFirebaseStorageFileUploadStore to a DbxActionContext, and handles the upload action.
+ */
+declare class DbxFirebaseStorageFileUploadActionHandlerDirective {
+    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: i0.InputSignal<boolean>;
+    readonly triggerOnFiles$: 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: i0.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: i0.InputSignal<boolean>;
+    readonly uploadHandler: i0.InputSignal<Maybe<StorageFileUploadHandler>>;
+    protected readonly _uploadHandlerEffect: i0.EffectRef;
+    readonly files$: rxjs.Observable<File[]>;
+    readonly uploadHandler$: rxjs.Observable<Maybe<StorageFileUploadHandler>>;
+    constructor();
+    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>;
+}
+
+/**
+ * Error that is thrown when a single file fails to upload.
+ */
+declare class StorageFileUploadFilesError extends BaseError {
+    readonly result: StorageFileUploadFilesFinalResult;
+    constructor(result: StorageFileUploadFilesFinalResult);
+}
+
+/**
+ * Directive that passes the upload result to a StorageFileDocumentStore to initialize the document immediately.
+ *
+ * Use with a DbxAction instance.
+ */
+declare class DbxFirebaseStorageFileUploadInitializeDocumentDirective {
+    readonly uploadStore: DbxFirebaseStorageFileUploadStore;
+    readonly storageFileDocumentStore: StorageFileDocumentStore;
+    readonly initializeWithExpediteProcessing: i0.InputSignal<Maybe<boolean>>;
+    private readonly source;
+    private readonly _dbxActionHandlerInstance;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageFileUploadInitializeDocumentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseStorageFileUploadInitializeDocumentDirective, "[dbxFirebaseStorageFileUploadInitializeDocument]", ["dbxFirebaseStorageFileUploadInitializeDocument"], { "initializeWithExpediteProcessing": { "alias": "initializeWithExpediteProcessing"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that provides a DbxFirebaseStorageFileUploadStore, and sync's the inputs to the store.
+ */
+declare class DbxFirebaseStorageFileUploadStoreDirective {
+    readonly uploadStore: DbxFirebaseStorageFileUploadStore;
+    readonly multipleUpload: i0.InputSignal<Maybe<boolean>>;
+    readonly fileTypesAccepted: i0.InputSignal<Maybe<ArrayOrValue<string>>>;
+    readonly fileTypesAccepted$: rxjs.Observable<Maybe<ArrayOrValue<string>>>;
+    readonly isMultiUploadAllowed$: rxjs.Observable<Maybe<boolean>>;
+    constructor();
+    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>;
+}
+
+/**
+ * Directive that syncs a DbxFirebaseStorageFileUploadStore's configuration to a DbxFileUploadComponent.
+ */
+declare class DbxFirebaseStorageFileUploadSyncDirective {
+    readonly uploadStore: DbxFirebaseStorageFileUploadStore;
+    readonly uploadComponent: DbxFileUploadComponent;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseStorageFileUploadSyncDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseStorageFileUploadSyncDirective, "[dbxFirebaseStorageFileUploadSync]", ["dbxFirebaseStorageFileUploadSync"], {}, {}, never, never, true, never>;
+}
+
+declare const importsAndExports: (typeof DbxActionModule | typeof DbxLoadingComponent | typeof DbxActionSnackbarErrorDirective | typeof DbxFirebaseStorageFileCollectionStoreDirective | typeof DbxFirebaseStorageFileDocumentStoreDirective | typeof DbxFirebaseStorageFileUploadActionHandlerDirective | typeof DbxFirebaseStorageFileUploadInitializeDocumentDirective | typeof DbxFirebaseStorageFileUploadStoreDirective | typeof DbxFirebaseStorageFileUploadSyncDirective | typeof DbxFileUploadComponent | typeof DbxActionLoadingContextDirective | 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
+ */
+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 DbxFirebaseStorageFileUploadActionHandlerDirective, typeof DbxFirebaseStorageFileUploadStoreDirective, typeof DbxFirebaseStorageFileUploadSyncDirective, typeof DbxFirebaseStorageFileUploadInitializeDocumentDirective, typeof DbxFirebaseStorageFileCollectionStoreDirective, typeof DbxFirebaseStorageFileDocumentStoreDirective], [typeof i1.DbxActionModule, typeof i1.DbxLoadingComponent, typeof i1.DbxActionLoadingContextDirective, typeof i1.DbxActionSnackbarErrorDirective, typeof i1.DbxFileUploadComponent, typeof i1.DbxFileUploadActionSyncDirective, typeof DbxFirebaseStorageFileUploadActionHandlerDirective, typeof DbxFirebaseStorageFileUploadStoreDirective, typeof DbxFirebaseStorageFileUploadSyncDirective, typeof DbxFirebaseStorageFileUploadInitializeDocumentDirective, typeof DbxFirebaseStorageFileCollectionStoreDirective, typeof DbxFirebaseStorageFileDocumentStoreDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseStorageFileUploadModule>;
+}
+
+/**
+ * Factory function for creating a StorageAccessor for the model view tracker.
+ */
+declare function defaultDbxFirebaseStorageFileDownloadStorageAccessorFactory(storageAccessorFactory: SimpleStorageAccessorFactory): StorageAccessor<DbxFirebaseStorageFileDownloadUserCache>;
+/**
+ * Creates EnvironmentProviders for providing DbxModelTrackerService, DbxModelObjectStateService and sets up the NgRx store for DbxModelTrackerEffects.
+ *
+ * @returns EnvironmentProviders
+ */
+declare function provideDbxFirebaseStorageFileService(): EnvironmentProviders;
+
+declare class FlatFirestoreModelKeyPipe implements PipeTransform {
+    transform(input: Maybe<FirestoreModelKey>): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlatFirestoreModelKeyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FlatFirestoreModelKeyPipe, "flatFirestoreModelKey", true>;
+}
+
+declare class TwoWayFlatFirestoreModelKeyPipe implements PipeTransform {
+    transform(input: Maybe<FirestoreModelKey>): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TwoWayFlatFirestoreModelKeyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TwoWayFlatFirestoreModelKeyPipe, "twoWayFlatFirestoreModelKey", true>;
+}
+
+declare const DBX_FIREBASE_ID_ROUTER_PARAM_DEFAULT_ID_PARAM_KEY = "id";
+declare const DBX_FIREBASE_ID_ROUTER_PARAM_DEFAULT_KEY_PARAM_KEY = "key";
+declare const DBX_FIREBASE_ID_ROUTER_PARAM_DEFAULT_USE_PARAM_VALUE = "0";
+/**
+ * Used to read an id with a specific key from the current route.
+ *
+ * Can be configured to redirect to a default route if a specific value is seen.
+ */
+interface DbxFirebaseIdRouteParamRedirect extends DbxRouteParamReader<ModelKey> {
+    /**
+     * The id value as it is from the current state's params.
+     */
+    readonly idFromParams$: Observable<Maybe<ModelKey>>;
+    /**
+     * The id value as it is when considering the default value.
+     */
+    readonly id$: Observable<Maybe<ModelKey>>;
+    setRedirectEnabled(redirect: Maybe<boolean>): void;
+    setDecider(decider: string | SwitchMapToDefaultFilterFunction<ModelKey>): void;
+}
+/**
+ * DbxFirebaseIdRouteParamRedirect instance
+ */
+interface DbxFirebaseIdRouteParamRedirectInstance extends DbxFirebaseIdRouteParamRedirect, DbxRouteParamReader<ModelKey>, Initialized, Destroyable {
+    readonly paramValue$: Observable<Maybe<string>>;
+    readonly defaultValue$: Observable<Maybe<string>>;
+    readonly value$: Observable<Maybe<string>>;
+    readonly idFromParams$: Observable<Maybe<ModelKey>>;
+    readonly id$: Observable<Maybe<ModelKey>>;
+    setParamKey(paramKey: string): void;
+    setDefaultValue(defaultValue: MaybeObservableOrValueGetter<string>): void;
+    setRedirectEnabled(redirect: Maybe<boolean>): void;
+    setDecider(decider: string | SwitchMapToDefaultFilterFunction<ModelKey>): void;
+    setParamValue(value: MaybeObservableOrValueGetter<string>): void;
+}
+declare function dbxFirebaseKeyRouteParamRedirect(dbxRouterService: DbxRouterService, defaultParamKey?: string): DbxFirebaseIdRouteParamRedirectInstance;
+declare function dbxFirebaseIdRouteParamRedirect(dbxRouterService: DbxRouterService, defaultParamKey?: string): DbxFirebaseIdRouteParamRedirectInstance;
+
+/**
+ * Token to access the FirebaseStorageContextConfig value.
+ */
+declare const DBX_FIREBASE_STORAGE_CONTEXT_CONFIG_TOKEN: InjectionToken<unknown>;
+/**
+ * Token to access the FirebaseStorageContext value.
+ */
+declare const DBX_FIREBASE_STORAGE_CONTEXT_TOKEN: InjectionToken<unknown>;
+
+type DbxFirebaseStorageContextConfigFactory = (app: FirebaseApp, injector: Injector) => FirebaseStorageContextFactoryConfig;
+/**
+ * The default factory function for the DbxFirebaseStorageContext.
+ *
+ * @param base Optional base configuration to use.
+ * @returns Factory function for the DbxFirebaseStorageContext.
+ */
+declare function dbxFirebaseStorageProvidersContextConfigFactory(base?: FirebaseStorageContextFactoryConfig): DbxFirebaseStorageContextConfigFactory;
+/**
+ * Configuration for provideDbxFirebaseStorage().
+ */
+interface ProvideDbxFirebaseStorageConfig {
+    /**
+     * Optional context config to provide.
+     */
+    readonly contextConfig?: FirebaseStorageContextFactoryConfig;
+    /**
+     * Optional factory function to provide the context config.
+     */
+    readonly contextConfigFactory?: DbxFirebaseStorageContextConfigFactory;
+}
+/**
+ * Creates EnvironmentProviders for the DbxFirebaseStorageService.
+ *
+ * @param config
+ * @returns
+ */
+declare function providedDbxFirebaseStorage(config?: ProvideDbxFirebaseStorageConfig): EnvironmentProviders;
+
+declare class DbxFirebaseModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFirebaseModule, never, never, [typeof DbxFirebaseModelModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseModule>;
+}
+
+/**
+ * Factory for DbxFirebaseModelTypesServiceConfig.
+ */
+type DbxFirebaseModelTypesServiceConfigFactory = (injector: Injector) => DbxFirebaseModelTypesServiceConfig;
+/**
+ * Configuration for provideDbxFirebaseModelTypesService().
+ */
+interface ProvideDbxFirebaseModelTypesServiceConfig {
+    /**
+     * Factory for DbxFirebaseModelTypesServiceConfig.
+     */
+    readonly dbxFirebaseModelTypesServiceConfigFactory: DbxFirebaseModelTypesServiceConfigFactory;
+}
+
+interface ProvideDbxFirebaseConfig<T, M extends FirebaseFunctionsMap = FirebaseFunctionsMap> {
+    readonly app: ProvideDbxFirebaseAppConfig;
+    readonly emulator: ProvideDbxFirebaseEmulatorsConfig;
+    readonly storage: ProvideDbxFirebaseStorageConfig;
+    readonly auth: ProvideDbxFirebaseAuthConfig;
+    readonly functions: ProvideDbxFirebaseFunctionsConfig<T, M>;
+    readonly firestores: ArrayOrValue<ProvideDbxFirebaseFirestoreCollectionConfig<any>>;
+    /**
+     * Configuration for provideDbxFirebaseModelContextService().
+     */
+    readonly modelContextService: ProvideDbxFirebaseModelContextServiceConfig<any>;
+    /**
+     * Configuration for provideDbxFirebaseModelTypesService().
+     */
+    readonly modelTypesService: ProvideDbxFirebaseModelTypesServiceConfig;
+    /**
+     * Configuration for provideDbxFirebaseModelEntitiesWidgetService().
+     */
+    readonly modelEntitiesWidgetService?: Maybe<ProvideDbxFirebaseModelEntitiesWidgetServiceConfig>;
+    /**
+     * Configuration for provideDbxFirebaseDevelopment.
+     *
+     * If false, provideDbxFirebaseDevelopment() will not be provided/called.
+     */
+    readonly development?: ProvideDbxFirebaseDevelopmentConfig | false;
+    /**
+     * Configuration for provideDbxFirebaseNotifications().
+     *
+     * If not provided, provideDbxFirebaseNotifications() will not be provided/called.
+     */
+    readonly notifications?: ProvideDbxFirebaseNotificationsConfig;
+    /**
+     * If true, provideDbxFirebaseAnalyticsUserEventsListenerService() will be provided/called.
+     */
+    readonly provideAnalyticsUserEventsListener?: Maybe<boolean>;
+    /**
+     * If true, provideDbxFirebaseStorageFileService() will be provided/called.
+     */
+    readonly provideStorageFileService?: Maybe<boolean>;
+}
+/**
+ * All-in-one provider for providing the main configurations for DbxFirebase.
+ *
+ * Requires the following already be provided/called:
+ * - provideDbxModelService()
+ *
+ * @param config Configuration for provideDbxFirebase().
+ * @returns EnvironmentProviders for the DbxFirebase configuration.
+ */
+declare function provideDbxFirebase<T, M extends FirebaseFunctionsMap = FirebaseFunctionsMap>(config: ProvideDbxFirebaseConfig<T, M>): EnvironmentProviders;
+
+export { AbstractConfiguredDbxFirebaseLoginButtonDirective, AbstractDbxFirebaseCollectionStore, AbstractDbxFirebaseCollectionWithParentStore, AbstractDbxFirebaseDocumentStore, AbstractDbxFirebaseDocumentWithParentStore, AbstractDbxFirebaseModelEntityWidgetDirective, AbstractDbxFirebaseNotificationItemWidgetComponent, AbstractRootSingleItemDbxFirebaseDocument, AbstractSingleItemDbxFirebaseDocument, AbstractSystemStateDocumentStoreAccessor, DBX_CONFIGURED_DBX_FIREBASE_LOGIN_BUTTON_COMPONENT_CONFIGURATION, DBX_FIREBASE_APP_OPTIONS_TOKEN, DBX_FIREBASE_DOCUMENT_STORE_CONTEXT_STORE_TOKEN, DBX_FIREBASE_ID_ROUTER_PARAM_DEFAULT_ID_PARAM_KEY, DBX_FIREBASE_ID_ROUTER_PARAM_DEFAULT_KEY_PARAM_KEY, DBX_FIREBASE_ID_ROUTER_PARAM_DEFAULT_USE_PARAM_VALUE, DBX_FIREBASE_MODEL_DOES_NOT_EXIST_ERROR, DBX_FIREBASE_MODEL_ENTITY_WITH_STORE_TOKEN, DBX_FIREBASE_STORAGEFILE_DOWNLOAD_STORAGE_ACCESSOR_TOKEN, DBX_FIREBASE_STORAGE_CONTEXT_CONFIG_TOKEN, DBX_FIREBASE_STORAGE_CONTEXT_TOKEN, DBX_FIRESTORE_CONTEXT_TOKEN, DEFAULT_CONFIGURED_DBX_FIREBASE_LOGIN_BUTTON_TEMPLATE, DEFAULT_DBX_FIREBASE_ANALYTICS_USER_PROPERTIES_FACTORY, DEFAULT_DBX_FIREBASE_AUTH_SERVICE_DELEGATE, DEFAULT_DBX_FIREBASE_MODEL_ENTITIES_COMPONENT_POPOVER_KEY, DEFAULT_DBX_FIREBASE_MODEL_HISTORY_COMPONENT_POPOVER_KEY, DEFAULT_DBX_FIREBASE_NOTIFICATION_ITEM_STORE_POPOVER_KEY, DEFAULT_FIREBASE_AUTH_LOGIN_PASSWORD_CONFIG, DEFAULT_FIREBASE_AUTH_LOGIN_PASSWORD_CONFIG_TOKEN, DEFAULT_FIREBASE_AUTH_LOGIN_PROVIDERS_TOKEN, DEFAULT_FIREBASE_AUTH_LOGIN_TERMS_COMPONENT_CLASS_TOKEN, DEFAULT_FIREBASE_COLLECTION_CHANGE_TRIGGER_FUNCTION, DEFAULT_FIREBASE_DEVELOPMENT_ENABLED_TOKEN, DEFAULT_FIREBASE_DEVELOPMENT_POPUP_KEY, DEFAULT_FIREBASE_DEVELOPMENT_SCHEDULER_ENABLED_TOKEN, DEFAULT_FIREBASE_DEVELOPMENT_WIDGET_PROVIDERS_TOKEN, DEFAULT_FIREBASE_LOGIN_METHOD_CATEGORY, DEFAULT_FIREBASE_NOTIFICATION_ITEM_WIDGET_TYPE, DEVELOPMENT_FIREBASE_SERVER_SCHEDULER_WIDGET_KEY, DbxFirebaseAnalyticsUserEventsListenerService, DbxFirebaseAnalyticsUserSource, DbxFirebaseAppCheckHttpInterceptor, DbxFirebaseAuthLoginService, DbxFirebaseAuthService, DbxFirebaseAuthServiceDelegate, DbxFirebaseCollectionChangeDirective, DbxFirebaseCollectionChangeTriggerInstance, DbxFirebaseCollectionHasChangeDirective, DbxFirebaseCollectionListDirective, DbxFirebaseCollectionLoaderInstance, DbxFirebaseCollectionStoreDirective, DbxFirebaseCollectionWithParentStoreDirective, DbxFirebaseDevelopmentDirective, DbxFirebaseDevelopmentModule, DbxFirebaseDevelopmentPopupComponent, DbxFirebaseDevelopmentPopupContentComponent, DbxFirebaseDevelopmentPopupContentFormComponent, DbxFirebaseDevelopmentSchedulerListComponent, DbxFirebaseDevelopmentSchedulerListViewComponent, DbxFirebaseDevelopmentSchedulerListViewItemComponent, DbxFirebaseDevelopmentSchedulerService, DbxFirebaseDevelopmentSchedulerWidgetComponent, DbxFirebaseDevelopmentService, DbxFirebaseDevelopmentWidgetService, DbxFirebaseDocumentLoaderInstance, DbxFirebaseDocumentStoreContextModelEntitiesSourceDirective, DbxFirebaseDocumentStoreContextStore, DbxFirebaseDocumentStoreContextStoreDirective, DbxFirebaseDocumentStoreDirective, DbxFirebaseDocumentStoreIdFromTwoWayModelKeyDirective, DbxFirebaseDocumentStoreTwoWayKeyProvider, DbxFirebaseDocumentStoreTwoWayModelKeySourceDirective, DbxFirebaseEmailFormComponent, DbxFirebaseEmailRecoveryFormComponent, DbxFirebaseEmulatorService, DbxFirebaseLoginAnonymousComponent, DbxFirebaseLoginAppleComponent, DbxFirebaseLoginButtonComponent, DbxFirebaseLoginButtonContainerComponent, DbxFirebaseLoginComponent, DbxFirebaseLoginContext, DbxFirebaseLoginContextBackButtonComponent, DbxFirebaseLoginContextDirective, DbxFirebaseLoginEmailComponent, DbxFirebaseLoginEmailContentComponent, DbxFirebaseLoginFacebookComponent, DbxFirebaseLoginGitHubComponent, DbxFirebaseLoginGoogleComponent, DbxFirebaseLoginListComponent, DbxFirebaseLoginMicrosoftComponent, DbxFirebaseLoginTermsComponent, DbxFirebaseLoginTermsSimpleComponent, DbxFirebaseLoginTwitterComponent, DbxFirebaseModelContextService, DbxFirebaseModelEntitiesComponent, DbxFirebaseModelEntitiesDebugWidgetComponent, DbxFirebaseModelEntitiesPopoverButtonComponent, DbxFirebaseModelEntitiesPopoverComponent, DbxFirebaseModelEntitiesSource, DbxFirebaseModelEntitiesWidgetService, DbxFirebaseModelEntitiesWidgetServiceConfig, DbxFirebaseModelHistoryComponent, DbxFirebaseModelHistoryPopoverButtonComponent, DbxFirebaseModelHistoryPopoverComponent, DbxFirebaseModelKeyComponent, DbxFirebaseModelModule, DbxFirebaseModelStoreModule, DbxFirebaseModelTrackerService, DbxFirebaseModelTypeInstanceListComponent, DbxFirebaseModelTypeInstanceListViewComponent, DbxFirebaseModelTypeInstanceListViewItemComponent, DbxFirebaseModelTypesService, DbxFirebaseModelTypesServiceConfig, DbxFirebaseModelViewedEventDirective, DbxFirebaseModule, DbxFirebaseNotificationBoxCollectionStoreDirective, DbxFirebaseNotificationBoxDocumentStoreDirective, DbxFirebaseNotificationCollectionStoreDirective, DbxFirebaseNotificationDocumentStoreDirective, DbxFirebaseNotificationItemContentComponent, DbxFirebaseNotificationItemDefaultViewComponent, DbxFirebaseNotificationItemListComponent, DbxFirebaseNotificationItemListViewComponent, DbxFirebaseNotificationItemListViewItemComponent, DbxFirebaseNotificationItemStore, DbxFirebaseNotificationItemStorePopoverButtonComponent, DbxFirebaseNotificationItemStorePopoverComponent, DbxFirebaseNotificationItemViewComponent, DbxFirebaseNotificationItemWidgetService, DbxFirebaseNotificationSummaryCollectionStoreDirective, DbxFirebaseNotificationSummaryDocumentStoreDirective, DbxFirebaseNotificationTemplateService, DbxFirebaseNotificationUserCollectionStoreDirective, DbxFirebaseNotificationUserDocumentStoreDirective, DbxFirebaseParsedEmulatorsConfig, DbxFirebaseRegisterComponent, DbxFirebaseRegisterEmailComponent, DbxFirebaseStorageFileCollectionStoreDirective, DbxFirebaseStorageFileDocumentStoreDirective, DbxFirebaseStorageFileDownloadButtonComponent, DbxFirebaseStorageFileDownloadService, DbxFirebaseStorageFileDownloadStorage, DbxFirebaseStorageFileGroupDocumentStoreDirective, DbxFirebaseStorageFileUploadActionHandlerDirective, DbxFirebaseStorageFileUploadInitializeDocumentDirective, DbxFirebaseStorageFileUploadModule, DbxFirebaseStorageFileUploadStore, DbxFirebaseStorageFileUploadStoreDirective, DbxFirebaseStorageFileUploadSyncDirective, DbxFirebaseStorageService, DbxFirebaseSystemStateCollectionStoreDirective, DbxFirebaseSystemStateDocumentStoreDirective, DbxFirestoreContextService, DbxLimitedFirebaseDocumentLoaderInstance, FIREBASE_NOTIFICATION_ITEM_WIDGET_TYPE_PREFIX, FlatFirestoreModelKeyPipe, NotificationBoxCollectionStore, NotificationBoxDocumentStore, NotificationCollectionStore, NotificationDocumentStore, NotificationSummaryCollectionStore, NotificationSummaryDocumentStore, NotificationUserCollectionStore, NotificationUserDocumentStore, OAUTH_FIREBASE_LOGIN_METHOD_CATEGORY, StorageFileCollectionStore, StorageFileDocumentStore, StorageFileGroupDocumentStore, StorageFileUploadFilesError, SystemStateCollectionStore, SystemStateDocumentStore, TwoWayFlatFirestoreModelKeyPipe, authRolesObsWithClaimsService, authUserInfoFromAuthUser, authUserStateFromFirebaseAuthServiceFunction, dbxFirebaseAuthContextInfo, dbxFirebaseCollectionChangeTrigger, dbxFirebaseCollectionChangeTriggerForStore, dbxFirebaseCollectionChangeTriggerForWatcher, dbxFirebaseCollectionChangeWatcher, dbxFirebaseCollectionLoaderInstance, dbxFirebaseCollectionLoaderInstanceWithCollection, dbxFirebaseDocumentLoaderInstance, dbxFirebaseDocumentLoaderInstanceWithAccessor, dbxFirebaseDocumentStoreContextModelEntitiesSourceFactory, dbxFirebaseIdRouteParamRedirect, dbxFirebaseInContextFirebaseModelServiceInstance, dbxFirebaseInContextFirebaseModelServiceInstanceFactory, dbxFirebaseKeyRouteParamRedirect, dbxFirebaseModelContextServiceInfoInstanceFactory, dbxFirebaseModelEntityWidgetInjectionConfigFactory, dbxFirebaseModelTypesServiceInstance, dbxFirebaseModelTypesServiceInstancePairForKeysFactory, dbxFirebaseSourceSelectLoadSource, dbxFirebaseStorageFileDownloadServiceCustomSourceFromObs, dbxFirebaseStorageProvidersContextConfigFactory, dbxLimitedFirebaseDocumentLoaderInstance, dbxLimitedFirebaseDocumentLoaderInstanceWithAccessor, dbxWidgetTypeForNotificationTemplateType, defaultDbxFirebaseAuthServiceDelegateWithClaimsService, defaultDbxFirebaseStorageFileDownloadStorageAccessorFactory, developmentFirebaseServerSchedulerWidgetEntry, enableAppCheckDebugTokenGeneration, firebaseAuthTokenFromUser, firebaseCollectionStoreCreateFunction, firebaseCollectionStoreCrudFunction, firebaseContextServiceEntityMap, firebaseDocumentStoreCreateFunction, firebaseDocumentStoreCrudFunction, firebaseDocumentStoreDeleteFunction, firebaseDocumentStoreReadFunction, firebaseDocumentStoreUpdateFunction, importsAndExports, isDbxFirebaseModelEntityWithStore, linkDocumentStoreToParentContextStores, modelDoesNotExistError, provideDbxFirebase, provideDbxFirebaseAnalyticsUserEventsListenerService, provideDbxFirebaseApp, provideDbxFirebaseAuth, provideDbxFirebaseCollectionStoreDirective, provideDbxFirebaseCollectionWithParentStoreDirective, provideDbxFirebaseDevelopment, provideDbxFirebaseDocumentStoreContextStore, provideDbxFirebaseDocumentStoreDirective, provideDbxFirebaseDocumentStoreTwoWayKeyProvider, provideDbxFirebaseEmulator, provideDbxFirebaseFunctions, provideDbxFirebaseLogin, provideDbxFirebaseModelContextService, provideDbxFirebaseModelEntitiesWidgetService, provideDbxFirebaseNotifications, provideDbxFirebaseStorageFileService, provideDbxFirestoreCollection, provideNotificationFirestoreCollections, provideStorageFileFirestoreCollections, provideSystemStateFirestoreCollections, providedDbxFirebaseStorage, readDbxAnalyticsUserPropertiesFromAuthUserInfo, readValueFromIdToken, setParentStoreEffect, stateFromTokenForLoggedInUserFunction, storageFileUploadFiles, storageFileUploadHandler };
+export type { AuthRolesObsWithClaimsServiceConfig, AuthUserInfo, AuthUserStateObsFunction, DbxFirebaseAnalyticsUserPropertiesFactory, DbxFirebaseAppCheckConfig, DbxFirebaseAppOptions, DbxFirebaseAuthContextInfo, DbxFirebaseAuthLoginPasswordConfig, DbxFirebaseAuthLoginProvider, DbxFirebaseAuthLoginProviderAssets, DbxFirebaseCollectionChangeTrigger, DbxFirebaseCollectionChangeTriggerFunction, DbxFirebaseCollectionChangeTriggerInstanceConfig, DbxFirebaseCollectionChangeWatcher, DbxFirebaseCollectionChangeWatcherEvent, DbxFirebaseCollectionChangeWatcherInstance, DbxFirebaseCollectionChangeWatcherTriggerMode, DbxFirebaseCollectionHasChangeDirectiveMode, DbxFirebaseCollectionLoader, DbxFirebaseCollectionLoaderAccessor, DbxFirebaseCollectionLoaderAccessorWithAccumulator, DbxFirebaseCollectionLoaderInstanceData, DbxFirebaseCollectionLoaderInstanceInitConfig, DbxFirebaseCollectionLoaderWithAccumulator, DbxFirebaseCollectionMode, DbxFirebaseCollectionStore, DbxFirebaseCollectionStoreContextState, DbxFirebaseCollectionStoreCreateFunction, DbxFirebaseCollectionStoreCrudFunction, DbxFirebaseCollectionWithParentStore, DbxFirebaseCollectionWithParentStoreContextState, DbxFirebaseComponentStoreSetParentEffectFunction, DbxFirebaseComponentStoreWithParent, DbxFirebaseComponentStoreWithParentContextState, DbxFirebaseComponentStoreWithParentSetParentEffectFunction, DbxFirebaseComponentStoreWithParentSetParentSourceModeFunction, DbxFirebaseComponentStoreWithParentSetParentStoreEffectFunction, DbxFirebaseComponentStoreWithParentSourceMode, DbxFirebaseDevelopmentPopupContentFormInput, DbxFirebaseDevelopmentPopupContentFormValue, DbxFirebaseDevelopmentWidgetEntry, DbxFirebaseDocumentLoader, DbxFirebaseDocumentLoaderInstanceInitConfig, DbxFirebaseDocumentReadOnlyStore, DbxFirebaseDocumentStore, DbxFirebaseDocumentStoreContextState, DbxFirebaseDocumentStoreContextStoreEntry, DbxFirebaseDocumentStoreContextStoreEntryNumber, DbxFirebaseDocumentStoreContextStoreEntryWithIdentity, DbxFirebaseDocumentStoreContextStoreState, DbxFirebaseDocumentStoreCreateFunction, DbxFirebaseDocumentStoreCrudFunction, DbxFirebaseDocumentStoreFunction, DbxFirebaseDocumentStoreFunctionParams, DbxFirebaseDocumentStoreFunctionParamsInput, DbxFirebaseDocumentWithParentStore, DbxFirebaseDocumentWithParentStoreContextState, DbxFirebaseEmailFormConfig, DbxFirebaseEmailFormValue, DbxFirebaseEmailRecoveryFormValue, DbxFirebaseEmulatorConfig, DbxFirebaseEmulatorsConfig, DbxFirebaseEnvironmentOptions, DbxFirebaseIdRouteParamRedirect, DbxFirebaseIdRouteParamRedirectInstance, DbxFirebaseInContextFirebaseModelInfoServiceInstance, DbxFirebaseInContextFirebaseModelRolesServiceInstance, DbxFirebaseInContextFirebaseModelServiceInstance, DbxFirebaseInContextFirebaseModelServiceInstanceFactory, DbxFirebaseLoginButtonConfig, DbxFirebaseLoginEmailContentComponentConfig, DbxFirebaseLoginEmailContentMode, DbxFirebaseLoginListItemInjectionComponentConfig, DbxFirebaseLoginMode, DbxFirebaseModelContextServiceFactory, DbxFirebaseModelContextServiceInfoInstanceFactory, DbxFirebaseModelContextServiceInfoInstanceFactoryConfig, DbxFirebaseModelDisplayInfo, DbxFirebaseModelEntitiesPopoverButtonConfig, DbxFirebaseModelEntitiesPopoverConfig, DbxFirebaseModelEntitiesPopoverConfigWithoutOrigin, DbxFirebaseModelEntitiesWidgetEntry, DbxFirebaseModelEntitiesWidgetInjectionConfig, DbxFirebaseModelEntitiesWidgetInjectionConfigFactory, DbxFirebaseModelEntitiesWidgetServiceConfigFactory, DbxFirebaseModelEntity, DbxFirebaseModelEntityWithKey, DbxFirebaseModelEntityWithKeyAndStore, DbxFirebaseModelEntityWithStore, DbxFirebaseModelHistoryPopoverButtonConfig, DbxFirebaseModelHistoryPopoverConfig, DbxFirebaseModelHistoryPopoverConfigWithoutOrigin, DbxFirebaseModelTrackerFilterItem, DbxFirebaseModelTrackerHistoryFilter, DbxFirebaseModelTypeInfo, DbxFirebaseModelTypeInstanceListItem, DbxFirebaseModelTypesMap, DbxFirebaseModelTypesServiceEntry, DbxFirebaseModelTypesServiceInstance, DbxFirebaseModelTypesServiceInstancePair, DbxFirebaseModelTypesServiceInstancePairForKeysFactory, DbxFirebaseNotificationItemStorePopoverButtonConfig, DbxFirebaseNotificationItemStorePopoverParams, DbxFirebaseNotificationItemStoreState, DbxFirebaseNotificationItemWidgetEntry, DbxFirebaseNotificationItemWidgetEntryRegistration, DbxFirebaseSourceSelectLoadSourceConfig, DbxFirebaseStorageContextConfigFactory, DbxFirebaseStorageFileDownloadButtonConfig, DbxFirebaseStorageFileDownloadButtonSource, DbxFirebaseStorageFileDownloadDetails, DbxFirebaseStorageFileDownloadServiceCustomSource, DbxFirebaseStorageFileDownloadServiceCustomSourceDownloadFunction, DbxFirebaseStorageFileDownloadUrlPair, DbxFirebaseStorageFileDownloadUrlPairString, DbxFirebaseStorageFileDownloadUrlPairsRecord, DbxFirebaseStorageFileDownloadUserCache, DbxFirebaseStorageFileUploadStoreAllowedTypes, DbxFirebaseStorageFileUploadStoreFileProgress, DbxFirebaseStorageFileUploadStoreState, DbxFirebaseStorageFileUploadStoreUploadStage, DbxLimitedFirebaseDocumentLoader, DefaultDbxFirebaseAuthServiceDelegateWithClaimsServiceConfig, FirebaseLoginMethodCategory, FirebaseLoginMethodType, KnownFirebaseLoginMethodCategory, KnownFirebaseLoginMethodType, NotificationItemWithSelection, ProvideDbxFirebaseAppConfig, ProvideDbxFirebaseAuthConfig, ProvideDbxFirebaseConfig, ProvideDbxFirebaseDevelopmentConfig, ProvideDbxFirebaseEmulatorsConfig, ProvideDbxFirebaseFirestoreCollectionConfig, ProvideDbxFirebaseFunctionsConfig, ProvideDbxFirebaseLoginConfig, ProvideDbxFirebaseModelContextServiceConfig, ProvideDbxFirebaseModelEntitiesWidgetServiceConfig, ProvideDbxFirebaseNotificationsConfig, ProvideDbxFirebaseStorageConfig, ScheduledFunctionDevelopmentFirebaseFunctionListEntryWithSelection, StateFromTokenFunction, StorageFileUploadConfig, StorageFileUploadConfigFactory, StorageFileUploadConfigOptions, StorageFileUploadFilesEvent, StorageFileUploadFilesFinalFileResult, StorageFileUploadFilesFinalResult, StorageFileUploadFilesInput, StorageFileUploadFilesInstance, StorageFileUploadHandler, StorageFileUploadHandlerConfig, StorageFileUploadHandlerFunction, StorageFileUploadHandlerInstance };