@dereekb/dbx-firebase 13.31.0 → 13.33.0

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

@@ -1,13 +1,13 @@
 import { AnalyticsUserProperties, DbxAnalyticsUserSource, AnalyticsUser, DbxAnalyticsService } from '@dereekb/dbx-analytics';
 import * as _dereekb_util from '@dereekb/util';
-import { Maybe, ISO8601DateString, AuthRoleSet, AuthRoleClaimsService, AuthClaimsObject, PasswordString, AuthClaims, FactoryWithRequiredInput, Initialized, Destroyable, ArrayOrValue, LabelRef, ClassLikeType, PageNumber, GetterOrValue, IterableOrValue, SetIncludesMode, ModelKey, ClassType, MapFunction, PartialOnKeys, UnixDateTimeSecondsNumber, ContentTypeMimeType, Milliseconds, Seconds, DateOrUnixDateTimeSecondsNumber, PromiseOrValue, PercentDecimal, PercentNumber } from '@dereekb/util';
+import { Maybe, ISO8601DateString, AuthRoleSet, AuthRoleClaimsService, AuthClaimsObject, PasswordString, AuthClaims, FactoryWithRequiredInput, Initialized, Destroyable, ArrayOrValue, LabelRef, ClassLikeType, PageNumber, GetterOrValue, IterableOrValue, SetIncludesMode, ModelKey, ClassType, MapFunction, PartialOnKeys, PromiseOrValue, Seconds, Minutes, UnixDateTimeSecondsNumber, ContentTypeMimeType, Milliseconds, DateOrUnixDateTimeSecondsNumber, PercentDecimal, PercentNumber } from '@dereekb/util';
 import * as _firebase_auth from '@firebase/auth';
 import { DbxAuthService, AuthUserState, AuthUserIdentifier, DbxAuthImpersonationDetails, NoAuthUserIdentifier, DbxInjectionContext, ClickableAnchor, AbstractForwardDbxInjectionContextDirective, DbxActionSuccessHandlerFunction, DbxInjectionComponentConfig, DbxAuthImpersonationDelegate, ProvideDbxAuthImpersonationConfig, ClickableUrl, IconAndTitle, SegueRef, ClickableAnchorLinkSegueRef, LockSetComponent, DbxButtonDisplay, DbxRouteModelIdDirectiveDelegate, DbxRouteModelKeyDirectiveDelegate, LockSetComponentStore, AbstractIfDirective, StorageAccessor, DbxActionContextStoreSourceInstance, DbxActionHandlerInstance, DbxButton, SimpleStorageAccessorFactory, DbxRouteParamReader, DbxRouterService } from '@dereekb/dbx-core';
 import { UserInfo, User, IdTokenResult, ParsedToken, AuthProvider, PopupRedirectResolver, UserCredential, AuthCredential, Auth } from 'firebase/auth';
 import * as rxjs from 'rxjs';
 import { Observable, BehaviorSubject, Subject, OperatorFunction, Subscription } from 'rxjs';
 import * as _dereekb_firebase from '@dereekb/firebase';
-import { FirebaseAuthToken, FirebaseAuthOobCode, FirebaseAuthIdToken, FirebaseAuthContextInfo, FirebaseDevelopmentFunctions, ScheduledFunctionDevelopmentFirebaseFunctionListEntry, FirestoreContext, FirestoreContextCacheFactory, 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, ModelFirebaseInvokeFunction, 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 { FirebaseAuthToken, FirebaseAuthOobCode, FirebaseAuthIdToken, FirebaseAuthContextInfo, FirebaseDevelopmentFunctions, ScheduledFunctionDevelopmentFirebaseFunctionListEntry, FirestoreContext, FirestoreContextCacheFactory, 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, ModelFirebaseInvokeFunction, ModelFirebaseReadFunction, ModelFirebaseUpdateFunction, FirestoreCollectionWithParentFactory, FirestoreCollectionGroup, SystemState, SystemStateDocument, SystemStateStoredData, SystemStateTypeIdentifier, UserExternalConnectionProviderType, UserExternalConnectionEntry, KnownUserExternalConnectionProviderType, UserExternalConnectionEntryMap, UserExternalConnection, UserExternalConnectionDocument, UserExternalConnectionFunctions, UserExternalConnectionFirestoreCollections, UserExternalConnectionFirestoreCollection, NotificationDeliveryHealthCheckResult, NotificationHealthCheck, NotificationDeliveryMethod, NotificationDeliveryMethodMap, NotificationHealthCheckIssue, AppNotificationTemplateTypeInfoRecordService, NotificationItemMetadata, NotificationItem, NotificationItemSubjectMessagePair, NotificationUser, NotificationUserDocument, NotificationFunctions, NotificationUserHealthCheckResult, NotificationUserHealthCheckParams, NotificationId, Notification, NotificationBox, NotificationDocument, NotificationBoxDocument, NotificationSummary, NotificationSummaryDocument, UnreadNotificationItemsResult, NotificationHealthCheckIssueCode, NotificationHealthCheckStatus, 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 * as i0 from '@angular/core';
 import { InjectionToken, EnvironmentProviders, Type, OnInit, Component, EventEmitter, Injector, AfterViewInit, ElementRef, Signal, Provider, PipeTransform } from '@angular/core';
 import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
@@ -18,7 +18,7 @@ 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 * as i1 from '@dereekb/dbx-web';
-import { DbxColorInput, DbxActionConfirmConfig, 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, DbxImageCompressionConfig, ImageBitmapToBlobEncoder, CompressImageFileResult, DbxFileUploadComponent, DbxPdfMergeEditorStore, DbxActionModule, DbxLoadingComponent, DbxActionSnackbarErrorDirective, DbxActionLoadingContextDirective, DbxFileUploadActionSyncDirective } from '@dereekb/dbx-web';
+import { DbxColorInput, DbxActionConfirmConfig, 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, AbstractDbxListWrapperDirective, AbstractDbxListViewDirective, DbxValueListViewConfig, DbxThemeColor, DbxWidgetViewComponentConfig, AbstractDbxWidgetComponent, AbstractDialogDirective, DbxWebFilePreviewService, DbxActionDialogFunction, FileAcceptFilterTypeString, DbxImageCompressionConfig, ImageBitmapToBlobEncoder, CompressImageFileResult, DbxFileUploadComponent, DbxPdfMergeEditorStore, DbxActionModule, DbxLoadingComponent, DbxActionSnackbarErrorDirective, DbxActionLoadingContextDirective, DbxFileUploadActionSyncDirective } from '@dereekb/dbx-web';
 import { FormConfig } from '@ng-forge/dynamic-forms';
 import { MatSnackBar } from '@angular/material/snack-bar';
 import { NgPopoverRef } from 'ng-overlay-container';
@@ -252,14 +252,41 @@ declare class DbxFirebaseAuthService implements DbxAuthService {
      * Alias for uid$
      */
     readonly userIdentifier$: Observable<AuthUserIdentifier | NoAuthUserIdentifier>;
+    /**
+     * The current ID token string, or null while logged out.
+     *
+     * Scoped per-uid via {@link sharedObservableForUidFunction} so the replay buffer can never hand a subscriber
+     * the PREVIOUS user's token after a same-page re-login.
+     */
     readonly currentIdTokenString$: Observable<Maybe<FirebaseAuthIdToken>>;
     readonly idTokenString$: Observable<FirebaseAuthIdToken>;
+    /**
+     * The current user's decoded ID token, or null while logged out.
+     *
+     * Scoped per-uid via {@link sharedObservableForUidFunction}. Token refreshes still flow through, as they arrive
+     * on {@link currentIdTokenString$}; only a uid change rebuilds the stream.
+     */
     readonly currentIdTokenResult$: Observable<Maybe<IdTokenResult>>;
     readonly idTokenResult$: Observable<IdTokenResult>;
+    /**
+     * The current user's token claims, or null while logged out.
+     *
+     * Intentionally not replayed: {@link currentIdTokenResult$} is already shared per-uid, and a buffer here would
+     * reintroduce the cross-user staleness that scoping removes.
+     */
     readonly currentClaims$: Observable<Maybe<ParsedToken>>;
     readonly claims$: Observable<ParsedToken>;
     readonly currentAuthContextInfo$: Observable<Maybe<DbxFirebaseAuthContextInfo>>;
     readonly authContextInfo$: Observable<Maybe<DbxFirebaseAuthContextInfo>>;
+    /**
+     * The current {@link AuthUserState}.
+     *
+     * The delegate's state stream is scoped per-uid via {@link sharedObservableForUidFunction}, so it is rebuilt
+     * whenever the signed-in uid changes. Without that, a subscriber attaching right after a same-page re-login is
+     * served the prior session's state synchronously from the replay buffer — and every consumer that reads the
+     * first emission, including the UIRouter auth transition hooks, then routes on it. The delegate factory is
+     * re-invoked per uid so the delegate's own internal replay is discarded along with it.
+     */
     readonly authUserState$: Observable<AuthUserState>;
     readonly authRoles$: Observable<AuthRoleSet>;
     readonly isOnboarded$: Observable<boolean>;
@@ -4352,236 +4379,1466 @@ declare class DbxFirebaseModelModule {
 }
 
 /**
- * Client-side service used for retrieving notification templates.
+ * Assets used to render a third-party connection row.
+ *
+ * Mapped from `DbxFirebaseAuthLoginProviderAssets`, with two deliberate differences:
+ * - `providerName` is REQUIRED. An unnamed connection row is not renderable, which is what forces
+ *   the login registry into its `'<linkText not configured>'` placeholders.
+ * - The full-bleed brand color fields are dropped. A brand-colored button is a sign-in affordance;
+ *   a settings row uses a normal themed button and carries the brand in its logo tile.
  */
-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>;
+interface DbxFirebaseExternalConnectionProviderAssets {
+    /**
+     * Display name of the provider (e.g. "Cal.com", "Zoom").
+     */
+    readonly providerName: string;
+    /**
+     * URL of the logo to use.
+     */
+    readonly logoUrl?: Maybe<string>;
+    /**
+     * Material icon to use in place of the logo.
+     */
+    readonly icon?: Maybe<string>;
+    /**
+     * Short description of what connecting this provider enables.
+     */
+    readonly description?: Maybe<string>;
+    /**
+     * Text for the connect action. Defaults to "Connect".
+     */
+    readonly connectText?: Maybe<string>;
+    /**
+     * Text for the disconnect action. Defaults to "Disconnect".
+     */
+    readonly disconnectText?: Maybe<string>;
+    /**
+     * Optional CSS filter to apply to the logo image (e.g. 'brightness(0) invert(1)').
+     */
+    readonly logoFilter?: Maybe<string>;
 }
-
 /**
- * A notification item wrapped with list selection state.
+ * Navigates the browser to the given url. Exists as a seam so tests (and apps that route through
+ * their own navigation service) never need to touch `window.location`.
+ *
+ * Returns a promise that settles on the outcome of the navigation, NOT on the request to navigate
+ * having been made: it resolves once the new page is actually opening, and rejects when it never
+ * does. Callers must await it — that is what keeps the connect action working until the authorize
+ * page is really on its way, instead of reporting success against a page that has not moved.
  */
-type NotificationItemWithSelection = DbxValueAsListItem<NotificationItem>;
+type DbxFirebaseExternalConnectionNavigateFunction = (url: string) => PromiseOrValue<void>;
 /**
- * Selection list wrapper for notification items with view-only default selection mode.
+ * The opaque, short-lived `state` a provider's OAuth handoff carries.
+ *
+ * It is what tells the server who is connecting, since the top-level navigation to the provider
+ * carries no Firebase ID token of its own.
  */
-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>;
-}
+type DbxFirebaseExternalConnectionAuthorizeState = string;
 /**
- * List view component that renders notification items using the selection list pattern.
+ * Mints a fresh {@link DbxFirebaseExternalConnectionAuthorizeState} for a provider.
  */
-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>;
-}
+type DbxFirebaseExternalConnectionMintAuthorizeStateFunction = () => Promise<DbxFirebaseExternalConnectionAuthorizeState>;
 /**
- * Individual list view item component rendering a notification's subject, message, and date.
+ * Context handed to a provider's custom {@link DbxFirebaseExternalConnectionConnectFunction}.
  */
-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>;
+interface DbxFirebaseExternalConnectionConnectContext {
+    readonly providerType: UserExternalConnectionProviderType;
+    readonly provider: DbxFirebaseExternalConnectionProvider;
+    /**
+     * The authorize url the default behavior would have navigated to, when one could be resolved.
+     *
+     * WITHOUT the `state` query parameter — the default behavior appends that itself, from
+     * {@link mintAuthorizeState}, so a custom handler that skips the mint never pays for one.
+     */
+    readonly authorizeUrl: Maybe<string>;
+    /**
+     * Mints the state the authorize request must carry, via an authenticated call.
+     *
+     * Only needed by a handler that builds its own authorize request; the default behavior does this on
+     * its own. Available regardless of the config's `mintAuthorizeState`, since a handler that asks for
+     * a state wants one; it throws only when the app never wired the userExternalConnection callables.
+     */
+    readonly mintAuthorizeState: DbxFirebaseExternalConnectionMintAuthorizeStateFunction;
+    /**
+     * Navigates the browser. Use this rather than `window.location` directly, and AWAIT it: it settles
+     * on the new page actually opening, which is what holds the connect action in its working state
+     * until then.
+     */
+    readonly navigate: DbxFirebaseExternalConnectionNavigateFunction;
 }
-
 /**
- * Presentational component for notification item content, displaying subject, message, and date.
+ * Starts the connect flow for a provider.
+ *
+ * The library default already mints the signed `state` and redirects to the authorize url carrying
+ * it, which is the whole of what an authorization-code handoff needs. An app supplies this only when
+ * the flow itself differs — opening a popup instead of navigating, say. Whatever it does, do NOT
+ * append the Firebase ID token to the redirect: the state is what identifies the caller.
+ *
+ * The returned promise must not resolve before the authorize page is opening, so await the context's
+ * `navigate` rather than calling it and returning.
  */
-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>;
-}
-
+type DbxFirebaseExternalConnectionConnectFunction = (context: DbxFirebaseExternalConnectionConnectContext) => Promise<void> | void;
 /**
- * Renders a notification item using the widget system, resolving the appropriate
- * display component based on the notification's template type.
+ * Registration for one third-party service a user can connect their account to.
+ *
+ * Mapped from `DbxFirebaseAuthLoginProvider`: `loginMethodType` becomes `providerType` and `assets`
+ * carries over. `componentClass` / `registrationComponentClass` / `category` / `allowLinking` /
+ * `componentData` are dropped — login needs a component per provider because each calls a different
+ * Firebase SDK class, whereas here the only per-provider variation is a URL, which is data.
  */
-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>;
+interface DbxFirebaseExternalConnectionProvider {
+    /**
+     * Provider type key. MUST match the string the server writes into the connection entry map.
+     */
+    readonly providerType: UserExternalConnectionProviderType;
+    /**
+     * Assets for rendering this provider's row.
+     */
+    readonly assets: DbxFirebaseExternalConnectionProviderAssets;
+    /**
+     * Path appended to the configured authorize origin to start this provider's OAuth flow.
+     *
+     * Defaults to the config's `authorizePathFactory` result.
+     */
+    readonly authorizePath?: Maybe<string>;
+    /**
+     * Overrides the default redirect-based connect behavior.
+     */
+    readonly connect?: Maybe<DbxFirebaseExternalConnectionConnectFunction>;
+    /**
+     * Confirmation shown before disconnecting.
+     */
+    readonly disconnectConfirm?: Maybe<DbxActionConfirmConfig>;
 }
-
 /**
- * Abstract base directive for notification item widget display components.
+ * One provider an app offers, as declared in its configuration.
  *
- * Provides typed access to the {@link NotificationItem} data for custom rendering.
+ * A KNOWN provider type is the whole entry: the library already carries its presentation, so flagging
+ * a service on is naming it. Every app that connects to Discord shows the same Discord row, and the
+ * asset copy is not what varies between downstream apps — the server's OAuth controller is.
+ *
+ * Pass a full provider to register a service the library has no defaults for, or
+ * {@link dbxFirebaseKnownExternalConnectionProvider} to start from a known one and patch it.
  */
-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>;
-}
-
+type DbxFirebaseExternalConnectionProviderEntry = KnownUserExternalConnectionProviderType | DbxFirebaseExternalConnectionProvider;
 /**
- * Default notification item view component that renders subject, message, and creation date.
+ * Configuration for the external connection registry.
+ *
+ * Declared as an abstract class so it is its own injection token (the newer style, as
+ * `DbxFirebaseOidcConfig`). Unlike login there is no library-supplied default catalog for an
+ * `InjectionToken`-with-`useFactory` shape to override, and the registry needs more than a list.
  */
-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 {
+declare abstract class DbxFirebaseExternalConnectionsConfig {
     /**
-     * Custom icon
-     *
-     * Defaults to "history"
+     * The providers the app registers, as known provider types and/or fully-declared providers.
      */
-    readonly icon?: string;
+    abstract readonly providers: DbxFirebaseExternalConnectionProviderEntry[];
     /**
-     * Custom header text
-     *
-     * Defaults to "History"
+     * Which providers are enabled. Pass `true` (the default) to enable every registered provider.
      */
-    readonly header?: string;
+    readonly enabledProviders?: Maybe<UserExternalConnectionProviderType[] | true>;
     /**
-     * Custom empty text when no items exist.
+     * Whether the connect flow mints a signed `state` and carries it on the authorize request.
+     * Defaults to true.
+     *
+     * This is what identifies the connecting user to the server, since a top-level navigation carries
+     * no Firebase ID token: the app's own authorize endpoint bounces a stateless request straight to
+     * the failure url. Turn it off only for an endpoint that mints its own state, and note that doing
+     * so means no authenticated call is made before the redirect.
      */
-    readonly emptyText?: string;
+    readonly mintAuthorizeState?: Maybe<boolean>;
     /**
-     * Origin to add the popover to.
+     * Origin the authorize paths are resolved against (e.g. the hosting origin that fronts the API).
+     *
+     * When undefined the authorize path is used as-is, which is the correct behavior when the app and
+     * the OAuth controller share an origin.
      */
-    readonly origin: ElementRef;
+    readonly authorizeOrigin?: Maybe<string>;
     /**
-     * Items loading state.
+     * Builds the default authorize path for a provider that does not declare its own.
+     *
+     * Defaults to {@link DEFAULT_EXTERNAL_CONNECTION_AUTHORIZE_PATH_FACTORY}.
      */
-    readonly notificationItemsLoadingState$: Observable<LoadingState<NotificationItem[]>>;
+    readonly authorizePathFactory?: Maybe<(providerType: UserExternalConnectionProviderType) => string>;
     /**
-     * Anchor
+     * Navigation seam used by the default connect behavior.
+     *
+     * Defaults to {@link DEFAULT_EXTERNAL_CONNECTION_NAVIGATE_FUNCTION}. An override owns the same
+     * contract: settle only once the new page is actually opening.
      */
-    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>;
+    readonly navigate?: Maybe<DbxFirebaseExternalConnectionNavigateFunction>;
 }
-
-interface DbxFirebaseNotificationItemStoreState {
+/**
+ * Default authorize path for a provider: `/oauth/<providerType>/authorize`.
+ *
+ * @param providerType - The provider to build a path for.
+ * @returns The authorize path.
+ */
+declare const DEFAULT_EXTERNAL_CONNECTION_AUTHORIZE_PATH_FACTORY: (providerType: UserExternalConnectionProviderType) => string;
+/**
+ * Presentation status of a connection row.
+ */
+type DbxFirebaseExternalConnectionRowStatus = 'loading' | 'connected' | 'notConnected' | 'error';
+/**
+ * One provider's row, as rendered on the settings page.
+ */
+interface DbxFirebaseExternalConnectionRow {
+    readonly providerType: UserExternalConnectionProviderType;
+    readonly assets: DbxFirebaseExternalConnectionProviderAssets;
     /**
-     * The NotificationSummary to pull items from
+     * The user's entry for this provider, when there is one.
      */
-    readonly items: NotificationItem[];
+    readonly entry?: Maybe<UserExternalConnectionEntry>;
+    readonly status: DbxFirebaseExternalConnectionRowStatus;
     /**
-     * The currently selected id
+     * Whether this provider is currently enabled. A disabled provider the user is still connected to
+     * is retained as a row so it can be disconnected.
      */
-    readonly selectedId: Maybe<NotificationId>;
+    readonly enabled: boolean;
 }
 /**
- * Store used for selecting a specific NotificationItem from a list of notification items.
+ * An action rendered on a connection row.
+ *
+ * Rows take an ARRAY of these because the `error` status wants both Reconnect and Disconnect.
  */
-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>;
+interface DbxFirebaseExternalConnectionActionConfig {
+    readonly label: string;
+    readonly icon?: Maybe<string>;
+    readonly confirm?: Maybe<DbxActionConfirmConfig>;
+    readonly handler: WorkUsingContext;
 }
-
 /**
- * Document store for a single Notification, providing derived observables for creation date, send state, and update functions.
+ * One rendered list item: a row plus the actions currently available for it.
+ *
+ * The actions are paired with the row here rather than derived by the item component because building them needs
+ * the connect/disconnect handlers, which belong to the container that owns the stores.
  */
-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>;
+interface DbxFirebaseExternalConnectionListItemValue {
+    readonly row: DbxFirebaseExternalConnectionRow;
+    readonly actions?: Maybe<DbxFirebaseExternalConnectionActionConfig[]>;
 }
-
 /**
- * Directive providing a {@link NotificationDocumentStore} for accessing a single notification document.
+ * Derives a row's presentation status from its entry.
+ *
+ * @param entry - The user's entry for the provider, if any.
+ * @returns The row status.
  */
-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 function dbxFirebaseExternalConnectionRowStatusForEntry(entry: Maybe<UserExternalConnectionEntry>): DbxFirebaseExternalConnectionRowStatus;
 /**
- * Collection store for Notification documents, scoped to a parent NotificationBox when available.
+ * Input for {@link dbxFirebaseExternalConnectionRows}.
  */
-declare class NotificationCollectionStore extends AbstractDbxFirebaseCollectionWithParentStore<Notification, NotificationBox, NotificationDocument, NotificationBoxDocument> {
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationCollectionStore, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationCollectionStore>;
+interface DbxFirebaseExternalConnectionRowsInput {
+    /**
+     * Every registered provider, in registration order.
+     */
+    readonly providers: DbxFirebaseExternalConnectionProvider[];
+    /**
+     * The provider types that are currently enabled.
+     */
+    readonly enabledProviderTypes: UserExternalConnectionProviderType[];
+    /**
+     * The user's per-provider entries, or null while still loading.
+     */
+    readonly entries: Maybe<UserExternalConnectionEntryMap>;
+    /**
+     * Whether the connection document is still loading.
+     */
+    readonly loading?: Maybe<boolean>;
 }
-
 /**
- * Directive providing a {@link NotificationCollectionStore} for querying notifications within a template.
+ * Builds the rows to render.
+ *
+ * The row set is the union of the enabled providers and any registered provider the user still has
+ * an entry for, so a provider that has since been disabled can still be disconnected.
+ *
+ * @param input - The registry state plus the user's entries.
+ * @returns The rows, in registration order.
  */
-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 function dbxFirebaseExternalConnectionRows(input: DbxFirebaseExternalConnectionRowsInput): DbxFirebaseExternalConnectionRow[];
 
 /**
- * Document store for a single NotificationBox, providing derived observables for creation date, recipients, and update functions.
+ * Default presentation for Cal.com.
+ *
+ * `icon` is a Material Symbols name throughout these defaults: the brand logo set the login registry
+ * pulls from covers Firebase's own auth providers only, so a real mark for any of these services
+ * would need a new asset. An app that has one passes `assets.logoUrl` instead.
  */
-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.TargetModelParams, void>;
-    readonly updateNotificationBoxRecipient: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.UpdateNotificationBoxRecipientParams, void>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationBoxDocumentStore, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationBoxDocumentStore>;
-}
-
+declare const DBX_FIREBASE_EXTERNAL_CONNECTION_CALCOM_PROVIDER: DbxFirebaseExternalConnectionProvider;
 /**
- * Directive providing a {@link NotificationBoxDocumentStore} for accessing a single notification box document.
+ * Default presentation for Zoom.
  */
-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 const DBX_FIREBASE_EXTERNAL_CONNECTION_ZOOM_PROVIDER: DbxFirebaseExternalConnectionProvider;
+/**
+ * Default presentation for Discord.
+ */
+declare const DBX_FIREBASE_EXTERNAL_CONNECTION_DISCORD_PROVIDER: DbxFirebaseExternalConnectionProvider;
+/**
+ * Default presentation for Zoho.
+ */
+declare const DBX_FIREBASE_EXTERNAL_CONNECTION_ZOHO_PROVIDER: DbxFirebaseExternalConnectionProvider;
+/**
+ * The library's provider for each known third-party service, keyed by provider type.
+ *
+ * Every service the workspace ships a server-side OAuth adapter for appears here, so an app that
+ * mounts one of those controllers has nothing to declare on the client beyond naming it.
+ */
+declare const DBX_FIREBASE_KNOWN_EXTERNAL_CONNECTION_PROVIDERS: Record<KnownUserExternalConnectionProviderType, DbxFirebaseExternalConnectionProvider>;
+/**
+ * Config for {@link dbxFirebaseKnownExternalConnectionProvider}.
+ */
+interface DbxFirebaseKnownExternalConnectionProviderConfig {
+    /**
+     * The known provider to start from.
+     */
+    readonly providerType: KnownUserExternalConnectionProviderType;
+    /**
+     * Asset values to merge over the known provider's, so an app can reword one line without
+     * restating the rest.
+     */
+    readonly assets?: Maybe<Partial<DbxFirebaseExternalConnectionProviderAssets>>;
+    /**
+     * Overrides the known provider's authorize path.
+     */
+    readonly authorizePath?: Maybe<string>;
+    /**
+     * Overrides the default redirect-based connect behavior.
+     */
+    readonly connect?: Maybe<DbxFirebaseExternalConnectionConnectFunction>;
+    /**
+     * Confirmation shown before disconnecting.
+     */
+    readonly disconnectConfirm?: Maybe<DbxActionConfirmConfig>;
+}
+/**
+ * Builds a provider from a known one, with the given overrides applied.
+ *
+ * @param config - The known provider to start from, plus the values to override.
+ * @returns The provider to register.
+ * @throws {Error} When there is no known provider for the given type.
+ */
+declare function dbxFirebaseKnownExternalConnectionProvider(config: DbxFirebaseKnownExternalConnectionProviderConfig): DbxFirebaseExternalConnectionProvider;
+/**
+ * Resolves a configured entry to the provider to register.
+ *
+ * @param entry - A known provider type, or a fully-declared provider.
+ * @returns The provider to register.
+ * @throws {Error} When the entry names a provider type the library has no defaults for.
+ */
+declare function dbxFirebaseExternalConnectionProviderForEntry(entry: DbxFirebaseExternalConnectionProviderEntry): DbxFirebaseExternalConnectionProvider;
+
+/**
+ * How long {@link DEFAULT_EXTERNAL_CONNECTION_NAVIGATE_FUNCTION} waits for the browser to leave the
+ * page before treating the redirect as having failed.
+ *
+ * Generous, because the wait spans the request to the app's own authorize endpoint plus the redirect
+ * chain out to the provider, and a cold serverless function alone can take several seconds.
+ */
+declare const DEFAULT_EXTERNAL_CONNECTION_NAVIGATE_TIMEOUT: number;
+/**
+ * Starts a top-level navigation and resolves only once the browser has committed to leaving the
+ * current page, rejecting when it has not done so within the timeout.
+ *
+ * `pagehide` is the signal: it fires as the browser is about to unload this document for the new one,
+ * which is the earliest point the navigation is known to have actually taken. Anything earlier — an
+ * assignment to `location.href` returning, say — only says the navigation was *requested*.
+ *
+ * The navigation is invoked here rather than by the caller so the listener is always in place before
+ * the page can go, and so a refused navigation settles immediately instead of waiting out the timeout.
+ *
+ * @param navigate - Starts the navigation.
+ * @param timeout - How long to wait before rejecting. Defaults to {@link DEFAULT_EXTERNAL_CONNECTION_NAVIGATE_TIMEOUT}.
+ * @returns Resolves when the page is being unloaded for the navigation.
+ */
+declare function navigateAndWaitForPageToLeave(navigate: () => void, timeout?: number): Promise<void>;
+/**
+ * Default navigation: a top-level browser redirect that settles only once the new page is opening.
+ *
+ * Assigning `location.href` returns immediately — before the request for the new document has even
+ * been answered — so a caller that treated the assignment as the end of the work reported success
+ * while the old page was still sitting there. Waiting for the unload instead means the connect action
+ * stays in its working state for as long as the user is still looking at the settings page, and a
+ * redirect the browser refuses outright surfaces as an error rather than a silent success.
+ *
+ * @param url - The url to navigate to.
+ * @returns Resolves once the browser is leaving the page for the new url.
+ */
+declare const DEFAULT_EXTERNAL_CONNECTION_NAVIGATE_FUNCTION: (url: string) => Promise<void>;
+/**
+ * Registry of the third-party services a user can connect their account to.
+ *
+ * Modeled on `DbxFirebaseAuthLoginService`, but WITHOUT any per-user state: it is root-scoped, so a
+ * Firestore listener held here would live for the app's lifetime and lock the UI to one user. The
+ * connection state is resolved by the container component instead, from a single document read that
+ * is fanned out to every row.
+ */
+declare class DbxFirebaseExternalConnectionService {
+    readonly config: DbxFirebaseExternalConnectionsConfig;
+    /**
+     * Optional so the registry is usable — and testable — in an app that has not wired the
+     * userExternalConnection callables. Only state minting needs them, and it says so when they are
+     * missing rather than failing every injection of this service.
+     */
+    private readonly _userExternalConnectionFunctions;
+    private readonly _providers;
+    private readonly _assets;
+    private _enableAll;
+    private _enabled;
+    constructor();
+    /**
+     * Registers a provider.
+     *
+     * @param provider - The provider to register.
+     * @param override - Whether to override an existing provider of the same type. Defaults to true.
+     * @returns True if the provider was registered.
+     */
+    register(provider: DbxFirebaseExternalConnectionProvider, override?: boolean): boolean;
+    /**
+     * Patches the assets for a provider type.
+     *
+     * @param providerType - The provider to update.
+     * @param assets - The asset values to merge in.
+     */
+    updateAssetsForProvider(providerType: UserExternalConnectionProviderType, assets: Partial<DbxFirebaseExternalConnectionProviderAssets>): void;
+    /**
+     * Enables all providers, including any registered later.
+     *
+     * @param enableAll - Whether to enable all providers. Defaults to true.
+     */
+    setEnableAll(enableAll?: boolean): void;
+    clearEnabled(): void;
+    enable(types: ArrayOrValue<UserExternalConnectionProviderType>): void;
+    disable(types: ArrayOrValue<UserExternalConnectionProviderType>): void;
+    getRegisteredTypes(): UserExternalConnectionProviderType[];
+    getEnabledTypes(): UserExternalConnectionProviderType[];
+    getProvider(providerType: UserExternalConnectionProviderType): Maybe<DbxFirebaseExternalConnectionProvider>;
+    getProviders(types?: Maybe<Iterable<UserExternalConnectionProviderType>>): DbxFirebaseExternalConnectionProvider[];
+    getAssetsForProvider(providerType: UserExternalConnectionProviderType): Maybe<DbxFirebaseExternalConnectionProviderAssets>;
+    /**
+     * Whether the connect flow mints a signed `state` and carries it on the authorize request.
+     *
+     * @returns True when state minting is enabled, which is the default.
+     */
+    get mintsAuthorizeState(): boolean;
+    /**
+     * Mints the short-lived signed `state` that begins a provider's OAuth handoff.
+     *
+     * An AUTHENTICATED call, which is the entire point of it: the top-level navigation that follows
+     * carries no Firebase ID token, so this is the only place the server learns who is connecting.
+     *
+     * Requires the user to already have a connection document — the server asserts a role against it,
+     * and a role map is only consulted for a document that exists. `DbxFirebaseExternalConnectionsComponent`
+     * creates it on load; a custom UI that reaches this call by another route has to create it too.
+     *
+     * @param providerType - The provider the state is for.
+     * @returns The state to send on the authorize request.
+     */
+    mintAuthorizeStateForProvider(providerType: UserExternalConnectionProviderType): Promise<DbxFirebaseExternalConnectionAuthorizeState>;
+    /**
+     * Resolves the authorize url for a provider, carrying a freshly minted `state` when state minting
+     * is enabled.
+     *
+     * @param providerType - The provider to resolve.
+     * @returns The authorize url, or null when the provider is not registered.
+     */
+    authorizeUrlWithStateForProvider(providerType: UserExternalConnectionProviderType): Promise<Maybe<string>>;
+    /**
+     * Resolves the authorize url for a provider, WITHOUT a `state`.
+     *
+     * @param providerType - The provider to resolve.
+     * @returns The authorize url, or null when the provider is not registered.
+     */
+    authorizeUrlForProvider(providerType: UserExternalConnectionProviderType): Maybe<string>;
+    /**
+     * Starts the connect flow for a provider.
+     *
+     * Uses the provider's own `connect` handler when it declares one, otherwise mints the `state` and
+     * navigates to the authorize url carrying it. The mint is deliberately part of the default rather
+     * than something each app re-implements: the app's authorize endpoint bounces a stateless request
+     * straight to its failure url, so a "connect" that skipped it would look like it worked and land
+     * the user back on the settings page unconnected.
+     *
+     * @param providerType - The provider to connect.
+     * @returns Resolves once the authorize page is actually opening, and rejects when it never opened.
+     */
+    connectToProvider(providerType: UserExternalConnectionProviderType): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseExternalConnectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseExternalConnectionService>;
+}
+
+/**
+ * Injection token for the app's UserExternalConnection collection.
+ *
+ * The model's own `UserExternalConnectionFirestoreCollections` is an interface (the canonical model
+ * folder shape) and so cannot be an Angular injection token. This abstract class is that token, and
+ * is bound to the app's collections class by `provideDbxFirebaseExternalConnections()`.
+ */
+declare abstract class DbxFirebaseUserExternalConnectionCollections implements UserExternalConnectionFirestoreCollections {
+    abstract readonly userExternalConnectionCollection: UserExternalConnectionFirestoreCollection;
+}
+/**
+ * Document store for the signed-in user's single UserExternalConnection document.
+ *
+ * The document id IS the user's uid, so this store is keyed with `setId(currentUid$)`.
+ */
+declare class UserExternalConnectionDocumentStore extends AbstractDbxFirebaseDocumentStore<UserExternalConnection, UserExternalConnectionDocument> {
+    readonly userExternalConnectionFunctions: UserExternalConnectionFunctions;
+    constructor();
+    /**
+     * Creates the user's connection document.
+     *
+     * Required before any provider can be connected: the server asserts a role against this document,
+     * and a role map is only consulted for a document that exists. Throws when the user already has
+     * one, so call it only for a user known not to.
+     */
+    readonly createUserExternalConnection: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreCreateFunction<_dereekb_firebase.CreateUserExternalConnectionParams, _dereekb_firebase.OnCallCreateModelResult>;
+    /**
+     * Disconnects the user from a provider. The only write a client can make to the connection pair.
+     */
+    readonly disconnectUserExternalConnection: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.DisconnectUserExternalConnectionParams, void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserExternalConnectionDocumentStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserExternalConnectionDocumentStore>;
+}
+
+/**
+ * Directive providing a {@link UserExternalConnectionDocumentStore} for a single user's connection document.
+ */
+declare class DbxFirebaseUserExternalConnectionDocumentStoreDirective extends DbxFirebaseDocumentStoreDirective<UserExternalConnection, UserExternalConnectionDocument, UserExternalConnectionDocumentStore> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseUserExternalConnectionDocumentStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseUserExternalConnectionDocumentStoreDirective, "[dbxFirebaseUserExternalConnectionDocument]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Maps the document store's loading state into the per-provider entry map the UI renders from.
+ *
+ * This mapper exists because `dataLoadingState$` turns a MISSING document into
+ * `errorResult(modelDoesNotExistError())` — and a user who has never connected anything has no
+ * document, which is the common case, not an error. `exists$` catches `permission-denied` but does
+ * not feed `dataLoadingState$`, so that case has to be handled here too.
+ *
+ * Both cases mean the same thing to this UI: an empty connection map.
+ *
+ * Pure and exported so it is unit-testable without a TestBed.
+ *
+ * @param state - The document store's data loading state.
+ * @returns The loading state of the user's entry map.
+ */
+declare function externalConnectionsLoadingStateFromDocumentLoadingState(state: LoadingState<DocumentDataWithIdAndKey<UserExternalConnection>>): LoadingState<UserExternalConnectionEntryMap>;
+/**
+ * Decides whether a document load means the user has no connection document and needs one created.
+ *
+ * Only a definitive does-not-exist counts. A state that is still loading carries no value and would
+ * otherwise read as missing — creating on it would fail for every user who does have a document. A
+ * denied read is a rules problem rather than an absent document, so it does not create either.
+ *
+ * Pure and exported so it is unit-testable without a TestBed.
+ *
+ * @param state - The document store's data loading state.
+ * @returns True when the document is known not to exist.
+ */
+declare function shouldCreateUserExternalConnectionForDocumentLoadingState(state: LoadingState<DocumentDataWithIdAndKey<UserExternalConnection>>): boolean;
+/**
+ * Derived state for the signed-in user's external connections.
+ *
+ * Holds THE shared subscription: one document read fanned out to every provider row, instead of one
+ * read per provider. That is the payoff of collapsing to a single document per user.
+ */
+declare class DbxFirebaseUserExternalConnectionsStore {
+    readonly userExternalConnectionDocumentStore: UserExternalConnectionDocumentStore;
+    /**
+     * The user's per-provider entries. A missing document (or a denied read) resolves to an empty map.
+     */
+    readonly entriesLoadingState$: Observable<LoadingState<UserExternalConnectionEntryMap>>;
+    /**
+     * Creates the user's connection document if they do not have one, and does nothing if they do.
+     *
+     * Waits for a settled load before deciding, because a loading state carries no value and would
+     * otherwise read as "missing" for a user who does have a document. Only the definitive
+     * does-not-exist error creates: a denied read is a rules problem, not an absent document.
+     *
+     * The create runs through the document store, so a rejection (including losing the race with
+     * another tab, which the server reports as already-exists) arrives as `error` on the returned
+     * loading state rather than as a thrown error.
+     *
+     * @returns The loading state of the create, or a state with no value when one already exists.
+     */
+    createIfMissing(): Observable<Maybe<LoadingState<OnCallCreateModelResult>>>;
+    /**
+     * Sets the uid whose connection document is loaded. The document id IS the uid.
+     *
+     * @param uid - The uid, or an observable of it. Null clears the loaded document.
+     */
+    setUid(uid: Maybe<string> | Observable<Maybe<string>>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseUserExternalConnectionsStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseUserExternalConnectionsStore>;
+}
+
+type DbxFirebaseExternalConnectionListItem = DbxValueAsListItem<DbxFirebaseExternalConnectionListItemValue>;
+/**
+ * Renders every third-party connection as a card row.
+ *
+ * Composed list utilities (see `DocProgressItemListComponent` for the same recipe):
+ * - `.dbx-list-card-items-list` paints each row as a tinted, rounded card;
+ * - `.dbx-list-no-hover-effects` drops the hover state layer, since a row is not clickable — only its buttons are;
+ * - `.dbx-list-auto-height` lets the list flow inline inside the settings section rather than filling it.
+ *
+ * @example
+ * ```html
+ * <dbx-firebase-external-connection-list [state]="listStateSignal()"></dbx-firebase-external-connection-list>
+ * ```
+ */
+declare class DbxFirebaseExternalConnectionListComponent extends AbstractDbxListWrapperDirective<DbxFirebaseExternalConnectionListItemValue> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseExternalConnectionListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseExternalConnectionListComponent, "dbx-firebase-external-connection-list", never, {}, {}, never, ["[top]", "[bottom]", "[empty]", "[emptyLoading]", "[end]"], true, never>;
+}
+declare class DbxFirebaseExternalConnectionListViewComponent extends AbstractDbxListViewDirective<DbxFirebaseExternalConnectionListItemValue> {
+    readonly config: DbxValueListViewConfig<DbxFirebaseExternalConnectionListItem>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseExternalConnectionListViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseExternalConnectionListViewComponent, "dbx-firebase-external-connection-list-view", never, {}, {}, never, never, true, never>;
+}
+/**
+ * One third-party connection: its brand, its current state for the signed-in user, and the actions available for it.
+ *
+ * Presentational — the row and its actions arrive as the injected list item, built by the container that reads every
+ * provider's state from ONE document.
+ */
+declare class DbxFirebaseExternalConnectionListViewItemComponent extends AbstractDbxValueListViewItemComponent<DbxFirebaseExternalConnectionListItemValue> {
+    readonly defaultIcon = "link";
+    readonly autoConfirmConfig: DbxActionConfirmConfig<unknown>;
+    get row(): DbxFirebaseExternalConnectionRow;
+    get assets(): _dereekb_dbx_firebase.DbxFirebaseExternalConnectionProviderAssets;
+    /**
+     * Actions for this row. An ARRAY because the `error` status offers both Reconnect and Disconnect.
+     *
+     * @returns The actions to render, empty when there are none.
+     */
+    get actions(): DbxFirebaseExternalConnectionActionConfig[];
+    get statusLabel(): string;
+    get statusColor(): DbxThemeColor;
+    get connectedAt(): Maybe<Date>;
+    /**
+     * The line under the provider name: which account is connected, or what the provider is for.
+     *
+     * @returns The detail line, or nullish when there is nothing to say.
+     */
+    get detail(): Maybe<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseExternalConnectionListViewItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseExternalConnectionListViewItemComponent, "dbx-firebase-external-connection-list-view-item", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Renders every registered third-party connection for the signed-in user.
+ *
+ * Owns the stores and makes exactly ONE `toSignal` subscription, which every row is computed from —
+ * the payoff of collapsing to one connection document per user. The rows are presentational and take
+ * their entry as a plain input rather than loading anything themselves.
+ *
+ * @example
+ * ```html
+ * <dbx-firebase-external-connections></dbx-firebase-external-connections>
+ * ```
+ */
+declare class DbxFirebaseExternalConnectionsComponent {
+    readonly dbxFirebaseAuthService: DbxFirebaseAuthService;
+    readonly dbxFirebaseExternalConnectionService: DbxFirebaseExternalConnectionService;
+    readonly dbxFirebaseUserExternalConnectionsStore: DbxFirebaseUserExternalConnectionsStore;
+    readonly userExternalConnectionDocumentStore: UserExternalConnectionDocumentStore;
+    constructor();
+    private readonly _currentUidSignal;
+    /**
+     * THE shared subscription. Every row is computed from this one document read.
+     */
+    private readonly _entriesStateSignal;
+    readonly signedInSignal: i0.Signal<boolean>;
+    readonly errorSignal: i0.Signal<Maybe<_dereekb_util.ReadableError>>;
+    readonly rowsSignal: i0.Signal<DbxFirebaseExternalConnectionRow[]>;
+    /**
+     * The list's state.
+     *
+     * Always a success result, never a loading one: a row carries its own `loading` status and renders a "Loading"
+     * chip, which reads better here than the list swapping itself out for a spinner and then reflowing.
+     */
+    readonly listStateSignal: i0.Signal<ListLoadingState<DbxFirebaseExternalConnectionListItemValue>>;
+    /**
+     * Builds the actions for a row.
+     *
+     * An errored connection offers both Reconnect and Disconnect: reconnecting is the usual fix, but a
+     * user who no longer wants the integration must not be forced to reauthorize just to remove it.
+     *
+     * @param row - The row to build actions for.
+     * @returns The actions to render, or null while loading.
+     */
+    actionsForRow(row: DbxFirebaseExternalConnectionRow): Maybe<DbxFirebaseExternalConnectionActionConfig[]>;
+    /**
+     * Starts the connect flow for a provider.
+     *
+     * The action stays working until the authorize page is actually opening, rather than succeeding the
+     * moment the redirect is requested — the page the user is looking at has not changed yet, so a
+     * success there reads as "nothing happened".
+     *
+     * @param providerType - The provider to connect.
+     * @returns Resolves once the authorize page is actually opening.
+     */
+    connectToProvider(providerType: UserExternalConnectionProviderType): Promise<void>;
+    /**
+     * Disconnects the signed-in user from a provider.
+     *
+     * @param providerType - The provider to disconnect.
+     * @returns The loading state observable of the callable.
+     */
+    disconnectFromProvider(providerType: UserExternalConnectionProviderType): rxjs.Observable<LoadingState<void>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseExternalConnectionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseExternalConnectionsComponent, "dbx-firebase-external-connections", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Configuration for provideDbxFirebaseExternalConnections().
+ */
+interface ProvideDbxFirebaseExternalConnectionsConfig extends DbxFirebaseExternalConnectionsConfig {
+    /**
+     * The app's Firestore collections class, which must implement `UserExternalConnectionFirestoreCollections`.
+     *
+     * Passed explicitly rather than derived, for the same reason `provideDbxFirestoreCollection()`
+     * takes it: the library never names an app's collections class.
+     */
+    readonly appCollectionClass: ClassLikeType<UserExternalConnectionFirestoreCollections>;
+}
+/**
+ * Registers the third-party connection providers an app offers, plus the registry service and the
+ * collection token the connection stores read from.
+ *
+ * A SIBLING of `provideDbxFirebase()` (like `provideDbxFirebaseLogin()` / `provideDbxFirebaseOidc()`)
+ * rather than part of it: it requires an app-supplied provider catalog and depends on
+ * `provideDbxFirestoreCollection()` having run.
+ *
+ * Naming a known provider type is all an app needs to offer that service: the library carries the
+ * presentation, and the connect flow — minting the signed `state`, then redirecting to the authorize
+ * url carrying it — is the library's default. Nothing about it belongs in an app's config.
+ *
+ * @param config - The provider catalog and authorize configuration.
+ * @returns EnvironmentProviders.
+ *
+ * @example
+ * ```ts
+ * provideDbxFirebaseExternalConnections({
+ *   appCollectionClass: DemoFirestoreCollections,
+ *   authorizeOrigin: environment.externalConnectionAuthorizeOrigin,
+ *   providers: [
+ *     CALCOM_USER_EXTERNAL_CONNECTION_PROVIDER_TYPE,
+ *     // start from a known provider and reword one line
+ *     dbxFirebaseKnownExternalConnectionProvider({ providerType: DISCORD_USER_EXTERNAL_CONNECTION_PROVIDER_TYPE, assets: { description: 'Link Discord to get notified in your server.' } }),
+ *     // or declare a service the library has no defaults for
+ *     APP_INTERNAL_EXTERNAL_CONNECTION_PROVIDER
+ *   ]
+ * })
+ * ```
+ */
+declare function provideDbxFirebaseExternalConnections(config: ProvideDbxFirebaseExternalConnectionsConfig): EnvironmentProviders;
+
+/**
+ * The "send a test message" action for one delivery method's section.
+ *
+ * Carries the handler rather than the section emitting an output: the button — and so the `dbxAction`
+ * host that drives it — lives inside the section, while the behaviour belongs to whoever owns the store.
+ * The section stays presentational and the container stays in charge of what the action does.
+ */
+interface DbxFirebaseNotificationHealthCheckMethodProbeActionConfig {
+    /**
+     * Label for the button, e.g. `Send Test Email`.
+     */
+    readonly label: string;
+    /**
+     * Material icon name for the button.
+     */
+    readonly icon?: Maybe<string>;
+    /**
+     * Whether the action is currently unavailable — typically because the server's probe window for this
+     * method has not passed yet.
+     */
+    readonly disabled?: Maybe<boolean>;
+    /**
+     * Explains why the action is unavailable, shown above the button.
+     */
+    readonly notice?: Maybe<string>;
+    /**
+     * Confirmation shown before the action runs.
+     *
+     * Effectively required, for two reasons: a test message is delivered to the user for real, and
+     * confirming is also what marks the action value-ready. Without a confirm the button triggers but the
+     * handler never runs.
+     */
+    readonly confirm?: Maybe<DbxActionConfirmConfig>;
+    /**
+     * Dispatches the test message.
+     */
+    readonly handler: WorkUsingContext;
+}
+/**
+ * Renders one delivery method's health check result: where it would deliver to, everything the check
+ * found for it, the state of any test message that was sent through it, and — when the method can be
+ * probed and an action is supplied — the button for sending a new one.
+ *
+ * Presentational: it injects nothing beyond the presentation registry, so it can be dropped anywhere a
+ * result is already in hand. The test message action is an input rather than something it resolves.
+ */
+declare class DbxFirebaseNotificationHealthCheckMethodComponent {
+    private readonly _presentationService;
+    readonly result: i0.InputSignal<Maybe<NotificationDeliveryHealthCheckResult>>;
+    /**
+     * The test message action to offer for this method, when the owner of the check has one to offer.
+     *
+     * Ignored unless the result reports that the method can actually be probed.
+     */
+    readonly probeAction: i0.InputSignal<Maybe<DbxFirebaseNotificationHealthCheckMethodProbeActionConfig>>;
+    readonly methodLabelSignal: i0.Signal<string>;
+    readonly methodIconSignal: i0.Signal<string>;
+    readonly statusColorSignal: i0.Signal<i1.DbxThemeColor>;
+    readonly statusLabelSignal: i0.Signal<string>;
+    /**
+     * Introduces the dispatched probe's timestamp, naming what was actually sent.
+     *
+     * Sentence-cased from the method's mid-sentence noun, since it opens the line.
+     */
+    readonly testMessageSentLabelSignal: i0.Signal<string>;
+    /**
+     * The action to render, which requires the server to have reported this method as probe-capable.
+     *
+     * The result is the authority on that, so an action supplied for a method that cannot be probed is
+     * dropped rather than offering the user a test message the server would refuse to send.
+     */
+    readonly probeActionSignal: i0.Signal<Maybe<DbxFirebaseNotificationHealthCheckMethodProbeActionConfig>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationHealthCheckMethodComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseNotificationHealthCheckMethodComponent, "dbx-firebase-notification-healthcheck-method", never, { "result": { "alias": "result"; "required": false; "isSignal": true; }; "probeAction": { "alias": "probeAction"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The test message action to offer in each delivery method's section, keyed by method.
+ *
+ * A method with no entry gets no test message action, as does a method the check reports as not
+ * probe-capable.
+ */
+type DbxFirebaseNotificationHealthCheckProbeActionMap = NotificationDeliveryMethodMap<Maybe<DbxFirebaseNotificationHealthCheckMethodProbeActionConfig>>;
+/**
+ * Renders a whole {@link NotificationHealthCheck}: the rolled-up status, then one section per delivery
+ * method that this system can actually send through.
+ *
+ * This is the inlineable report — it takes the check as an input and injects nothing beyond the
+ * presentation registry, so it can be dropped anywhere a check is already in hand (a settings page, a
+ * dialog, an admin view). The per-method test message actions are an input for the same reason: the
+ * report renders them, whoever owns the store supplies them.
+ *
+ * The view is client-facing, so it shows only what the user can act on. The check's account-wide
+ * findings (`is`), any method the system has no send service for, and the methods in
+ * {@link HIDDEN_NOTIFICATION_DELIVERY_METHODS} are left out here — all of them remain on the check
+ * itself for an API/callModel consumer.
+ */
+declare class DbxFirebaseNotificationHealthCheckComponent {
+    private readonly _presentationService;
+    readonly healthCheck: i0.InputSignal<Maybe<NotificationHealthCheck>>;
+    /**
+     * The test message action to offer in each method's section, keyed by delivery method.
+     *
+     * Left unset the report is read-only, which is what an admin or historical view wants.
+     */
+    readonly probeActions: i0.InputSignal<Maybe<Partial<Record<NotificationDeliveryMethod, Maybe<DbxFirebaseNotificationHealthCheckMethodProbeActionConfig>>>>>;
+    readonly statusColorSignal: i0.Signal<i1.DbxThemeColor>;
+    readonly statusIconSignal: i0.Signal<string>;
+    readonly statusLabelSignal: i0.Signal<string>;
+    /**
+     * The method results worth showing the user.
+     *
+     * A method the server has no send service for is not something the user can do anything about, so it
+     * is dropped rather than rendered as a "Not Checked" section, as is any method this report does not
+     * render at all — see {@link HIDDEN_NOTIFICATION_DELIVERY_METHODS}.
+     */
+    readonly methodResultsSignal: i0.Signal<_dereekb_firebase.NotificationDeliveryHealthCheckResult[]>;
+    /**
+     * Each method section to render, paired with the test message action for its method.
+     *
+     * Paired up here rather than indexed in the template so the map lookup stays out of the view.
+     */
+    readonly methodSectionsSignal: i0.Signal<{
+        result: _dereekb_firebase.NotificationDeliveryHealthCheckResult;
+        probeAction: Maybe<DbxFirebaseNotificationHealthCheckMethodProbeActionConfig>;
+    }[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationHealthCheckComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseNotificationHealthCheckComponent, "dbx-firebase-notification-healthcheck", never, { "healthCheck": { "alias": "healthCheck"; "required": false; "isSignal": true; }; "probeActions": { "alias": "probeActions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Renders a single {@link NotificationHealthCheckIssue}: its status chip, what was found, and what to
+ * do about it.
+ *
+ * The chip's label and icon come from the {@link DbxFirebaseNotificationHealthCheckPresentationService}
+ * registry; the message and the suggested fix always come from the issue itself, so an issue code the
+ * registry has never seen still renders correctly.
+ *
+ * The finding's structured detail (`d`) is deliberately not rendered — values like the sending domain
+ * or the delivery method key are diagnostic rather than user-facing. They remain on the issue itself,
+ * so an API/callModel consumer still receives them.
+ */
+declare class DbxFirebaseNotificationHealthCheckIssueComponent {
+    private readonly _presentationService;
+    readonly issue: i0.InputSignal<Maybe<NotificationHealthCheckIssue>>;
+    /**
+     * The delivery method this finding belongs to, when it belongs to one.
+     *
+     * Only used to label a probe finding with what was actually sent — `Test Email Sent` rather than the
+     * method-agnostic `Test Sent` — since every provider emits the same probe codes. An account-wide
+     * finding leaves it unset.
+     */
+    readonly method: i0.InputSignal<Maybe<NotificationDeliveryMethod>>;
+    readonly presentationSignal: i0.Signal<_dereekb_dbx_firebase.DbxFirebaseNotificationHealthCheckIssuePresentation>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationHealthCheckIssueComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseNotificationHealthCheckIssueComponent, "dbx-firebase-notification-healthcheck-issue", never, { "issue": { "alias": "issue"; "required": false; "isSignal": true; }; "method": { "alias": "method"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * 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>;
+}
+
+/**
+ * A notification item wrapped with list selection state.
+ */
+type NotificationItemWithSelection = DbxValueAsListItem<NotificationItem>;
+/**
+ * Selection list wrapper for notification items with view-only default selection mode.
+ */
+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>;
+}
+/**
+ * List view component that renders notification items using the selection list pattern.
+ */
+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>;
+}
+/**
+ * Individual list view item component rendering a notification's subject, message, and date.
+ */
+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>;
+}
+
+/**
+ * Presentational component for notification item content, displaying subject, message, and date.
+ */
+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>;
+}
+
+/**
+ * Renders a notification item using the widget system, resolving the appropriate
+ * display component based on the notification's template type.
+ */
+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>;
+}
+
+/**
+ * Abstract base directive for notification item widget display components.
+ *
+ * Provides typed access to the {@link NotificationItem} data for custom rendering.
+ */
+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>;
+}
+
+/**
+ * Default notification item view component that renders subject, message, and creation date.
+ */
+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>;
+}
+
+/**
+ * Configuration for the {@link DbxFirebaseNotificationHealthCheckDialogButtonComponent}.
+ */
+interface DbxFirebaseNotificationHealthCheckDialogButtonComponentConfig {
+    readonly text?: Maybe<string>;
+    readonly icon?: Maybe<string>;
+}
+/**
+ * Button that opens the notification delivery health check in a dialog.
+ *
+ * Place it inside a `dbxFirebaseNotificationUserDocument` so the dialog's view component can resolve
+ * that directive's NotificationUserDocumentStore.
+ */
+declare class DbxFirebaseNotificationHealthCheckDialogButtonComponent {
+    private readonly _matDialog;
+    private readonly _injector;
+    readonly config: i0.InputSignal<Maybe<DbxFirebaseNotificationHealthCheckDialogButtonComponentConfig>>;
+    readonly text: i0.InputSignal<Maybe<string>>;
+    readonly icon: i0.InputSignal<Maybe<string>>;
+    readonly textSignal: i0.Signal<string>;
+    readonly iconSignal: i0.Signal<string>;
+    openHealthCheckDialog(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationHealthCheckDialogButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseNotificationHealthCheckDialogButtonComponent, "dbx-firebase-notification-healthcheck-dialog-button", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Configuration for opening a {@link DbxFirebaseNotificationHealthCheckDialogComponent}.
+ */
+interface DbxFirebaseNotificationHealthCheckDialogComponentConfig {
+    /**
+     * The injector to open the dialog with.
+     *
+     * A dialog renders outside the opening component's view, so it does not inherit that component's
+     * injector by default. Passing the opener's injector is what lets the view component resolve the
+     * NotificationUserDocumentStore that `dbxFirebaseNotificationUserDocument` provided.
+     */
+    readonly injector?: Injector;
+}
+/**
+ * Dialog wrapper around {@link DbxFirebaseNotificationHealthCheckViewComponent}.
+ */
+declare class DbxFirebaseNotificationHealthCheckDialogComponent extends AbstractDialogDirective {
+    /**
+     * Opens the notification delivery health check in a dialog.
+     *
+     * @param matDialog - The dialog service.
+     * @param config - The injector to resolve the NotificationUserDocumentStore from.
+     * @returns The dialog reference.
+     */
+    static openDialog(matDialog: MatDialog, config?: DbxFirebaseNotificationHealthCheckDialogComponentConfig): MatDialogRef<DbxFirebaseNotificationHealthCheckDialogComponent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationHealthCheckDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseNotificationHealthCheckDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Document store for a single NotificationUser with update, resync, and health check functions.
+ */
+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.TargetModelParams, _dereekb_firebase.ResyncNotificationUserResult>;
+    /**
+     * Runs a delivery health check for this NotificationUser.
+     *
+     * Dispatching a real test message is opt-in via the `sendProbe` param, since it delivers actual
+     * mail/SMS to the user.
+     *
+     * The result is only returned by the call, so use the DbxFirebaseNotificationUserHealthCheckStore
+     * to run a check whose outcome is retained as state.
+     */
+    readonly healthCheck: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.NotificationUserHealthCheckParams, _dereekb_firebase.NotificationUserHealthCheckResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationUserDocumentStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationUserDocumentStore>;
+}
+
+/**
+ * Params for a health check run. The store injects the NotificationUser key, so it is not required.
+ */
+type DbxFirebaseNotificationUserHealthCheckRunParams = DbxFirebaseDocumentStoreFunctionParamsInput<NotificationUserHealthCheckParams>;
+interface DbxFirebaseNotificationUserHealthCheckStoreState {
+    /**
+     * The loading state of the most recent health check run made through this store.
+     *
+     * Only set once a run has been dispatched. The check itself is persisted on the NotificationUser,
+     * so the stored one is read from the document instead.
+     */
+    readonly healthCheckResultState?: Maybe<LoadingState<NotificationUserHealthCheckResult>>;
+}
+/**
+ * Store for running a notification delivery health check against the NotificationUser of the
+ * injected {@link NotificationUserDocumentStore}, and for retaining the result of that run.
+ *
+ * Exists separately from the document store because a run returns more than what is persisted:
+ * `probesDispatched`/`probesResolved` are only available on the invocation result, and are only
+ * relevant to the session that ran the check.
+ */
+declare class DbxFirebaseNotificationUserHealthCheckStore extends ComponentStore<DbxFirebaseNotificationUserHealthCheckStoreState> {
+    readonly notificationUserDocumentStore: NotificationUserDocumentStore;
+    /**
+     * The app's health check tuning, when it configured any.
+     *
+     * Optional: without it both windows fall back to the library defaults, which is correct for an app
+     * that did not override them on the server either.
+     */
+    private readonly _config;
+    constructor();
+    /**
+     * Whether the NotificationUser being checked exists.
+     *
+     * There is nothing to check until notifications have been set up for the account.
+     */
+    readonly exists$: Observable<boolean>;
+    /**
+     * The health check stored on the document.
+     *
+     * The check is persisted on every run, so the most recent one renders without invoking anything.
+     */
+    readonly healthCheck$: Observable<Maybe<_dereekb_firebase.NotificationHealthCheck>>;
+    /**
+     * The loading state of the most recent {@link runHealthCheck} dispatch.
+     *
+     * A dispatch sets this to a loading state synchronously, so a caller that dispatches and then
+     * watches this observable is watching its own run.
+     */
+    readonly healthCheckResultState$: Observable<Maybe<LoadingState<NotificationUserHealthCheckResult>>>;
+    /**
+     * The full result of the most recent {@link runHealthCheck} run from this store.
+     *
+     * `probesDispatched`/`probesResolved` are not part of the document, so they are only available here
+     * and only until the store is destroyed.
+     */
+    readonly latestHealthCheckResult$: Observable<Maybe<NotificationUserHealthCheckResult>>;
+    /**
+     * The earliest time another run is allowed, derived from the check stored on the document.
+     *
+     * Undefined until a check has been run.
+     */
+    readonly nextRunAt$: Observable<Maybe<Date>>;
+    /**
+     * The earliest time another test message may be dispatched through each delivery method.
+     *
+     * Per method, because the server's probe window is per method: each method has its own test message
+     * action, and a test email must not hold the test text message off. Tracked separately from
+     * {@link nextRunAt$} as well — running the check does not consume the test message allowance, so a
+     * plain run must not disable any of the probe actions.
+     */
+    readonly nextProbeAtByMethod$: Observable<NotificationDeliveryMethodMap<Maybe<Date>>>;
+    /**
+     * How long until another run is allowed, counting down once per second.
+     */
+    readonly throttleSecondsRemaining$: Observable<Seconds>;
+    /**
+     * How long until another test message may be dispatched through each delivery method, counting down
+     * once per second.
+     *
+     * A method whose window has never opened — no probe has been dispatched through it — is absent, which
+     * a consumer reads the same as 0.
+     */
+    readonly probeThrottleSecondsRemainingByMethod$: Observable<NotificationDeliveryMethodMap<Seconds>>;
+    /**
+     * Whether the server would reject a run right now.
+     *
+     * The server enforces the throttle; this is what lets the view disable the action instead of letting
+     * the user trigger a call that comes back as an error.
+     */
+    readonly isThrottled$: Observable<boolean>;
+    /**
+     * The delivery methods whose test message is still waiting on an outcome.
+     *
+     * The one part of a stored check that changes without anyone re-running it, so it is what
+     * {@link watchPendingProbes} watches.
+     */
+    readonly pendingProbeMethods$: Observable<NotificationDeliveryMethod[]>;
+    /**
+     * Whether a test message is in flight right now.
+     */
+    readonly hasPendingProbe$: Observable<boolean>;
+    /**
+     * The next verification to run, or null when there is nothing to watch.
+     *
+     * Re-derived from the document on every change, which is what paces the loop: each verification
+     * advances the stored check's `vat`, so the moment the server will accept another poll moves forward
+     * and this emits the next one. The watch gives up once the oldest probe has been in flight longer than
+     * the configured window — a provider that is never going to record an outcome should not be polled for
+     * as long as the page stays open.
+     */
+    private readonly _nextProbeVerification$;
+    private readonly _setHealthCheckResultState;
+    /**
+     * Runs the document store's health check for its NotificationUser and puts the outcome on
+     * {@link healthCheckResultState$}.
+     *
+     * Dispatching a real test message is opt-in via the `sendProbe` param, since it delivers actual
+     * mail/SMS to the user.
+     *
+     * While a run is in flight further dispatches are ignored, so the state always reflects the run
+     * that is actually happening.
+     */
+    readonly runHealthCheck: (observableOrValue: Maybe<Omit<NotificationUserHealthCheckParams, "key"> & Partial<Pick<NotificationUserHealthCheckParams, "key">>> | Observable<Maybe<Omit<NotificationUserHealthCheckParams, "key"> & Partial<Pick<NotificationUserHealthCheckParams, "key">>>>) => rxjs.Subscription;
+    /**
+     * Watches every in-flight test message until it has an outcome, without the user doing anything.
+     *
+     * A dispatched probe settles on the delivery provider's schedule rather than the caller's, so
+     * something has to ask again once the outcome exists. That used to be the user, told to come back and
+     * re-run the check; this is that same poll, run automatically. Each verification is scoped to the
+     * methods actually awaiting an outcome and answers to its own server-side window, so it neither sends
+     * anything nor consumes the user's allowance for running the check itself. The result lands on the
+     * NotificationUser, which is already streamed into {@link healthCheck$}, so a settled probe simply
+     * appears in the report.
+     *
+     * Idempotent to start and safe to leave running: it does nothing at all while no probe is in flight,
+     * and stops on its own once every probe has settled or aged out.
+     */
+    readonly watchPendingProbes: (observableOrValue?: void | Observable<void> | undefined) => rxjs.Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationUserHealthCheckStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseNotificationUserHealthCheckStore>;
+}
+/**
+ * A scheduled verification of the test messages a check has in flight.
+ */
+interface DbxFirebaseNotificationUserHealthCheckProbeVerification {
+    /**
+     * The delivery methods awaiting an outcome.
+     */
+    readonly methods: NotificationDeliveryMethod[];
+    /**
+     * The earliest time the server will accept the verification.
+     */
+    readonly at: Date;
+}
+
+/**
+ * Renders the notification delivery health check for the ancestor NotificationUserDocumentStore, and
+ * the actions for re-running it.
+ *
+ * The check is persisted on the NotificationUser, so the last one renders immediately without invoking
+ * anything. "Run Check" re-runs it and stays a single global action, since a run only reads
+ * configuration and provider state. Sending a test message is per delivery method instead — it
+ * dispatches a real message through that one method, and answers to that method's own throttle window —
+ * so its action lives in that method's section rather than in a footer.
+ *
+ * A dispatched test message settles later, on the delivery provider's schedule. This view watches for
+ * that outcome itself rather than telling the user to come back and re-run the check: the store polls a
+ * cheap server-side verification while anything is in flight, and the report — read live from the
+ * document — updates the moment the result lands.
+ */
+declare class DbxFirebaseNotificationHealthCheckViewComponent {
+    private readonly _presentationService;
+    readonly healthCheckStore: DbxFirebaseNotificationUserHealthCheckStore;
+    readonly existsSignal: i0.Signal<boolean>;
+    readonly healthCheckSignal: i0.Signal<Maybe<_dereekb_firebase.NotificationHealthCheck>>;
+    readonly latestHealthCheckResultSignal: i0.Signal<Maybe<_dereekb_firebase.NotificationUserHealthCheckResult>>;
+    readonly throttleSecondsRemainingSignal: i0.Signal<number>;
+    readonly isThrottledSignal: i0.Signal<boolean>;
+    readonly probeThrottleSecondsRemainingByMethodSignal: i0.Signal<Partial<Record<NotificationDeliveryMethod, number>>>;
+    private readonly _lastRequestedProbeMethod;
+    constructor();
+    /**
+     * The delivery method whose test message was most recently requested from this view.
+     *
+     * Recorded because the invocation result reports only how many probes it dispatched, so this is what
+     * lets the notice name what was sent.
+     */
+    readonly lastRequestedProbeMethodSignal: i0.Signal<Maybe<NotificationDeliveryMethod>>;
+    /**
+     * The test message handler for each delivery method, built once up front.
+     *
+     * A per-method countdown rebuilds that method's action config every second, and `dbxActionHandler`
+     * installs its handler in an effect, so handing over a fresh closure on each tick would re-install it
+     * once a second for no reason.
+     */
+    private readonly _sendTestMessageHandlers;
+    /**
+     * Explains why "Run Check" is disabled while the server's run throttle is in effect.
+     */
+    readonly throttleNoticeSignal: i0.Signal<string | undefined>;
+    /**
+     * The test message action for each delivery method the check reports as probe-capable.
+     *
+     * A method that cannot be probed gets no entry, so no test message is offered where the server has no
+     * way to send one.
+     *
+     * Everything the user needs to read about a test message belongs in the section holding the button
+     * that sent it, so the notice is composed here rather than in a footer: what was just sent, that its
+     * outcome is being watched for, and when another may be sent.
+     */
+    readonly probeActionsSignal: i0.Signal<Partial<Record<NotificationDeliveryMethod, Maybe<_dereekb_dbx_firebase.DbxFirebaseNotificationHealthCheckMethodProbeActionConfig>>>>;
+    /**
+     * Composes one delivery method's test message notice.
+     *
+     * Deliberately never tells the user to come back and check: a pending outcome is watched for
+     * automatically, so the only thing left to say about the wait is that they need do nothing.
+     *
+     * @param input - What the method sends, how long its window has left, and the state of its probe.
+     * @returns The notice, or undefined when there is nothing worth saying.
+     */
+    private probeNoticeForMethod;
+    readonly handleRunHealthCheck: WorkUsingContext;
+    /**
+     * Dispatches a run to the store, then tracks that run's loading state as the action's work.
+     *
+     * The store's effect sets the loading state synchronously as it is dispatched, so handing the state
+     * observable over afterwards tracks this run instead of completing on the previous run's result.
+     *
+     * @param context - The work instance of the action being handled.
+     * @param params - The params for this run, such as which methods to send a test message through.
+     */
+    private runHealthCheckAsWork;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationHealthCheckViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseNotificationHealthCheckViewComponent, "dbx-firebase-notification-healthcheck-view", 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>;
+}
+
+/**
+ * Document store for a single Notification, providing derived observables for creation date, send state, and update functions.
+ */
+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>;
+}
+
+/**
+ * Directive providing a {@link NotificationDocumentStore} for accessing a single notification document.
+ */
+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>;
+}
+
+/**
+ * Collection store for Notification documents, scoped to a parent NotificationBox when available.
+ */
+declare class NotificationCollectionStore extends AbstractDbxFirebaseCollectionWithParentStore<Notification, NotificationBox, NotificationDocument, NotificationBoxDocument> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationCollectionStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationCollectionStore>;
+}
+
+/**
+ * Directive providing a {@link NotificationCollectionStore} for querying notifications within a template.
+ */
+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>;
+}
+
+/**
+ * Document store for a single NotificationBox, providing derived observables for creation date, recipients, and update functions.
+ */
+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.TargetModelParams, void>;
+    readonly updateNotificationBoxRecipient: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.UpdateNotificationBoxRecipientParams, void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationBoxDocumentStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationBoxDocumentStore>;
+}
+
+/**
+ * Directive providing a {@link NotificationBoxDocumentStore} for accessing a single notification box document.
+ */
+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>;
+}
 
 /**
  * Collection store for querying NotificationBox documents.
@@ -4666,24 +5923,267 @@ declare class DbxFirebaseNotificationUserCollectionStoreDirective extends DbxFir
 }
 
 /**
- * Document store for a single NotificationUser with update and resync functions.
+ * Directive providing a {@link NotificationUserDocumentStore} for accessing a single notification user document.
  */
-declare class NotificationUserDocumentStore extends AbstractDbxFirebaseDocumentStore<NotificationUser, NotificationUserDocument> {
-    readonly notificationFunctions: NotificationFunctions;
+declare class DbxFirebaseNotificationUserDocumentStoreDirective extends DbxFirebaseDocumentStoreDirective<NotificationUser, NotificationUserDocument, NotificationUserDocumentStore> {
     constructor();
-    readonly updateNotificationUser: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.UpdateNotificationUserParams, void>;
-    readonly resyncNotificationUser: _dereekb_dbx_firebase.DbxFirebaseDocumentStoreFunction<_dereekb_firebase.TargetModelParams, _dereekb_firebase.ResyncNotificationUserResult>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationUserDocumentStore, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationUserDocumentStore>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationUserDocumentStoreDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseNotificationUserDocumentStoreDirective, "[dbxFirebaseNotificationUserDocument]", never, {}, {}, never, never, true, never>;
 }
 
 /**
- * Directive providing a {@link NotificationUserDocumentStore} for accessing a single notification user document.
+ * @module healthcheck.presentation
+ *
+ * Presentation metadata for notification health check findings.
+ *
+ * Issue codes are intentionally open-ended — apps and delivery providers emit their own — so the UI
+ * needs a way to attach a label and an icon to a code it does not know about. Every issue already
+ * carries its own user-facing `m` (message) and `f` (suggested fix), so a registered entry supplies
+ * **presentation only, never copy**: an unregistered code still renders correctly, just with a
+ * status-derived label and icon instead of a code-specific one.
  */
-declare class DbxFirebaseNotificationUserDocumentStoreDirective extends DbxFirebaseDocumentStoreDirective<NotificationUser, NotificationUserDocument, NotificationUserDocumentStore> {
+
+/**
+ * How a single {@link NotificationHealthCheckIssueCode} should be presented.
+ *
+ * Deliberately carries no message text: the issue itself is the authority on what to say.
+ */
+interface DbxFirebaseNotificationHealthCheckPresentationEntry {
+    /**
+     * The issue code this entry presents.
+     */
+    readonly code: NotificationHealthCheckIssueCode;
+    /**
+     * Short label for the finding, shown on its status chip.
+     */
+    readonly label?: Maybe<string>;
+    /**
+     * Material icon name for the finding.
+     */
+    readonly icon?: Maybe<string>;
+    /**
+     * Overrides the colour that would otherwise be derived from the issue's status.
+     *
+     * Rarely useful, and unset on every library default: the same code is emitted at different
+     * severities depending on what was found (a recent delivery failure is an error when permanent and
+     * a warning when temporary), so the status is the more accurate source.
+     */
+    readonly color?: Maybe<DbxThemeColor>;
+}
+/**
+ * A fully resolved presentation for one finding.
+ */
+interface DbxFirebaseNotificationHealthCheckIssuePresentation {
+    readonly label: string;
+    readonly icon: string;
+    readonly color: DbxThemeColor;
+}
+/**
+ * App-level tuning for the notification delivery health check UI.
+ *
+ * These windows are ENFORCED BY THE SERVER; the client only counts down to them so it can disable an
+ * action instead of letting the user trigger a call that comes back as an error. So every value here
+ * must match what the server was configured with — declare it once in a package both sides import
+ * rather than writing the number down twice, or the UI will offer a test message the server rejects.
+ */
+declare abstract class DbxFirebaseNotificationHealthCheckConfig {
+    /**
+     * How long a user must wait between test messages on a single delivery method.
+     *
+     * Defaults to {@link DEFAULT_NOTIFICATION_USER_HEALTH_CHECK_PROBE_THROTTLE_MINUTES}.
+     */
+    abstract readonly probeThrottleMinutes?: Maybe<Minutes>;
+    /**
+     * How long a user must wait between health check runs.
+     *
+     * Defaults to {@link DEFAULT_NOTIFICATION_USER_HEALTH_CHECK_THROTTLE_MINUTES}.
+     */
+    abstract readonly runThrottleMinutes?: Maybe<Minutes>;
+    /**
+     * How long the client must wait between verifications of an in-flight test message.
+     *
+     * Defaults to {@link DEFAULT_NOTIFICATION_USER_HEALTH_CHECK_VERIFY_THROTTLE_SECONDS}. This is also
+     * the cadence the client polls at, so it must match the server's window: pace faster and every other
+     * poll comes back rejected.
+     */
+    abstract readonly verifyThrottleSeconds?: Maybe<Seconds>;
+    /**
+     * How long to keep watching a test message before giving up on it.
+     *
+     * Defaults to {@link DEFAULT_NOTIFICATION_HEALTH_CHECK_PROBE_WATCH_MINUTES}. Purely a client-side
+     * stop: a provider that never records an outcome would otherwise be polled for as long as the page
+     * stays open. Once it passes, the probe is left pending and the next full run settles it.
+     */
+    abstract readonly probeWatchMinutes?: Maybe<Minutes>;
+}
+/**
+ * How long the client keeps watching an in-flight test message before giving up on it.
+ *
+ * Comfortably longer than a provider takes to record a delivery outcome — the point is to stop polling
+ * a provider that is never going to answer, not to impose a deadline of the client's own.
+ */
+declare const DEFAULT_NOTIFICATION_HEALTH_CHECK_PROBE_WATCH_MINUTES: Minutes;
+/**
+ * Configuration for the {@link DbxFirebaseNotificationHealthCheckPresentationService}.
+ */
+declare abstract class DbxFirebaseNotificationHealthCheckPresentationServiceConfig {
+    /**
+     * App-specific entries to register, layered over the library defaults.
+     */
+    abstract readonly entries?: Maybe<ArrayOrValue<DbxFirebaseNotificationHealthCheckPresentationEntry>>;
+    /**
+     * Whether to register the library's default entries. Defaults to true.
+     */
+    abstract readonly registerDefaultEntries?: Maybe<boolean>;
+}
+/**
+ * Colour for each health check status.
+ *
+ * `WARNING` and `ERROR` deliberately share `warn` — the palette has no distinct error tone — so they
+ * are told apart by their icons instead.
+ */
+declare const NOTIFICATION_HEALTH_CHECK_STATUS_COLORS: Record<NotificationHealthCheckStatus, DbxThemeColor>;
+/**
+ * Icon for each health check status. Also what distinguishes a warning from an error.
+ */
+declare const NOTIFICATION_HEALTH_CHECK_STATUS_ICONS: Record<NotificationHealthCheckStatus, string>;
+/**
+ * Human-readable label for each health check status.
+ *
+ * Used as the chip label for an issue code with no registered entry.
+ */
+declare const NOTIFICATION_HEALTH_CHECK_STATUS_LABELS: Record<NotificationHealthCheckStatus, string>;
+/**
+ * Human-readable label for each delivery method.
+ */
+declare const NOTIFICATION_DELIVERY_METHOD_LABELS: Record<NotificationDeliveryMethod, string>;
+/**
+ * Icon for each delivery method.
+ */
+declare const NOTIFICATION_DELIVERY_METHOD_ICONS: Record<NotificationDeliveryMethod, string>;
+/**
+ * Label for each delivery method's "send a test message" action.
+ *
+ * Always names what the method actually delivers — "Send Test Email", "Send Test Text Message" — rather
+ * than a generic "Send Test Message", so the button says which of a user's contact details it is about
+ * to send something real to.
+ */
+declare const NOTIFICATION_DELIVERY_METHOD_TEST_MESSAGE_LABELS: Record<NotificationDeliveryMethod, string>;
+/**
+ * Noun for what each delivery method's test message actually is, for use mid-sentence.
+ *
+ * Lowercase because it reads inside prose — "A test text message was sent recently."
+ */
+declare const NOTIFICATION_DELIVERY_METHOD_TEST_MESSAGE_NOUNS: Record<NotificationDeliveryMethod, string>;
+/**
+ * Short name for each delivery method, for a label that has to stay compact.
+ *
+ * Used to compose the probe chips — `Test Email Sent`, `Test Text Sent` — where the full
+ * {@link NOTIFICATION_DELIVERY_METHOD_LABELS} wording would make the chip too long to scan.
+ */
+declare const NOTIFICATION_DELIVERY_METHOD_SHORT_LABELS: Record<NotificationDeliveryMethod, string>;
+/**
+ * What each probe lifecycle code says happened to the test message.
+ *
+ * The other half of the composed probe chip label — see {@link notificationHealthCheckProbeIssueLabel}.
+ */
+declare const NOTIFICATION_HEALTH_CHECK_PROBE_ISSUE_OUTCOMES: Record<NotificationHealthCheckIssueCode, string>;
+/**
+ * The chip label for a probe lifecycle finding, naming the delivery method it belongs to.
+ *
+ * Every provider emits the same probe codes, so these labels cannot be fixed strings in the presentation
+ * registry the way every other code's is: the same `probeDelivered` finding should read `Test Email
+ * Delivered` in the email section and `Test Text Delivered` in the text section.
+ *
+ * @param code - The issue code to label.
+ * @param method - The delivery method whose section the finding is rendered in.
+ * @returns The composed label, or undefined when the code is not a probe lifecycle code.
+ */
+declare function notificationHealthCheckProbeIssueLabel(code: NotificationHealthCheckIssueCode, method: NotificationDeliveryMethod): Maybe<string>;
+/**
+ * Presentation entries for every issue code the library and the Mailgun email check emit.
+ *
+ * None of them set a colour — see {@link DbxFirebaseNotificationHealthCheckPresentationEntry.color}.
+ */
+declare const DEFAULT_NOTIFICATION_HEALTH_CHECK_PRESENTATION_ENTRIES: DbxFirebaseNotificationHealthCheckPresentationEntry[];
+
+/**
+ * Registry of presentation metadata for notification health check findings.
+ *
+ * Health check issue codes are open-ended, so this maps a code to a label and an icon. An
+ * unregistered code is not an error — it falls back to a presentation derived from the issue's
+ * status, and the issue's own `m`/`f` strings carry the meaning either way.
+ *
+ * Apps extend the table by supplying a {@link DbxFirebaseNotificationHealthCheckPresentationServiceConfig}
+ * through `provideDbxFirebaseNotifications({ healthCheckPresentation })`.
+ */
+declare class DbxFirebaseNotificationHealthCheckPresentationService {
+    private readonly _config;
+    private readonly _entries;
     constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationUserDocumentStoreDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseNotificationUserDocumentStoreDirective, "[dbxFirebaseNotificationUserDocument]", never, {}, {}, never, never, true, never>;
+    /**
+     * Registers presentation entries, overriding any already registered for the same code by default.
+     *
+     * @param entries - The entries to register.
+     * @param override - Whether to replace an existing entry for the same code. Defaults to true.
+     */
+    register(entries: ArrayOrValue<DbxFirebaseNotificationHealthCheckPresentationEntry>, override?: boolean): void;
+    /**
+     * The entry registered for an issue code, if any.
+     *
+     * @param code - The issue code to look up.
+     * @returns The registered entry, or undefined when the code has none.
+     */
+    entryForCode(code: NotificationHealthCheckIssueCode): Maybe<DbxFirebaseNotificationHealthCheckPresentationEntry>;
+    /**
+     * Resolves how to present a single finding.
+     *
+     * Pass the delivery method whose section the finding is rendered in to get a probe label that names
+     * it — `Test Email Sent` rather than `Test Sent`. Every provider emits the same probe codes, so that
+     * is the one label a registry entry cannot supply on its own.
+     *
+     * @param issue - The finding to present.
+     * @param method - The delivery method the finding belongs to, when it belongs to one.
+     * @returns The label, icon, and colour to render it with.
+     */
+    presentationForIssue(issue: NotificationHealthCheckIssue, method?: Maybe<NotificationDeliveryMethod>): DbxFirebaseNotificationHealthCheckIssuePresentation;
+    /**
+     * @param status - The status to colour.
+     * @returns The theme colour for the status.
+     */
+    colorForStatus(status: NotificationHealthCheckStatus): DbxThemeColor;
+    /**
+     * @param status - The status to find an icon for.
+     * @returns The icon for the status.
+     */
+    iconForStatus(status: NotificationHealthCheckStatus): string;
+    /**
+     * @param status - The status to label.
+     * @returns The human-readable label for the status.
+     */
+    labelForStatus(status: NotificationHealthCheckStatus): string;
+    /**
+     * @param method - The delivery method to label.
+     * @returns The human-readable label for the delivery method.
+     */
+    labelForDeliveryMethod(method: NotificationDeliveryMethod): string;
+    /**
+     * @param method - The delivery method to find an icon for.
+     * @returns The icon for the delivery method.
+     */
+    iconForDeliveryMethod(method: NotificationDeliveryMethod): string;
+    /**
+     * @param method - The delivery method whose test message action is being labelled.
+     * @returns The label for the method's "send a test message" action, naming what it sends.
+     */
+    testMessageLabelForDeliveryMethod(method: NotificationDeliveryMethod): string;
+    /**
+     * @param method - The delivery method whose test message is being described.
+     * @returns The lowercase noun for the method's test message, for use mid-sentence.
+     */
+    testMessageNounForDeliveryMethod(method: NotificationDeliveryMethod): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseNotificationHealthCheckPresentationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseNotificationHealthCheckPresentationService>;
 }
 
 /**
@@ -4750,6 +6250,22 @@ interface ProvideDbxFirebaseNotificationsConfig {
      * If false, will not register anything.
      */
     readonly defaultNotificationItemWidget?: DbxWidgetEntry['componentClass'] | false;
+    /**
+     * App-specific presentation entries for notification health check issue codes.
+     *
+     * Only needed when the app or one of its delivery providers emits issue codes the library does not
+     * know about. The health check UI works without this — an unregistered code falls back to a
+     * presentation derived from the finding's own status.
+     */
+    readonly healthCheckPresentation?: Maybe<DbxFirebaseNotificationHealthCheckPresentationServiceConfig>;
+    /**
+     * Tuning for the notification health check's throttle windows.
+     *
+     * Only needed when the app configured different windows on its server. The values are enforced there
+     * and merely counted down here, so they must be the same on both sides — pass the app's own shared
+     * constants rather than repeating the numbers.
+     */
+    readonly healthCheck?: Maybe<DbxFirebaseNotificationHealthCheckConfig>;
 }
 /**
  * Creates EnvironmentProviders that provides a DbxFirebaseNotificationTemplateService, DbxFirebaseNotificationItemWidgetService and AppNotificationTemplateTypeInfoRecordService.
@@ -5850,5 +7366,5 @@ interface ProvideDbxFirebaseConfig<T, M extends FirebaseFunctionsMap = FirebaseF
  */
 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_AUTH_FLOW_TOKEN, DBX_FIREBASE_DOCUMENT_STORE_CONTEXT_STORE_TOKEN, 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_FIREBASE_STORAGE_PDF_MERGE_UPLOAD_FILE_NAME, DBX_FIRESTORE_CONTEXT_TOKEN, DEFAULT_CONFIGURED_DBX_FIREBASE_LOGIN_BUTTON_TEMPLATE, DEFAULT_DBX_FIREBASE_ANALYTICS_USER_PROPERTIES_FACTORY, DEFAULT_DBX_FIREBASE_AUTH_FLOW, DEFAULT_DBX_FIREBASE_AUTH_SERVICE_DELEGATE, DEFAULT_DBX_FIREBASE_ID_ROUTER_PARAM_ID_PARAM_KEY, DEFAULT_DBX_FIREBASE_ID_ROUTER_PARAM_KEY_PARAM_KEY, DEFAULT_DBX_FIREBASE_ID_ROUTER_PARAM_USE_PARAM_VALUE, 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, DbxFirebaseAuthImpersonationDelegate, DbxFirebaseAuthLoginService, DbxFirebaseAuthService, DbxFirebaseAuthServiceDelegate, DbxFirebaseCollectionChangeDirective, DbxFirebaseCollectionChangeTriggerInstance, DbxFirebaseCollectionHasChangeDirective, DbxFirebaseCollectionListDirective, DbxFirebaseCollectionLoaderInstance, DbxFirebaseCollectionStoreDirective, DbxFirebaseCollectionWithParentStoreDirective, DbxFirebaseDevelopmentDirective, DbxFirebaseDevelopmentModule, DbxFirebaseDevelopmentPopupComponent, DbxFirebaseDevelopmentPopupContentComponent, DbxFirebaseDevelopmentPopupContentForgeFormComponent, DbxFirebaseDevelopmentSchedulerListComponent, DbxFirebaseDevelopmentSchedulerListViewComponent, DbxFirebaseDevelopmentSchedulerListViewItemComponent, DbxFirebaseDevelopmentSchedulerService, DbxFirebaseDevelopmentSchedulerWidgetComponent, DbxFirebaseDevelopmentService, DbxFirebaseDevelopmentWidgetService, DbxFirebaseDocumentLoaderInstance, DbxFirebaseDocumentStoreContextModelEntitiesSourceDirective, DbxFirebaseDocumentStoreContextStore, DbxFirebaseDocumentStoreContextStoreDirective, DbxFirebaseDocumentStoreDirective, DbxFirebaseDocumentStoreIdFromTwoWayModelKeyDirective, DbxFirebaseDocumentStoreTwoWayKeyProvider, DbxFirebaseDocumentStoreTwoWayModelKeySourceDirective, DbxFirebaseEmailForgeFormComponent, DbxFirebaseEmailRecoveryForgeFormComponent, DbxFirebaseEmulatorService, DbxFirebaseLoginAnonymousComponent, DbxFirebaseLoginAppleComponent, DbxFirebaseLoginButtonComponent, DbxFirebaseLoginButtonContainerComponent, DbxFirebaseLoginComponent, DbxFirebaseLoginContext, DbxFirebaseLoginContextBackButtonComponent, DbxFirebaseLoginContextDirective, DbxFirebaseLoginEmailComponent, DbxFirebaseLoginEmailContentComponent, DbxFirebaseLoginFacebookComponent, DbxFirebaseLoginGitHubComponent, DbxFirebaseLoginGoogleComponent, DbxFirebaseLoginListComponent, DbxFirebaseLoginMicrosoftComponent, DbxFirebaseLoginTermsComponent, DbxFirebaseLoginTermsSimpleComponent, DbxFirebaseLoginTwitterComponent, DbxFirebaseManageAuthProvidersComponent, 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, DbxFirebasePasswordResetComponent, DbxFirebasePasswordResetFormComponent, DbxFirebaseRegisterComponent, DbxFirebaseRegisterEmailComponent, DbxFirebaseStorageFileCollectionStoreDirective, DbxFirebaseStorageFileDocumentStoreDirective, DbxFirebaseStorageFileDownloadButtonComponent, DbxFirebaseStorageFileDownloadService, DbxFirebaseStorageFileDownloadStorage, DbxFirebaseStorageFileGroupDocumentStoreDirective, DbxFirebaseStorageFileUploadActionHandlerDirective, DbxFirebaseStorageFileUploadInitializeDocumentDirective, DbxFirebaseStorageFileUploadModule, DbxFirebaseStorageFileUploadStore, DbxFirebaseStorageFileUploadStoreDirective, DbxFirebaseStorageFileUploadSyncDirective, DbxFirebaseStoragePdfMergeUploadSyncDirective, DbxFirebaseStorageService, DbxFirebaseSystemStateCollectionStoreDirective, DbxFirebaseSystemStateDocumentStoreDirective, DbxFirestoreContextService, DbxLimitedFirebaseDocumentLoaderInstance, FIREBASE_APP_CHECK_TOKEN, FIREBASE_APP_TOKEN, FIREBASE_AUTH_TOKEN, FIREBASE_FIRESTORE_TOKEN, FIREBASE_FUNCTIONS_TOKEN, FIREBASE_NOTIFICATION_ITEM_WIDGET_TYPE_PREFIX, FIREBASE_PROVIDER_ID_TO_LOGIN_METHOD_TYPE_MAP, FIREBASE_STORAGE_TOKEN, FlatFirestoreModelKeyPipe, IMPORTS_AND_EXPORTS, LOGIN_METHOD_TYPE_TO_FIREBASE_PROVIDER_ID_MAP, NotificationBoxCollectionStore, NotificationBoxDocumentStore, NotificationCollectionStore, NotificationDocumentStore, NotificationSummaryCollectionStore, NotificationSummaryDocumentStore, NotificationUserCollectionStore, NotificationUserDocumentStore, OAUTH_FIREBASE_LOGIN_METHOD_CATEGORY, StorageFileCollectionStore, StorageFileDocumentStore, StorageFileGroupDocumentStore, StorageFileUploadFilesError, SystemStateCollectionStore, SystemStateDocumentStore, TwoWayFlatFirestoreModelKeyPipe, authRolesObsWithClaimsService, authUserInfoFromAuthUser, authUserStateFromFirebaseAuthServiceFunction, createDbxFirebaseAppCheck, createDbxFirebaseAuth, createDbxFirebaseFirestore, createDbxFirebaseFunctions, createDbxFirebaseStorage, dbxFirebaseAuthContextInfo, dbxFirebaseCollectionChangeTrigger, dbxFirebaseCollectionChangeTriggerForStore, dbxFirebaseCollectionChangeTriggerForWatcher, dbxFirebaseCollectionChangeWatcher, dbxFirebaseCollectionLoaderInstance, dbxFirebaseCollectionLoaderInstanceWithCollection, dbxFirebaseDocumentLoaderInstance, dbxFirebaseDocumentLoaderInstanceWithAccessor, dbxFirebaseDocumentStoreContextModelEntitiesSourceFactory, dbxFirebaseIdRouteParamRedirect, dbxFirebaseInContextFirebaseModelServiceInstance, dbxFirebaseInContextFirebaseModelServiceInstanceFactory, dbxFirebaseKeyRouteParamRedirect, dbxFirebaseModelContextServiceInfoInstanceFactory, dbxFirebaseModelEntityWidgetInjectionConfigFactory, dbxFirebaseModelTypesServiceInstance, dbxFirebaseModelTypesServiceInstancePairForKeysFactory, dbxFirebaseSourceSelectLoadSource, dbxFirebaseStorageFileDownloadServiceCustomSourceFromObs, dbxFirebaseStorageFileImageCompressionFileModifier, dbxFirebaseStorageProvidersContextConfigFactory, dbxLimitedFirebaseDocumentLoaderInstance, dbxLimitedFirebaseDocumentLoaderInstanceWithAccessor, dbxWidgetTypeForNotificationTemplateType, defaultDbxFirebaseAuthServiceDelegateWithClaimsService, defaultDbxFirebaseStorageFileDownloadStorageAccessorFactory, developmentFirebaseServerSchedulerWidgetEntry, enableAppCheckDebugTokenGeneration, firebaseAuthState, firebaseAuthTokenFromUser, firebaseCollectionStoreCreateFunction, firebaseCollectionStoreCrudFunction, firebaseContextServiceEntityMap, firebaseDocumentStoreCreateFunction, firebaseDocumentStoreCrudFunction, firebaseDocumentStoreDeleteFunction, firebaseDocumentStoreInvokeFunction, firebaseDocumentStoreReadFunction, firebaseDocumentStoreUpdateFunction, firebaseIdToken, firebaseProviderIdToLoginMethodType, isDbxFirebaseModelEntityWithStore, isStandaloneWebApp, linkDocumentStoreToParentContextStores, loginMethodTypeToFirebaseProviderId, modelDoesNotExistError, parseDbxFirebaseEmulatorsConfig, provideDbxFirebase, provideDbxFirebaseAnalyticsUserEventsListenerService, provideDbxFirebaseApp, provideDbxFirebaseAuth, provideDbxFirebaseAuthImpersonation, provideDbxFirebaseCollectionStoreDirective, provideDbxFirebaseCollectionWithParentStoreDirective, provideDbxFirebaseDevelopment, provideDbxFirebaseDocumentStoreContextStore, provideDbxFirebaseDocumentStoreDirective, provideDbxFirebaseDocumentStoreTwoWayKeyProvider, provideDbxFirebaseFunctions, provideDbxFirebaseLogin, provideDbxFirebaseModelContextService, provideDbxFirebaseModelEntitiesWidgetService, provideDbxFirebaseNotifications, provideDbxFirebaseStorageFileService, provideDbxFirestoreCollection, provideNotificationFirestoreCollections, provideStorageFileFirestoreCollections, provideSystemStateFirestoreCollections, providedDbxFirebaseStorage, readDbxAnalyticsUserPropertiesFromAuthUserInfo, readValueFromIdToken, resolveDbxFirebaseAuthFlow, setParentStoreEffect, stateFromTokenForLoggedInUserFunction, storageFileUploadFiles, storageFileUploadHandler };
-export type { AuthRolesObsWithClaimsServiceConfig, AuthUserInfo, AuthUserStateObsFunction, CreateDbxFirebaseAppCheckParams, CreateDbxFirebaseAuthParams, CreateDbxFirebaseFirestoreParams, CreateDbxFirebaseFunctionsParams, CreateDbxFirebaseStorageParams, DbxFirebaseAnalyticsUserPropertiesFactory, DbxFirebaseAppCheckConfig, DbxFirebaseAppOptions, DbxFirebaseAuthContextInfo, DbxFirebaseAuthFlow, DbxFirebaseAuthLoginPasswordConfig, DbxFirebaseAuthLoginProvider, DbxFirebaseAuthLoginProviderAssets, DbxFirebaseCollectionChangeTrigger, DbxFirebaseCollectionChangeTriggerFunction, DbxFirebaseCollectionChangeTriggerInstanceConfig, DbxFirebaseCollectionChangeWatcher, DbxFirebaseCollectionChangeWatcherEvent, DbxFirebaseCollectionChangeWatcherInstance, DbxFirebaseCollectionChangeWatcherTriggerMode, DbxFirebaseCollectionHasChangeDirectiveMode, DbxFirebaseCollectionLoader, DbxFirebaseCollectionLoaderAccessor, DbxFirebaseCollectionLoaderAccessorWithAccumulator, DbxFirebaseCollectionLoaderInstanceData, DbxFirebaseCollectionLoaderInstanceInitConfig, DbxFirebaseCollectionLoaderWithAccumulator, DbxFirebaseCollectionMode, DbxFirebaseCollectionStore, DbxFirebaseCollectionStoreContextState, DbxFirebaseCollectionStoreCreateFunction, DbxFirebaseCollectionStoreCrudFunction, DbxFirebaseCollectionWithParentStore, DbxFirebaseCollectionWithParentStoreContextState, DbxFirebaseCompletePasswordResetInput, 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, DbxFirebaseLoginButtonInjectionData, 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, DbxFirebasePasswordResetFormConfig, DbxFirebasePasswordResetFormValue, DbxFirebaseResolvedAuthFlow, DbxFirebaseSourceSelectLoadSourceConfig, DbxFirebaseStorageContextConfigFactory, DbxFirebaseStorageFileDownloadButtonConfig, DbxFirebaseStorageFileDownloadButtonSource, DbxFirebaseStorageFileDownloadDetails, DbxFirebaseStorageFileDownloadServiceCustomSource, DbxFirebaseStorageFileDownloadServiceCustomSourceDownloadFunction, DbxFirebaseStorageFileDownloadUrlPair, DbxFirebaseStorageFileDownloadUrlPairString, DbxFirebaseStorageFileDownloadUrlPairsRecord, DbxFirebaseStorageFileDownloadUserCache, DbxFirebaseStorageFileImageCompressionFileModifierConfig, DbxFirebaseStorageFileImageCompressionLogger, DbxFirebaseStorageFileUploadFileModifier, DbxFirebaseStorageFileUploadStoreAllowedTypes, DbxFirebaseStorageFileUploadStoreFileProgress, DbxFirebaseStorageFileUploadStoreState, DbxFirebaseStorageFileUploadStoreUploadStage, DbxLimitedFirebaseDocumentLoader, DefaultDbxFirebaseAuthServiceDelegateWithClaimsServiceConfig, FirebaseDocumentStoreFunctionConfig, FirebaseLoginMethodCategory, FirebaseLoginMethodType, KnownFirebaseLoginMethodCategory, KnownFirebaseLoginMethodType, NotificationItemWithSelection, ProvideDbxFirebaseAppConfig, ProvideDbxFirebaseAuthConfig, ProvideDbxFirebaseAuthImpersonationConfig, ProvideDbxFirebaseConfig, ProvideDbxFirebaseDevelopmentConfig, ProvideDbxFirebaseFirestoreCollectionConfig, ProvideDbxFirebaseFunctionsConfig, ProvideDbxFirebaseLoginConfig, ProvideDbxFirebaseModelContextServiceConfig, ProvideDbxFirebaseModelEntitiesWidgetServiceConfig, ProvideDbxFirebaseNotificationsConfig, ProvideDbxFirebaseStorageConfig, ScheduledFunctionDevelopmentFirebaseFunctionListEntryWithSelection, StateFromTokenFunction, StorageFileUploadConfig, StorageFileUploadConfigFactory, StorageFileUploadConfigOptions, StorageFileUploadFilesEvent, StorageFileUploadFilesFinalFileResult, StorageFileUploadFilesFinalResult, StorageFileUploadFilesInput, StorageFileUploadFilesInstance, StorageFileUploadHandler, StorageFileUploadHandlerConfig, StorageFileUploadHandlerFunction, StorageFileUploadHandlerInstance };
+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_AUTH_FLOW_TOKEN, DBX_FIREBASE_DOCUMENT_STORE_CONTEXT_STORE_TOKEN, DBX_FIREBASE_EXTERNAL_CONNECTION_CALCOM_PROVIDER, DBX_FIREBASE_EXTERNAL_CONNECTION_DISCORD_PROVIDER, DBX_FIREBASE_EXTERNAL_CONNECTION_ZOHO_PROVIDER, DBX_FIREBASE_EXTERNAL_CONNECTION_ZOOM_PROVIDER, DBX_FIREBASE_KNOWN_EXTERNAL_CONNECTION_PROVIDERS, 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_FIREBASE_STORAGE_PDF_MERGE_UPLOAD_FILE_NAME, DBX_FIRESTORE_CONTEXT_TOKEN, DEFAULT_CONFIGURED_DBX_FIREBASE_LOGIN_BUTTON_TEMPLATE, DEFAULT_DBX_FIREBASE_ANALYTICS_USER_PROPERTIES_FACTORY, DEFAULT_DBX_FIREBASE_AUTH_FLOW, DEFAULT_DBX_FIREBASE_AUTH_SERVICE_DELEGATE, DEFAULT_DBX_FIREBASE_ID_ROUTER_PARAM_ID_PARAM_KEY, DEFAULT_DBX_FIREBASE_ID_ROUTER_PARAM_KEY_PARAM_KEY, DEFAULT_DBX_FIREBASE_ID_ROUTER_PARAM_USE_PARAM_VALUE, 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_EXTERNAL_CONNECTION_AUTHORIZE_PATH_FACTORY, DEFAULT_EXTERNAL_CONNECTION_NAVIGATE_FUNCTION, DEFAULT_EXTERNAL_CONNECTION_NAVIGATE_TIMEOUT, 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, DEFAULT_NOTIFICATION_HEALTH_CHECK_PRESENTATION_ENTRIES, DEFAULT_NOTIFICATION_HEALTH_CHECK_PROBE_WATCH_MINUTES, DEVELOPMENT_FIREBASE_SERVER_SCHEDULER_WIDGET_KEY, DbxFirebaseAnalyticsUserEventsListenerService, DbxFirebaseAnalyticsUserSource, DbxFirebaseAppCheckHttpInterceptor, DbxFirebaseAuthImpersonationDelegate, DbxFirebaseAuthLoginService, DbxFirebaseAuthService, DbxFirebaseAuthServiceDelegate, DbxFirebaseCollectionChangeDirective, DbxFirebaseCollectionChangeTriggerInstance, DbxFirebaseCollectionHasChangeDirective, DbxFirebaseCollectionListDirective, DbxFirebaseCollectionLoaderInstance, DbxFirebaseCollectionStoreDirective, DbxFirebaseCollectionWithParentStoreDirective, DbxFirebaseDevelopmentDirective, DbxFirebaseDevelopmentModule, DbxFirebaseDevelopmentPopupComponent, DbxFirebaseDevelopmentPopupContentComponent, DbxFirebaseDevelopmentPopupContentForgeFormComponent, DbxFirebaseDevelopmentSchedulerListComponent, DbxFirebaseDevelopmentSchedulerListViewComponent, DbxFirebaseDevelopmentSchedulerListViewItemComponent, DbxFirebaseDevelopmentSchedulerService, DbxFirebaseDevelopmentSchedulerWidgetComponent, DbxFirebaseDevelopmentService, DbxFirebaseDevelopmentWidgetService, DbxFirebaseDocumentLoaderInstance, DbxFirebaseDocumentStoreContextModelEntitiesSourceDirective, DbxFirebaseDocumentStoreContextStore, DbxFirebaseDocumentStoreContextStoreDirective, DbxFirebaseDocumentStoreDirective, DbxFirebaseDocumentStoreIdFromTwoWayModelKeyDirective, DbxFirebaseDocumentStoreTwoWayKeyProvider, DbxFirebaseDocumentStoreTwoWayModelKeySourceDirective, DbxFirebaseEmailForgeFormComponent, DbxFirebaseEmailRecoveryForgeFormComponent, DbxFirebaseEmulatorService, DbxFirebaseExternalConnectionListComponent, DbxFirebaseExternalConnectionListViewComponent, DbxFirebaseExternalConnectionListViewItemComponent, DbxFirebaseExternalConnectionService, DbxFirebaseExternalConnectionsComponent, DbxFirebaseExternalConnectionsConfig, DbxFirebaseLoginAnonymousComponent, DbxFirebaseLoginAppleComponent, DbxFirebaseLoginButtonComponent, DbxFirebaseLoginButtonContainerComponent, DbxFirebaseLoginComponent, DbxFirebaseLoginContext, DbxFirebaseLoginContextBackButtonComponent, DbxFirebaseLoginContextDirective, DbxFirebaseLoginEmailComponent, DbxFirebaseLoginEmailContentComponent, DbxFirebaseLoginFacebookComponent, DbxFirebaseLoginGitHubComponent, DbxFirebaseLoginGoogleComponent, DbxFirebaseLoginListComponent, DbxFirebaseLoginMicrosoftComponent, DbxFirebaseLoginTermsComponent, DbxFirebaseLoginTermsSimpleComponent, DbxFirebaseLoginTwitterComponent, DbxFirebaseManageAuthProvidersComponent, 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, DbxFirebaseNotificationHealthCheckComponent, DbxFirebaseNotificationHealthCheckConfig, DbxFirebaseNotificationHealthCheckDialogButtonComponent, DbxFirebaseNotificationHealthCheckDialogComponent, DbxFirebaseNotificationHealthCheckIssueComponent, DbxFirebaseNotificationHealthCheckMethodComponent, DbxFirebaseNotificationHealthCheckPresentationService, DbxFirebaseNotificationHealthCheckPresentationServiceConfig, DbxFirebaseNotificationHealthCheckViewComponent, DbxFirebaseNotificationItemContentComponent, DbxFirebaseNotificationItemDefaultViewComponent, DbxFirebaseNotificationItemListComponent, DbxFirebaseNotificationItemListViewComponent, DbxFirebaseNotificationItemListViewItemComponent, DbxFirebaseNotificationItemStore, DbxFirebaseNotificationItemStorePopoverButtonComponent, DbxFirebaseNotificationItemStorePopoverComponent, DbxFirebaseNotificationItemViewComponent, DbxFirebaseNotificationItemWidgetService, DbxFirebaseNotificationSummaryCollectionStoreDirective, DbxFirebaseNotificationSummaryDocumentStoreDirective, DbxFirebaseNotificationTemplateService, DbxFirebaseNotificationUserCollectionStoreDirective, DbxFirebaseNotificationUserDocumentStoreDirective, DbxFirebaseNotificationUserHealthCheckStore, DbxFirebaseParsedEmulatorsConfig, DbxFirebasePasswordResetComponent, DbxFirebasePasswordResetFormComponent, DbxFirebaseRegisterComponent, DbxFirebaseRegisterEmailComponent, DbxFirebaseStorageFileCollectionStoreDirective, DbxFirebaseStorageFileDocumentStoreDirective, DbxFirebaseStorageFileDownloadButtonComponent, DbxFirebaseStorageFileDownloadService, DbxFirebaseStorageFileDownloadStorage, DbxFirebaseStorageFileGroupDocumentStoreDirective, DbxFirebaseStorageFileUploadActionHandlerDirective, DbxFirebaseStorageFileUploadInitializeDocumentDirective, DbxFirebaseStorageFileUploadModule, DbxFirebaseStorageFileUploadStore, DbxFirebaseStorageFileUploadStoreDirective, DbxFirebaseStorageFileUploadSyncDirective, DbxFirebaseStoragePdfMergeUploadSyncDirective, DbxFirebaseStorageService, DbxFirebaseSystemStateCollectionStoreDirective, DbxFirebaseSystemStateDocumentStoreDirective, DbxFirebaseUserExternalConnectionCollections, DbxFirebaseUserExternalConnectionDocumentStoreDirective, DbxFirebaseUserExternalConnectionsStore, DbxFirestoreContextService, DbxLimitedFirebaseDocumentLoaderInstance, FIREBASE_APP_CHECK_TOKEN, FIREBASE_APP_TOKEN, FIREBASE_AUTH_TOKEN, FIREBASE_FIRESTORE_TOKEN, FIREBASE_FUNCTIONS_TOKEN, FIREBASE_NOTIFICATION_ITEM_WIDGET_TYPE_PREFIX, FIREBASE_PROVIDER_ID_TO_LOGIN_METHOD_TYPE_MAP, FIREBASE_STORAGE_TOKEN, FlatFirestoreModelKeyPipe, IMPORTS_AND_EXPORTS, LOGIN_METHOD_TYPE_TO_FIREBASE_PROVIDER_ID_MAP, NOTIFICATION_DELIVERY_METHOD_ICONS, NOTIFICATION_DELIVERY_METHOD_LABELS, NOTIFICATION_DELIVERY_METHOD_SHORT_LABELS, NOTIFICATION_DELIVERY_METHOD_TEST_MESSAGE_LABELS, NOTIFICATION_DELIVERY_METHOD_TEST_MESSAGE_NOUNS, NOTIFICATION_HEALTH_CHECK_PROBE_ISSUE_OUTCOMES, NOTIFICATION_HEALTH_CHECK_STATUS_COLORS, NOTIFICATION_HEALTH_CHECK_STATUS_ICONS, NOTIFICATION_HEALTH_CHECK_STATUS_LABELS, NotificationBoxCollectionStore, NotificationBoxDocumentStore, NotificationCollectionStore, NotificationDocumentStore, NotificationSummaryCollectionStore, NotificationSummaryDocumentStore, NotificationUserCollectionStore, NotificationUserDocumentStore, OAUTH_FIREBASE_LOGIN_METHOD_CATEGORY, StorageFileCollectionStore, StorageFileDocumentStore, StorageFileGroupDocumentStore, StorageFileUploadFilesError, SystemStateCollectionStore, SystemStateDocumentStore, TwoWayFlatFirestoreModelKeyPipe, UserExternalConnectionDocumentStore, authRolesObsWithClaimsService, authUserInfoFromAuthUser, authUserStateFromFirebaseAuthServiceFunction, createDbxFirebaseAppCheck, createDbxFirebaseAuth, createDbxFirebaseFirestore, createDbxFirebaseFunctions, createDbxFirebaseStorage, dbxFirebaseAuthContextInfo, dbxFirebaseCollectionChangeTrigger, dbxFirebaseCollectionChangeTriggerForStore, dbxFirebaseCollectionChangeTriggerForWatcher, dbxFirebaseCollectionChangeWatcher, dbxFirebaseCollectionLoaderInstance, dbxFirebaseCollectionLoaderInstanceWithCollection, dbxFirebaseDocumentLoaderInstance, dbxFirebaseDocumentLoaderInstanceWithAccessor, dbxFirebaseDocumentStoreContextModelEntitiesSourceFactory, dbxFirebaseExternalConnectionProviderForEntry, dbxFirebaseExternalConnectionRowStatusForEntry, dbxFirebaseExternalConnectionRows, dbxFirebaseIdRouteParamRedirect, dbxFirebaseInContextFirebaseModelServiceInstance, dbxFirebaseInContextFirebaseModelServiceInstanceFactory, dbxFirebaseKeyRouteParamRedirect, dbxFirebaseKnownExternalConnectionProvider, dbxFirebaseModelContextServiceInfoInstanceFactory, dbxFirebaseModelEntityWidgetInjectionConfigFactory, dbxFirebaseModelTypesServiceInstance, dbxFirebaseModelTypesServiceInstancePairForKeysFactory, dbxFirebaseSourceSelectLoadSource, dbxFirebaseStorageFileDownloadServiceCustomSourceFromObs, dbxFirebaseStorageFileImageCompressionFileModifier, dbxFirebaseStorageProvidersContextConfigFactory, dbxLimitedFirebaseDocumentLoaderInstance, dbxLimitedFirebaseDocumentLoaderInstanceWithAccessor, dbxWidgetTypeForNotificationTemplateType, defaultDbxFirebaseAuthServiceDelegateWithClaimsService, defaultDbxFirebaseStorageFileDownloadStorageAccessorFactory, developmentFirebaseServerSchedulerWidgetEntry, enableAppCheckDebugTokenGeneration, externalConnectionsLoadingStateFromDocumentLoadingState, firebaseAuthState, firebaseAuthTokenFromUser, firebaseCollectionStoreCreateFunction, firebaseCollectionStoreCrudFunction, firebaseContextServiceEntityMap, firebaseDocumentStoreCreateFunction, firebaseDocumentStoreCrudFunction, firebaseDocumentStoreDeleteFunction, firebaseDocumentStoreInvokeFunction, firebaseDocumentStoreReadFunction, firebaseDocumentStoreUpdateFunction, firebaseIdToken, firebaseProviderIdToLoginMethodType, isDbxFirebaseModelEntityWithStore, isStandaloneWebApp, linkDocumentStoreToParentContextStores, loginMethodTypeToFirebaseProviderId, modelDoesNotExistError, navigateAndWaitForPageToLeave, notificationHealthCheckProbeIssueLabel, parseDbxFirebaseEmulatorsConfig, provideDbxFirebase, provideDbxFirebaseAnalyticsUserEventsListenerService, provideDbxFirebaseApp, provideDbxFirebaseAuth, provideDbxFirebaseAuthImpersonation, provideDbxFirebaseCollectionStoreDirective, provideDbxFirebaseCollectionWithParentStoreDirective, provideDbxFirebaseDevelopment, provideDbxFirebaseDocumentStoreContextStore, provideDbxFirebaseDocumentStoreDirective, provideDbxFirebaseDocumentStoreTwoWayKeyProvider, provideDbxFirebaseExternalConnections, provideDbxFirebaseFunctions, provideDbxFirebaseLogin, provideDbxFirebaseModelContextService, provideDbxFirebaseModelEntitiesWidgetService, provideDbxFirebaseNotifications, provideDbxFirebaseStorageFileService, provideDbxFirestoreCollection, provideNotificationFirestoreCollections, provideStorageFileFirestoreCollections, provideSystemStateFirestoreCollections, providedDbxFirebaseStorage, readDbxAnalyticsUserPropertiesFromAuthUserInfo, readValueFromIdToken, resolveDbxFirebaseAuthFlow, setParentStoreEffect, shouldCreateUserExternalConnectionForDocumentLoadingState, stateFromTokenForLoggedInUserFunction, storageFileUploadFiles, storageFileUploadHandler };
+export type { AuthRolesObsWithClaimsServiceConfig, AuthUserInfo, AuthUserStateObsFunction, CreateDbxFirebaseAppCheckParams, CreateDbxFirebaseAuthParams, CreateDbxFirebaseFirestoreParams, CreateDbxFirebaseFunctionsParams, CreateDbxFirebaseStorageParams, DbxFirebaseAnalyticsUserPropertiesFactory, DbxFirebaseAppCheckConfig, DbxFirebaseAppOptions, DbxFirebaseAuthContextInfo, DbxFirebaseAuthFlow, DbxFirebaseAuthLoginPasswordConfig, DbxFirebaseAuthLoginProvider, DbxFirebaseAuthLoginProviderAssets, DbxFirebaseCollectionChangeTrigger, DbxFirebaseCollectionChangeTriggerFunction, DbxFirebaseCollectionChangeTriggerInstanceConfig, DbxFirebaseCollectionChangeWatcher, DbxFirebaseCollectionChangeWatcherEvent, DbxFirebaseCollectionChangeWatcherInstance, DbxFirebaseCollectionChangeWatcherTriggerMode, DbxFirebaseCollectionHasChangeDirectiveMode, DbxFirebaseCollectionLoader, DbxFirebaseCollectionLoaderAccessor, DbxFirebaseCollectionLoaderAccessorWithAccumulator, DbxFirebaseCollectionLoaderInstanceData, DbxFirebaseCollectionLoaderInstanceInitConfig, DbxFirebaseCollectionLoaderWithAccumulator, DbxFirebaseCollectionMode, DbxFirebaseCollectionStore, DbxFirebaseCollectionStoreContextState, DbxFirebaseCollectionStoreCreateFunction, DbxFirebaseCollectionStoreCrudFunction, DbxFirebaseCollectionWithParentStore, DbxFirebaseCollectionWithParentStoreContextState, DbxFirebaseCompletePasswordResetInput, 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, DbxFirebaseExternalConnectionActionConfig, DbxFirebaseExternalConnectionAuthorizeState, DbxFirebaseExternalConnectionConnectContext, DbxFirebaseExternalConnectionConnectFunction, DbxFirebaseExternalConnectionListItem, DbxFirebaseExternalConnectionListItemValue, DbxFirebaseExternalConnectionMintAuthorizeStateFunction, DbxFirebaseExternalConnectionNavigateFunction, DbxFirebaseExternalConnectionProvider, DbxFirebaseExternalConnectionProviderAssets, DbxFirebaseExternalConnectionProviderEntry, DbxFirebaseExternalConnectionRow, DbxFirebaseExternalConnectionRowStatus, DbxFirebaseExternalConnectionRowsInput, DbxFirebaseIdRouteParamRedirect, DbxFirebaseIdRouteParamRedirectInstance, DbxFirebaseInContextFirebaseModelInfoServiceInstance, DbxFirebaseInContextFirebaseModelRolesServiceInstance, DbxFirebaseInContextFirebaseModelServiceInstance, DbxFirebaseInContextFirebaseModelServiceInstanceFactory, DbxFirebaseKnownExternalConnectionProviderConfig, DbxFirebaseLoginButtonConfig, DbxFirebaseLoginButtonInjectionData, 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, DbxFirebaseNotificationHealthCheckDialogButtonComponentConfig, DbxFirebaseNotificationHealthCheckDialogComponentConfig, DbxFirebaseNotificationHealthCheckIssuePresentation, DbxFirebaseNotificationHealthCheckMethodProbeActionConfig, DbxFirebaseNotificationHealthCheckPresentationEntry, DbxFirebaseNotificationHealthCheckProbeActionMap, DbxFirebaseNotificationItemStorePopoverButtonConfig, DbxFirebaseNotificationItemStorePopoverParams, DbxFirebaseNotificationItemStoreState, DbxFirebaseNotificationItemWidgetEntry, DbxFirebaseNotificationItemWidgetEntryRegistration, DbxFirebaseNotificationUserHealthCheckProbeVerification, DbxFirebaseNotificationUserHealthCheckRunParams, DbxFirebaseNotificationUserHealthCheckStoreState, DbxFirebasePasswordResetFormConfig, DbxFirebasePasswordResetFormValue, DbxFirebaseResolvedAuthFlow, DbxFirebaseSourceSelectLoadSourceConfig, DbxFirebaseStorageContextConfigFactory, DbxFirebaseStorageFileDownloadButtonConfig, DbxFirebaseStorageFileDownloadButtonSource, DbxFirebaseStorageFileDownloadDetails, DbxFirebaseStorageFileDownloadServiceCustomSource, DbxFirebaseStorageFileDownloadServiceCustomSourceDownloadFunction, DbxFirebaseStorageFileDownloadUrlPair, DbxFirebaseStorageFileDownloadUrlPairString, DbxFirebaseStorageFileDownloadUrlPairsRecord, DbxFirebaseStorageFileDownloadUserCache, DbxFirebaseStorageFileImageCompressionFileModifierConfig, DbxFirebaseStorageFileImageCompressionLogger, DbxFirebaseStorageFileUploadFileModifier, DbxFirebaseStorageFileUploadStoreAllowedTypes, DbxFirebaseStorageFileUploadStoreFileProgress, DbxFirebaseStorageFileUploadStoreState, DbxFirebaseStorageFileUploadStoreUploadStage, DbxLimitedFirebaseDocumentLoader, DefaultDbxFirebaseAuthServiceDelegateWithClaimsServiceConfig, FirebaseDocumentStoreFunctionConfig, FirebaseLoginMethodCategory, FirebaseLoginMethodType, KnownFirebaseLoginMethodCategory, KnownFirebaseLoginMethodType, NotificationItemWithSelection, ProvideDbxFirebaseAppConfig, ProvideDbxFirebaseAuthConfig, ProvideDbxFirebaseAuthImpersonationConfig, ProvideDbxFirebaseConfig, ProvideDbxFirebaseDevelopmentConfig, ProvideDbxFirebaseExternalConnectionsConfig, ProvideDbxFirebaseFirestoreCollectionConfig, ProvideDbxFirebaseFunctionsConfig, ProvideDbxFirebaseLoginConfig, ProvideDbxFirebaseModelContextServiceConfig, ProvideDbxFirebaseModelEntitiesWidgetServiceConfig, ProvideDbxFirebaseNotificationsConfig, ProvideDbxFirebaseStorageConfig, ScheduledFunctionDevelopmentFirebaseFunctionListEntryWithSelection, StateFromTokenFunction, StorageFileUploadConfig, StorageFileUploadConfigFactory, StorageFileUploadConfigOptions, StorageFileUploadFilesEvent, StorageFileUploadFilesFinalFileResult, StorageFileUploadFilesFinalResult, StorageFileUploadFilesInput, StorageFileUploadFilesInstance, StorageFileUploadHandler, StorageFileUploadHandlerConfig, StorageFileUploadHandlerFunction, StorageFileUploadHandlerInstance };