@dereekb/dbx-firebase 13.31.0 → 13.33.0

package/fesm2022/dereekb-dbx-firebase.mjs

@@ -1,25 +1,25 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, inject, Injectable, provideAppInitializer, makeEnvironmentProviders, Component, model, computed, ChangeDetectionStrategy, signal, Directive, EventEmitter, input, output, Injector, viewChild, HostListener, NgModule, ElementRef, forwardRef, effect, DestroyRef, Inject, Optional, Pipe } from '@angular/core';
 import { DbxAnalyticsService } from '@dereekb/dbx-analytics';
-import { asObservable, timeoutStartWith, filterMaybe, isNot, SubscriptionObject, lazyFrom, switchMapWhileTrue, loadingStateFromObs, distinctUntilKeysChange, cleanupDestroyable, iterationHasNextAndCanLoadMore, pageItemAccumulatorCurrentPage, accumulatorFlattenPageListLoadingState, useFirst, itemAccumulatorNextPageUntilResultsCount, iteratorNextPageUntilPage, iteratorNextPageUntilMaxPageLoadLimit, pageLoadingStateFromObs, useAsObservable, filterMaybeArray, mapEachAsync, invertObservableDecision, filterItemsWithObservableDecision, switchMapMaybe, beginLoading, mapLoadingStateValueWithOperator, valueFromFinishedLoadingState, skipInitialMaybe, distinctUntilModelKeyChange, successResult, errorResult, isLoadingStateLoading, cleanup, mapLoadingState, throwErrorFromLoadingStateError, maybeValueFromObservableOrValue, distinctUntilHasDifferentValues, MultiSubscriptionObject, startWithBeginLoading, skipAllInitialMaybe } from '@dereekb/rxjs';
-import { Observable, switchMap, of, shareReplay, map, Subject, merge, distinctUntilChanged, EMPTY, catchError, firstValueFrom, tap, BehaviorSubject, combineLatest, first, from, interval, exhaustMap, filter, take, startWith, throttleTime, NEVER, defaultIfEmpty, combineLatestWith, mergeMap } from 'rxjs';
+import { asObservable, timeoutStartWith, filterMaybe, isNot, SubscriptionObject, lazyFrom, switchMapWhileTrue, loadingStateFromObs, distinctUntilKeysChange, cleanupDestroyable, iterationHasNextAndCanLoadMore, pageItemAccumulatorCurrentPage, accumulatorFlattenPageListLoadingState, useFirst, itemAccumulatorNextPageUntilResultsCount, iteratorNextPageUntilPage, iteratorNextPageUntilMaxPageLoadLimit, pageLoadingStateFromObs, useAsObservable, filterMaybeArray, mapEachAsync, invertObservableDecision, filterItemsWithObservableDecision, switchMapMaybe, beginLoading, mapLoadingStateValueWithOperator, valueFromFinishedLoadingState, skipInitialMaybe, distinctUntilModelKeyChange, successResult, errorResult, isLoadingStateLoading, cleanup, mapLoadingState, startWithBeginLoading, throwErrorFromLoadingStateError, maybeValueFromObservableOrValue, distinctUntilHasDifferentValues, MultiSubscriptionObject, skipAllInitialMaybe } from '@dereekb/rxjs';
+import { Observable, switchMap, of, shareReplay, map, Subject, merge, distinctUntilChanged, EMPTY, catchError, firstValueFrom, tap, BehaviorSubject, combineLatest, first, from, interval, exhaustMap, filter, take, startWith, throttleTime, NEVER, defaultIfEmpty, combineLatestWith, timer, takeWhile, withLatestFrom, mergeMap } from 'rxjs';
 import * as i2 from '@dereekb/dbx-core';
-import { loggedInObsFromIsLoggedIn, loggedOutObsFromIsLoggedIn, authUserIdentifier, DbxInjectionContext, DBX_INJECTION_COMPONENT_DATA, DbxInjectionComponent, AbstractForwardDbxInjectionContextDirective, DbxInjectionContextDirective, DbxAuthImpersonationDelegate, DbxAuthService, provideDbxAuthImpersonation, DbxActionButtonDirective, completeOnDestroy, cleanSubscription, DbxActionDirective, DbxActionEnforceModifiedDirective, DbxActionHandlerDirective, DbxActionAutoTriggerDirective, clean, cleanLoadingContext, provideDbxRouteModelIdDirectiveDelegate, provideDbxRouteModelKeyDirectiveDelegate, AbstractIfDirective, LockSetComponentStore, newWithInjector, CutTextPipe, DbxActionContextStoreSourceInstance, DbxActionHandlerInstance, cleanSubscriptionWithLockSet, DbxButton, SimpleStorageAccessorFactory, dbxRouteParamReaderInstance, DbxRouteParamDefaultRedirectInstance } from '@dereekb/dbx-core';
+import { loggedInObsFromIsLoggedIn, loggedOutObsFromIsLoggedIn, authUserIdentifier, DbxInjectionContext, DBX_INJECTION_COMPONENT_DATA, DbxInjectionComponent, AbstractForwardDbxInjectionContextDirective, DbxInjectionContextDirective, DbxAuthImpersonationDelegate, DbxAuthService, provideDbxAuthImpersonation, DbxActionButtonDirective, completeOnDestroy, cleanSubscription, DbxActionDirective, DbxActionEnforceModifiedDirective, DbxActionHandlerDirective, DbxActionAutoTriggerDirective, clean, cleanLoadingContext, provideDbxRouteModelIdDirectiveDelegate, provideDbxRouteModelKeyDirectiveDelegate, AbstractIfDirective, LockSetComponentStore, newWithInjector, DbxActionDisabledDirective, CutTextPipe, DbxActionValueDirective, DbxActionContextStoreSourceInstance, DbxActionHandlerInstance, cleanSubscriptionWithLockSet, DbxButton, SimpleStorageAccessorFactory, dbxRouteParamReaderInstance, DbxRouteParamDefaultRedirectInstance } from '@dereekb/dbx-core';
 import { onAuthStateChanged, onIdTokenChanged, confirmPasswordReset, sendPasswordResetEmail, signInWithPopup, signInWithRedirect, linkWithPopup, linkWithRedirect, linkWithCredential, unlink, createUserWithEmailAndPassword, signInWithEmailAndPassword, signInAnonymously, reauthenticateWithPopup, reauthenticateWithRedirect, getRedirectResult, OAuthProvider, FacebookAuthProvider, GithubAuthProvider, GoogleAuthProvider, TwitterAuthProvider, getAuth, connectAuthEmulator } from 'firebase/auth';
-import { AUTH_ADMIN_ROLE, cachedGetter, urlWithoutParameters, addToSet, removeFromSet, filterMaybeArrayValues, mapIterable, asArray, excludeValuesFromArray, containsStringAnyCase, addToSetCopy, iterableToArray, runAsyncTasksForValues, forEachKeyValue, countAllInNestedArray, invertDecision, useIterableOrValue, filterUniqueValues, reverseCompareFn, sortByNumberFunction, separateValues, readableError, isMaybeSo, firstValue, splitJoinRemainder, MS_IN_HOUR, SECONDS_IN_MINUTE, MS_IN_DAY, unixDateTimeSecondsNumberForNow, MS_IN_MINUTE, addMilliseconds, unixDateTimeSecondsNumberFromDate, dateFromDateOrTimeSecondsNumber, MS_IN_SECOND, isPast } from '@dereekb/util';
+import { AUTH_ADMIN_ROLE, cachedGetter, urlWithoutParameters, addToSet, removeFromSet, filterMaybeArrayValues, mapIterable, asArray, excludeValuesFromArray, containsStringAnyCase, addToSetCopy, iterableToArray, runAsyncTasksForValues, forEachKeyValue, countAllInNestedArray, invertDecision, useIterableOrValue, filterUniqueValues, reverseCompareFn, sortByNumberFunction, separateValues, readableError, isMaybeSo, firstValue, fixExtraQueryParameters, areEqualPOJOValues, MS_IN_SECOND, splitJoinRemainder, MS_IN_HOUR, SECONDS_IN_MINUTE, MS_IN_DAY, unixDateTimeSecondsNumberForNow, MS_IN_MINUTE, addMilliseconds, unixDateTimeSecondsNumberFromDate, dateFromDateOrTimeSecondsNumber, isPast } from '@dereekb/util';
 import { safeFormatToISO8601DateString, msToSeconds, isSameDate } from '@dereekb/date';
 import { getToken, initializeAppCheck, ReCaptchaV3Provider } from 'firebase/app-check';
 import * as i1$1 from '@dereekb/dbx-web';
-import { DbxLinkComponent, DbxActionModule, DbxButtonModule, DbxErrorComponent, DbxActionErrorDirective, DbxButtonComponent, DbxButtonSpacerDirective, DbxRouterAnchorModule, DbxSectionComponent, DbxWidgetService, AbstractDbxSelectionListWrapperDirective, DbxListWrapperComponentImportsModule, provideDbxListViewWrapper, DEFAULT_LIST_WRAPPER_COMPONENT_CONFIGURATION_TEMPLATE, AbstractDbxSelectionListViewDirective, DbxSelectionValueListViewComponentImportsModule, provideDbxListView, DEFAULT_DBX_SELECTION_VALUE_LIST_COMPONENT_CONFIGURATION_TEMPLATE, AbstractDbxValueListViewItemComponent, TwoColumnsContextStore, DbxAnchorComponent, DbxTwoColumnFullLeftDirective, DbxWidgetViewComponent, DbxTwoColumnComponent, DbxTwoBlockComponent, DbxTwoColumnRightComponent, AbstractPopupDirective, DbxPopupService, DbxPopupContentComponent, DbxPopupControlsComponent, DbxModelTypesService, DbxModelTrackerService, allDbxModelViewTrackerEventModelKeys, DbxListItemAnchorModifierDirective, DbxValueListItemModifierDirective, AbstractPopoverDirective, DbxPopoverContentComponent, DbxPopoverHeaderComponent, DbxPopoverScrollContentDirective, DbxListEmptyContentComponent, AbstractPopoverRefDirective, DbxPopoverService, DbxLoadingComponent, DbxDetailBlockComponent, DbxClickToCopyTextComponent, DbxDownloadTextViewComponent, DbxModelObjectStateService, DbxListViewWrapper, AbstractDbxWidgetComponent, DbxPopoverInteractionModule, DbxListModifierModule, DbxWebFilePreviewService, DbxActionSnackbarErrorDirective, DbxActionDialogDirective, compressImageFile, DbxFileUploadComponent, DbxPdfMergeEditorStore, PDF_MERGE_RESULT_MIME_TYPE, DbxActionLoadingContextDirective, DbxFileUploadActionSyncDirective } from '@dereekb/dbx-web';
+import { DbxLinkComponent, DbxActionModule, DbxButtonModule, DbxErrorComponent, DbxActionErrorDirective, DbxButtonComponent, DbxButtonSpacerDirective, DbxRouterAnchorModule, DbxSectionComponent, DbxWidgetService, AbstractDbxSelectionListWrapperDirective, DbxListWrapperComponentImportsModule, provideDbxListViewWrapper, DEFAULT_LIST_WRAPPER_COMPONENT_CONFIGURATION_TEMPLATE, AbstractDbxSelectionListViewDirective, DbxSelectionValueListViewComponentImportsModule, provideDbxListView, DEFAULT_DBX_SELECTION_VALUE_LIST_COMPONENT_CONFIGURATION_TEMPLATE, AbstractDbxValueListViewItemComponent, TwoColumnsContextStore, DbxAnchorComponent, DbxTwoColumnFullLeftDirective, DbxWidgetViewComponent, DbxTwoColumnComponent, DbxTwoBlockComponent, DbxTwoColumnRightComponent, AbstractPopupDirective, DbxPopupService, DbxPopupContentComponent, DbxPopupControlsComponent, DbxModelTypesService, DbxModelTrackerService, allDbxModelViewTrackerEventModelKeys, DbxListItemAnchorModifierDirective, DbxValueListItemModifierDirective, AbstractPopoverDirective, DbxPopoverContentComponent, DbxPopoverHeaderComponent, DbxPopoverScrollContentDirective, DbxListEmptyContentComponent, AbstractPopoverRefDirective, DbxPopoverService, DbxLoadingComponent, DbxDetailBlockComponent, DbxClickToCopyTextComponent, DbxDownloadTextViewComponent, DbxModelObjectStateService, DbxListViewWrapper, AbstractDbxListWrapperDirective, AbstractDbxListViewDirective, DbxValueListViewComponentImportsModule, DEFAULT_DBX_VALUE_LIST_COMPONENT_CONFIGURATION_TEMPLATE, DbxActionConfirmDirective, DbxAvatarComponent, DbxChipDirective, DbxColorDirective, DbxIconTileComponent, DbxContentPitDirective, AbstractDbxWidgetComponent, AbstractDialogDirective, DbxDialogContentDirective, DbxPopoverInteractionModule, DbxListModifierModule, DbxWebFilePreviewService, DbxActionSnackbarErrorDirective, DbxActionDialogDirective, compressImageFile, DbxFileUploadComponent, DbxPdfMergeEditorStore, PDF_MERGE_RESULT_MIME_TYPE, DbxActionLoadingContextDirective, DbxFileUploadActionSyncDirective } from '@dereekb/dbx-web';
 import * as i1 from '@angular/material/icon';
 import { MatIconModule, MatIcon } from '@angular/material/icon';
-import { firebaseAuthErrorToReadableError, FIREBASE_AUTH_PASSWORD_MIN_LENGTH, FirebaseDevelopmentFunctions, ScheduledFunctionDevelopmentFunctionTypeEnum, clientFirebaseFirestoreContextFactory, SystemStateFirestoreCollections, NotificationFirestoreCollections, StorageFileFirestoreCollections, FIREBASE_DEVELOPMENT_FUNCTIONS_MAP_KEY, iterationQueryDocChangeWatcher, firebaseQuerySnapshotAccumulator, firebaseQueryItemAccumulator, firestoreModelKeysFromDocuments, firestoreModelIdsFromDocuments, documentReferencesFromDocuments, getDocumentSnapshots, getDataFromDocumentSnapshots, latestSnapshotsFromDocuments, dataFromDocumentSnapshots, loadDocumentsForKeys, loadDocumentsForDocumentReferences, loadDocumentsForIds, firestoreModelKeyCollectionTypePair, buildFirebaseCollectionTypeModelTypeMap, firestoreModelId, flatFirestoreModelKey, twoWayFlatFirestoreModelKey, FirestoreAccessorStreamMode, firestoreModelIdsFromKey, firestoreModelKeyPartPairs, firestoreModelKeyPairObject, documentDataWithIdAndKey, isClientFirebaseError, FIRESTORE_PERMISSION_DENIED_ERROR_CODE, inferKeyFromTwoWayFlatFirestoreModelKey, firestoreModelKeyParentKey, AppNotificationTemplateTypeInfoRecordService, NotificationFunctions, unreadNotificationItems, StorageFileFunctions, firestoreModelKey, storageFileIdentity, clientFirebaseStorageContextFactory } from '@dereekb/firebase';
+import { firebaseAuthErrorToReadableError, FIREBASE_AUTH_PASSWORD_MIN_LENGTH, FirebaseDevelopmentFunctions, ScheduledFunctionDevelopmentFunctionTypeEnum, clientFirebaseFirestoreContextFactory, SystemStateFirestoreCollections, NotificationFirestoreCollections, StorageFileFirestoreCollections, FIREBASE_DEVELOPMENT_FUNCTIONS_MAP_KEY, iterationQueryDocChangeWatcher, firebaseQuerySnapshotAccumulator, firebaseQueryItemAccumulator, firestoreModelKeysFromDocuments, firestoreModelIdsFromDocuments, documentReferencesFromDocuments, getDocumentSnapshots, getDataFromDocumentSnapshots, latestSnapshotsFromDocuments, dataFromDocumentSnapshots, loadDocumentsForKeys, loadDocumentsForDocumentReferences, loadDocumentsForIds, firestoreModelKeyCollectionTypePair, buildFirebaseCollectionTypeModelTypeMap, firestoreModelId, flatFirestoreModelKey, twoWayFlatFirestoreModelKey, FirestoreAccessorStreamMode, firestoreModelIdsFromKey, firestoreModelKeyPartPairs, firestoreModelKeyPairObject, documentDataWithIdAndKey, isClientFirebaseError, FIRESTORE_PERMISSION_DENIED_ERROR_CODE, inferKeyFromTwoWayFlatFirestoreModelKey, firestoreModelKeyParentKey, userExternalConnectionEntryIsConnected, CALCOM_USER_EXTERNAL_CONNECTION_PROVIDER_TYPE, ZOOM_USER_EXTERNAL_CONNECTION_PROVIDER_TYPE, DISCORD_USER_EXTERNAL_CONNECTION_PROVIDER_TYPE, ZOHO_USER_EXTERNAL_CONNECTION_PROVIDER_TYPE, UserExternalConnectionFunctions, NotificationHealthCheckStatus, NotificationDeliveryMethod, MailgunNotificationHealthCheckIssueCode, KnownNotificationHealthCheckIssueCode, AppNotificationTemplateTypeInfoRecordService, NotificationFunctions, notificationUserHealthCheckNextRunAt, notificationUserHealthCheckNextProbeAtByMethod, notificationHealthCheckPendingProbeMethods, notificationUserHealthCheckNextVerifyAt, DEFAULT_NOTIFICATION_USER_HEALTH_CHECK_VERIFY_THROTTLE_SECONDS, ALL_NOTIFICATION_DELIVERY_METHODS, unreadNotificationItems, StorageFileFunctions, firestoreModelKey, storageFileIdentity, clientFirebaseStorageContextFactory } from '@dereekb/firebase';
 import * as i1$2 from '@dereekb/dbx-form';
 import { AbstractSyncForgeFormDirective, dbxForgeEmailField, DbxForgeFormComponentImportsModule, dbxForgeFormComponentProviders, DBX_FORGE_FORM_COMPONENT_TEMPLATE, AbstractConfigAsyncForgeFormDirective, dbxForgeUsernameLoginField, dbxForgeTextPasswordField, dbxForgeTextVerifyPasswordField, DbxActionFormDirective, DbxFormSourceDirective, dbxForgeTextPasswordWithVerifyField, dbxForgeTextField, dbxForgePickableChipField, filterPickableItemFieldValuesByLabel } from '@dereekb/dbx-form';
 import { NgTemplateOutlet, DatePipe } from '@angular/common';
 import * as i1$3 from '@angular/material/button';
 import { MatButtonModule } from '@angular/material/button';
-import { toSignal, toObservable } from '@angular/core/rxjs-interop';
+import { toSignal, toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { MatSnackBar } from '@angular/material/snack-bar';
 import { initializeApp } from 'firebase/app';
 import { persistentSingleTabManager, persistentMultipleTabManager, persistentLocalCache, initializeFirestore, connectFirestoreEmulator } from 'firebase/firestore';
@@ -30,6 +30,7 @@ import { MatExpansionPanel, MatExpansionPanelHeader, MatExpansionPanelTitle, Mat
 import { ComponentStore } from '@ngrx/component-store';
 import { __decorate, __param } from 'tslib';
 import { MatDialog } from '@angular/material/dialog';
+import { isAfter, addMinutes } from 'date-fns';
 import { BaseError } from 'make-error';
 
 /**
@@ -288,6 +289,34 @@ const DEFAULT_DBX_FIREBASE_AUTH_SERVICE_DELEGATE = {
         return of(undefined);
     }
 };
+/**
+ * Creates a function that returns a shared observable scoped to the input's uid, discarding and rebuilding it
+ * whenever the uid changes.
+ *
+ * Exists because a `shareReplay()` buffer cannot be cleared: a shared stream that outlives the signed-in user
+ * hands the NEXT user's subscribers a value derived from the PREVIOUS user's token, synchronously. Any consumer
+ * that reads the first emission — the UIRouter auth transition hooks, for instance — then acts on data belonging
+ * to a different user. Rebuilding per-uid gives a same-page re-login (log out, log back in as someone else
+ * without reloading) the same cold-start behavior as a page reload.
+ *
+ * The per-uid observable should use `refCount: true` so the discarded uid's source is torn down rather than
+ * leaking one live subscription per user switch. That is safe here because the returned observable is only
+ * consumed through a `switchMap`, so its reference count tracks the outer subscribers exactly.
+ *
+ * @param config - The uid reader and the per-uid observable factory.
+ * @returns Function that returns the shared observable for the input.
+ */
+function sharedObservableForUidFunction(config) {
+    const { uidForInput, factoryForInput } = config;
+    let current;
+    return (input) => {
+        const uid = uidForInput(input);
+        if (current == null || current.uid !== uid) {
+            current = { uid, obs: factoryForInput(input) };
+        }
+        return current.obs;
+    };
+}
 // MARK: Service
 class DbxFirebaseAuthService {
     firebaseAuth = inject(FIREBASE_AUTH_TOKEN);
@@ -328,26 +357,71 @@ class DbxFirebaseAuthService {
      * Alias for uid$
      */
     userIdentifier$ = this.uid$;
-    currentIdTokenString$ = firebaseIdToken(this.firebaseAuth).pipe(distinctUntilChanged(), shareReplay(1));
+    /**
+     * 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.
+     */
+    currentIdTokenString$ = (() => {
+        const sharedForUid = sharedObservableForUidFunction({
+            uidForInput: (uid) => uid,
+            factoryForInput: (uid) => (uid == null ? of(null) : firebaseIdToken(this.firebaseAuth).pipe(distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true })))
+        });
+        return this.currentUid$.pipe(switchMap((uid) => sharedForUid(uid)));
+    })();
     idTokenString$ = this.currentUid$.pipe(switchMap((x) => (x ? this.currentIdTokenString$.pipe(filterMaybe()) : EMPTY)));
-    currentIdTokenResult$ = this.currentAuthUser$.pipe(switchMap((x) => (x ? this.currentIdTokenString$.pipe(switchMap((y) => (y ? x.getIdTokenResult() : of(null)))) : of(null))), distinctUntilChanged(), shareReplay(1));
+    /**
+     * 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.
+     */
+    currentIdTokenResult$ = (() => {
+        const sharedForUser = sharedObservableForUidFunction({
+            uidForInput: (user) => user?.uid,
+            factoryForInput: (user) => user == null
+                ? of(null)
+                : this.currentIdTokenString$.pipe(switchMap((token) => (token ? user.getIdTokenResult() : of(null))), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }))
+        });
+        return this.currentAuthUser$.pipe(distinctUntilChanged((a, b) => a?.uid === b?.uid), switchMap((user) => sharedForUser(user)));
+    })();
     idTokenResult$ = this.currentIdTokenResult$.pipe(filterMaybe());
-    currentClaims$ = this.currentIdTokenResult$.pipe(map((x) => (x ? x.claims : null)), distinctUntilChanged(), shareReplay(1));
+    /**
+     * 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.
+     */
+    currentClaims$ = this.currentIdTokenResult$.pipe(map((x) => (x ? x.claims : null)), distinctUntilChanged());
     claims$ = this.currentClaims$.pipe(filterMaybe());
     currentAuthContextInfo$ = this.currentAuthUser$.pipe(switchMap((x) => this.loadAuthContextInfoForUser(x)), shareReplay(1));
     authContextInfo$ = this.currentAuthContextInfo$.pipe(filterMaybe());
+    /**
+     * 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.
+     */
     authUserState$ = (() => {
-        const delegateAuthUserStateObs = this.delegate.authUserStateObs(this).pipe(catchError(() => of('error')), distinctUntilChanged(), shareReplay(1));
-        let obs;
-        if (this.delegate.fullControlOfAuthUserState) {
-            obs = delegateAuthUserStateObs;
-        }
-        else {
-            obs = this._authState$.pipe(distinctUntilChanged(), switchMap((x) => {
-                return x == null ? of('none') : delegateAuthUserStateObs;
-            }));
-        }
-        return obs;
+        const fullControlOfAuthUserState = Boolean(this.delegate.fullControlOfAuthUserState);
+        const sharedDelegateStateForUid = sharedObservableForUidFunction({
+            uidForInput: (user) => user?.uid,
+            factoryForInput: (user) => {
+                let obs;
+                if (user == null && !fullControlOfAuthUserState) {
+                    obs = of('none');
+                }
+                else {
+                    obs = this.delegate.authUserStateObs(this).pipe(catchError(() => of('error')), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
+                }
+                return obs;
+            }
+        });
+        return this._authState$.pipe(distinctUntilChanged((a, b) => a?.uid === b?.uid), switchMap((user) => sharedDelegateStateForUid(user)));
     })();
     authRoles$ = this.delegate.authRolesObs(this);
     isOnboarded$ = this.delegate.isOnboarded(this);
@@ -2279,7 +2353,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
 function authRolesObsWithClaimsService(config) {
     const { addAuthUserStateToRoles: addAuthUserState, claimsService } = config;
     return (dbxFirebaseAuthService) => {
-        let obs = dbxFirebaseAuthService.idTokenResult$.pipe(map((x) => claimsService.toRoles(x.claims)));
+        /**
+         * Sourced from currentIdTokenResult$ instead of idTokenResult$ so the logged-out null is not swallowed by that
+         * stream's filterMaybe(): the claim-derived roles have to CLEAR when there is no token. Otherwise they persist
+         * through the entire logged-out window and on into the next user's session, and a role guard evaluated in that
+         * window passes on the PREVIOUS user's roles.
+         */
+        let obs = dbxFirebaseAuthService.currentIdTokenResult$.pipe(map((x) => (x == null ? new Set() : claimsService.toRoles(x.claims))));
         if (addAuthUserState) {
             obs = obs.pipe(switchMap((authRoleSet) => dbxFirebaseAuthService.authUserState$.pipe(map((userState) => addToSetCopy(authRoleSet, [userState])))));
         }
@@ -6183,175 +6263,1842 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
         }] });
 
 /**
- * Client-side service used for retrieving notification templates.
+ * 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.
  */
-class DbxFirebaseNotificationTemplateService {
-    appNotificationTemplateTypeInfoRecordService = inject(AppNotificationTemplateTypeInfoRecordService);
-    notificationItemSubjectMessagePairForNotificationSummaryItem(item) {
-        const templateType = item.t;
-        const templateDetails = this.appNotificationTemplateTypeInfoRecordService.appNotificationTemplateTypeInfoRecord[templateType];
-        const subject = item.s ?? templateDetails.name;
-        const message = item.g ?? '';
-        const date = item.cat;
+class DbxFirebaseExternalConnectionsConfig {
+    /**
+     * Which providers are enabled. Pass `true` (the default) to enable every registered provider.
+     */
+    enabledProviders;
+    /**
+     * 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.
+     */
+    mintAuthorizeState;
+    /**
+     * 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.
+     */
+    authorizeOrigin;
+    /**
+     * Builds the default authorize path for a provider that does not declare its own.
+     *
+     * Defaults to {@link DEFAULT_EXTERNAL_CONNECTION_AUTHORIZE_PATH_FACTORY}.
+     */
+    authorizePathFactory;
+    /**
+     * 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.
+     */
+    navigate;
+}
+/**
+ * Default authorize path for a provider: `/oauth/<providerType>/authorize`.
+ *
+ * @param providerType - The provider to build a path for.
+ * @returns The authorize path.
+ */
+const DEFAULT_EXTERNAL_CONNECTION_AUTHORIZE_PATH_FACTORY = (providerType) => `/oauth/${providerType}/authorize`;
+/**
+ * Derives a row's presentation status from its entry.
+ *
+ * @param entry - The user's entry for the provider, if any.
+ * @returns The row status.
+ */
+function dbxFirebaseExternalConnectionRowStatusForEntry(entry) {
+    let result;
+    if (userExternalConnectionEntryIsConnected(entry)) {
+        result = 'connected';
+    }
+    else if (entry?.st === 'error') {
+        result = 'error';
+    }
+    else {
+        result = 'notConnected';
+    }
+    return result;
+}
+/**
+ * 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.
+ */
+function dbxFirebaseExternalConnectionRows(input) {
+    const { providers, enabledProviderTypes, entries, loading } = input;
+    const enabled = new Set(enabledProviderTypes);
+    return providers
+        .filter((x) => enabled.has(x.providerType) || entries?.[x.providerType] != null)
+        .map((provider) => {
+        const entry = entries?.[provider.providerType];
         return {
-            item,
-            subject,
-            message,
-            date
+            providerType: provider.providerType,
+            assets: provider.assets,
+            entry,
+            status: loading ? 'loading' : dbxFirebaseExternalConnectionRowStatusForEntry(entry),
+            enabled: enabled.has(provider.providerType)
         };
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationTemplateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationTemplateService });
+    });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationTemplateService, decorators: [{
-            type: Injectable
-        }] });
 
 /**
- * Selection list wrapper for notification items with view-only default selection mode.
+ * 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.
  */
-class DbxFirebaseNotificationItemListComponent extends AbstractDbxSelectionListWrapperDirective {
-    constructor() {
-        super({
-            componentClass: DbxFirebaseNotificationItemListViewComponent,
-            defaultSelectionMode: 'view'
-        });
+const DBX_FIREBASE_EXTERNAL_CONNECTION_CALCOM_PROVIDER = {
+    providerType: CALCOM_USER_EXTERNAL_CONNECTION_PROVIDER_TYPE,
+    assets: {
+        providerName: 'Cal.com',
+        icon: 'event',
+        description: 'Schedule and manage bookings from your Cal.com account.'
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.11", type: DbxFirebaseNotificationItemListComponent, isStandalone: true, selector: "dbx-firebase-notificationitem-list", providers: provideDbxListViewWrapper(DbxFirebaseNotificationItemListComponent), usesInheritance: true, ngImport: i0, template: "\n  <dbx-list [state]=\"currentState$\" [config]=\"configSignal()\" [hasMore]=\"hasMore()\" [disabled]=\"disabledSignal()\" [selectionMode]=\"selectionModeSignal()\">\n    <ng-content top select=\"[top]\"></ng-content>\n    <ng-content bottom select=\"[bottom]\"></ng-content>\n    <ng-content empty select=\"[empty]\"></ng-content>\n    <ng-content emptyLoading select=\"[emptyLoading]\"></ng-content>\n    <ng-content end select=\"[end]\"></ng-content>\n  </dbx-list>", isInline: true, dependencies: [{ kind: "ngmodule", type: DbxListWrapperComponentImportsModule }, { kind: "component", type: i1$1.DbxListComponent, selector: "dbx-list", inputs: ["padded", "state", "config", "disabled", "selectionMode", "hasMore"], outputs: ["contentScrolled"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemListComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'dbx-firebase-notificationitem-list',
-                    template: DEFAULT_LIST_WRAPPER_COMPONENT_CONFIGURATION_TEMPLATE,
-                    imports: [DbxListWrapperComponentImportsModule],
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                    providers: provideDbxListViewWrapper(DbxFirebaseNotificationItemListComponent),
-                    standalone: true
-                }]
-        }], ctorParameters: () => [] });
+};
 /**
- * List view component that renders notification items using the selection list pattern.
+ * Default presentation for Zoom.
  */
-class DbxFirebaseNotificationItemListViewComponent extends AbstractDbxSelectionListViewDirective {
-    config = {
-        componentClass: DbxFirebaseNotificationItemListViewItemComponent,
-        mapValuesToItemValues: (x) => of(x.map((y) => ({ ...y, key: y.id, icon: y.icon, itemValue: y })))
-    };
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemListViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.11", type: DbxFirebaseNotificationItemListViewComponent, isStandalone: true, selector: "dbx-firebase-notificationitem-list-view", providers: provideDbxListView(DbxFirebaseNotificationItemListViewComponent), usesInheritance: true, ngImport: i0, template: "<dbx-selection-list-view [config]=\"config\"></dbx-selection-list-view>", isInline: true, dependencies: [{ kind: "ngmodule", type: DbxSelectionValueListViewComponentImportsModule }, { kind: "component", type: i1$1.DbxSelectionValueListViewComponent, selector: "dbx-selection-list-view" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemListViewComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'dbx-firebase-notificationitem-list-view',
-                    template: DEFAULT_DBX_SELECTION_VALUE_LIST_COMPONENT_CONFIGURATION_TEMPLATE,
-                    imports: [DbxSelectionValueListViewComponentImportsModule],
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                    providers: provideDbxListView(DbxFirebaseNotificationItemListViewComponent),
-                    standalone: true
-                }]
-        }] });
+const DBX_FIREBASE_EXTERNAL_CONNECTION_ZOOM_PROVIDER = {
+    providerType: ZOOM_USER_EXTERNAL_CONNECTION_PROVIDER_TYPE,
+    assets: {
+        providerName: 'Zoom',
+        icon: 'videocam',
+        description: 'Create and manage Zoom meetings.'
+    }
+};
 /**
- * Individual list view item component rendering a notification's subject, message, and date.
+ * Default presentation for Discord.
  */
-class DbxFirebaseNotificationItemListViewItemComponent extends AbstractDbxValueListViewItemComponent {
-    dbxFirebaseNotificationTemplateService = inject(DbxFirebaseNotificationTemplateService);
-    pairGetter = cachedGetter(() => this.dbxFirebaseNotificationTemplateService.notificationItemSubjectMessagePairForNotificationSummaryItem(this.itemValue));
-    get subject() {
-        return this.pairGetter().subject;
+const DBX_FIREBASE_EXTERNAL_CONNECTION_DISCORD_PROVIDER = {
+    providerType: DISCORD_USER_EXTERNAL_CONNECTION_PROVIDER_TYPE,
+    assets: {
+        providerName: 'Discord',
+        icon: 'forum',
+        description: 'Link your Discord account.'
     }
-    get message() {
-        return this.pairGetter().message;
+};
+/**
+ * Default presentation for Zoho.
+ */
+const DBX_FIREBASE_EXTERNAL_CONNECTION_ZOHO_PROVIDER = {
+    providerType: ZOHO_USER_EXTERNAL_CONNECTION_PROVIDER_TYPE,
+    assets: {
+        providerName: 'Zoho',
+        icon: 'work',
+        description: 'Connect your Zoho account.'
     }
-    get date() {
-        return this.pairGetter().date;
+};
+/**
+ * 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.
+ */
+const DBX_FIREBASE_KNOWN_EXTERNAL_CONNECTION_PROVIDERS = {
+    calcom: DBX_FIREBASE_EXTERNAL_CONNECTION_CALCOM_PROVIDER,
+    zoom: DBX_FIREBASE_EXTERNAL_CONNECTION_ZOOM_PROVIDER,
+    discord: DBX_FIREBASE_EXTERNAL_CONNECTION_DISCORD_PROVIDER,
+    zoho: DBX_FIREBASE_EXTERNAL_CONNECTION_ZOHO_PROVIDER
+};
+/**
+ * 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.
+ */
+function dbxFirebaseKnownExternalConnectionProvider(config) {
+    const { providerType, assets, authorizePath, connect, disconnectConfirm } = config;
+    const known = DBX_FIREBASE_KNOWN_EXTERNAL_CONNECTION_PROVIDERS[providerType];
+    if (known == null) {
+        throw new Error(`dbxFirebaseKnownExternalConnectionProvider(): there is no known provider for "${providerType}".`);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemListViewItemComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.11", type: DbxFirebaseNotificationItemListViewItemComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: `
-    <div class="dbx-list-item-padded dbx-list-two-line-item dbx-firebase-notificationitem-list-view-item" role="article" [attr.aria-label]="subject">
-      <div class="item-left">
-        <span class="notificationitem-subject">{{ subject }}</span>
-        <span class="notificationitem-message item-details">{{ message | cutText: 90 }}</span>
-        <span class="notificationitem-date item-details-footnote">{{ date | date: 'medium' }}</span>
-      </div>
-    </div>
-  `, isInline: true, dependencies: [{ kind: "pipe", type: DatePipe, name: "date" }, { kind: "pipe", type: CutTextPipe, name: "cutText" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+    return {
+        ...known,
+        assets: { ...known.assets, ...assets },
+        authorizePath: authorizePath ?? known.authorizePath,
+        connect: connect ?? known.connect,
+        disconnectConfirm: disconnectConfirm ?? known.disconnectConfirm
+    };
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemListViewItemComponent, decorators: [{
-            type: Component,
-            args: [{
-                    template: `
-    <div class="dbx-list-item-padded dbx-list-two-line-item dbx-firebase-notificationitem-list-view-item" role="article" [attr.aria-label]="subject">
-      <div class="item-left">
-        <span class="notificationitem-subject">{{ subject }}</span>
-        <span class="notificationitem-message item-details">{{ message | cutText: 90 }}</span>
-        <span class="notificationitem-date item-details-footnote">{{ date | date: 'medium' }}</span>
-      </div>
-    </div>
-  `,
-                    imports: [DatePipe, CutTextPipe],
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                    standalone: true
-                }]
-        }] });
-
 /**
- * Presentational component for notification item content, displaying subject, message, and date.
+ * 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.
  */
-class DbxFirebaseNotificationItemContentComponent {
-    subject = input(...(ngDevMode ? [undefined, { debugName: "subject" }] : /* istanbul ignore next */ []));
-    message = input(...(ngDevMode ? [undefined, { debugName: "message" }] : /* istanbul ignore next */ []));
-    date = input(...(ngDevMode ? [undefined, { debugName: "date" }] : /* istanbul ignore next */ []));
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.11", type: DbxFirebaseNotificationItemContentComponent, isStandalone: true, selector: "dbx-firebase-notificationitem-content", inputs: { subject: { classPropertyName: "subject", publicName: "subject", isSignal: true, isRequired: false, transformFunction: null }, message: { classPropertyName: "message", publicName: "message", isSignal: true, isRequired: false, transformFunction: null }, date: { classPropertyName: "date", publicName: "date", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: "<div class=\"dbx-firebase-notificationitem-content\" role=\"article\" [attr.aria-label]=\"subject()\">\n  <div class=\"notificationitem-header dbx-pb2\">\n    @if (subject()) {\n      <div class=\"notificationitem-subject dbx-pb1\">{{ subject() }}</div>\n    }\n    <ng-content select=\"[header]\"></ng-content>\n    @if (date()) {\n      <div class=\"notificationitem-date dbx-label dbx-small\">{{ date() | date: 'medium' }}</div>\n    }\n  </div>\n  <ng-content select=\"[premessage]\"></ng-content>\n  <div class=\"notificationitem-message\">{{ message() }}</div>\n  <ng-content></ng-content>\n</div>\n", styles: [".dbx-firebase-notificationitem-content .notificationitem-subject{font-size:1.25em}\n"], dependencies: [{ kind: "pipe", type: DatePipe, name: "date" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+function dbxFirebaseExternalConnectionProviderForEntry(entry) {
+    let result;
+    if (typeof entry === 'string') {
+        const known = DBX_FIREBASE_KNOWN_EXTERNAL_CONNECTION_PROVIDERS[entry];
+        if (known == null) {
+            throw new Error(`dbxFirebaseExternalConnectionProviderForEntry(): there is no known provider for "${entry}". Declare the provider instead of naming it.`);
+        }
+        result = known;
+    }
+    else {
+        result = entry;
+    }
+    return result;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemContentComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'dbx-firebase-notificationitem-content', imports: [DatePipe], changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, template: "<div class=\"dbx-firebase-notificationitem-content\" role=\"article\" [attr.aria-label]=\"subject()\">\n  <div class=\"notificationitem-header dbx-pb2\">\n    @if (subject()) {\n      <div class=\"notificationitem-subject dbx-pb1\">{{ subject() }}</div>\n    }\n    <ng-content select=\"[header]\"></ng-content>\n    @if (date()) {\n      <div class=\"notificationitem-date dbx-label dbx-small\">{{ date() | date: 'medium' }}</div>\n    }\n  </div>\n  <ng-content select=\"[premessage]\"></ng-content>\n  <div class=\"notificationitem-message\">{{ message() }}</div>\n  <ng-content></ng-content>\n</div>\n", styles: [".dbx-firebase-notificationitem-content .notificationitem-subject{font-size:1.25em}\n"] }]
-        }], propDecorators: { subject: [{ type: i0.Input, args: [{ isSignal: true, alias: "subject", required: false }] }], message: [{ type: i0.Input, args: [{ isSignal: true, alias: "message", required: false }] }], date: [{ type: i0.Input, args: [{ isSignal: true, alias: "date", required: false }] }] } });
 
 /**
- * Prefix used by all widgets.
+ * How long {@link DEFAULT_EXTERNAL_CONNECTION_NAVIGATE_FUNCTION} waits for the browser to leave the
+ * page before treating the redirect as having failed.
  *
- * Does not include the "-" between the prefix and the template type returned by dbxWidgetTypeForNotificationTemplateType().
+ * 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.
  */
-const FIREBASE_NOTIFICATION_ITEM_WIDGET_TYPE_PREFIX = 'dbxFirebaseNotificationItem';
-const DEFAULT_FIREBASE_NOTIFICATION_ITEM_WIDGET_TYPE = `${FIREBASE_NOTIFICATION_ITEM_WIDGET_TYPE_PREFIX}Default`;
+const DEFAULT_EXTERNAL_CONNECTION_NAVIGATE_TIMEOUT = 20 * 1000;
 /**
- * Derives the widget type string for a given notification template type by prepending the standard prefix.
+ * 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.
  *
- * @param notificationTemplateType - The notification template type to generate a widget type for.
- * @returns The prefixed widget type string.
+ * `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.
  */
-function dbxWidgetTypeForNotificationTemplateType(notificationTemplateType) {
-    return `${FIREBASE_NOTIFICATION_ITEM_WIDGET_TYPE_PREFIX}-${notificationTemplateType}`;
+function navigateAndWaitForPageToLeave(navigate, timeout = DEFAULT_EXTERNAL_CONNECTION_NAVIGATE_TIMEOUT) {
+    return new Promise((resolve, reject) => {
+        // aborting drops the listener, so a page that stays put does not accumulate one per attempt
+        const abortController = new AbortController();
+        const timeoutRef = setTimeout(() => {
+            abortController.abort();
+            reject(new Error('The page did not open. The browser may have blocked the redirect.'));
+        }, timeout);
+        const cancel = () => {
+            abortController.abort();
+            clearTimeout(timeoutRef);
+        };
+        window.addEventListener('pagehide', () => {
+            clearTimeout(timeoutRef);
+            resolve();
+        }, { once: true, signal: abortController.signal });
+        try {
+            navigate();
+        }
+        catch (e) {
+            cancel();
+            reject(e);
+        }
+    });
 }
-
 /**
- * Service used for registering widgets used for notification items.
+ * 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.
  */
-class DbxFirebaseNotificationItemWidgetService {
-    dbxWidgetService = inject(DbxWidgetService);
-    dbxFirebaseNotificationTemplateService = inject(DbxFirebaseNotificationTemplateService);
-    _entries = new Map();
+const DEFAULT_EXTERNAL_CONNECTION_NAVIGATE_FUNCTION = (url) => {
+    return navigateAndWaitForPageToLeave(() => {
+        window.location.href = url;
+    });
+};
+/**
+ * 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.
+ */
+class DbxFirebaseExternalConnectionService {
+    config = inject(DbxFirebaseExternalConnectionsConfig);
     /**
-     * Used to register a item widget. If widget for the given type is already registered, this will override it by default.
+     * 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.
+     */
+    _userExternalConnectionFunctions = inject(UserExternalConnectionFunctions, { optional: true });
+    _providers = new Map();
+    _assets = new Map();
+    _enableAll = false;
+    _enabled = new Set();
+    constructor() {
+        const { providers, enabledProviders } = this.config;
+        providers.forEach((x) => this.register(dbxFirebaseExternalConnectionProviderForEntry(x), false));
+        if (enabledProviders == null || enabledProviders === true) {
+            this._enableAll = true;
+        }
+        else {
+            this.enable(enabledProviders);
+        }
+    }
+    /**
+     * Registers a provider.
      *
-     * @param provider - The notification item widget entry to register.
-     * @param override - Whether to override an existing widget for the same notification template type. Defaults to true.
-     * @returns True if the widget was registered, false if it already existed and override was false or the template type was unknown.
+     * @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, override = true) {
-        const { componentClass, notificationTemplateType } = provider;
-        const widgetType = dbxWidgetTypeForNotificationTemplateType(notificationTemplateType);
-        let result = false;
-        if (override || !this._entries.has(notificationTemplateType)) {
-            const notificationTemplateTypeInfo = this.dbxFirebaseNotificationTemplateService.appNotificationTemplateTypeInfoRecordService.appNotificationTemplateTypeInfoRecord[notificationTemplateType];
-            if (notificationTemplateTypeInfo) {
-                const entry = {
-                    notificationTemplateType,
+        let result;
+        if (override || !this._providers.has(provider.providerType)) {
+            this._providers.set(provider.providerType, provider);
+            this.updateAssetsForProvider(provider.providerType, provider.assets);
+            result = true;
+        }
+        else {
+            result = false;
+        }
+        return result;
+    }
+    /**
+     * Patches the assets for a provider type.
+     *
+     * @param providerType - The provider to update.
+     * @param assets - The asset values to merge in.
+     */
+    updateAssetsForProvider(providerType, assets) {
+        const current = this._assets.get(providerType);
+        this._assets.set(providerType, { ...current, ...assets });
+    }
+    // MARK: Enable/Disable
+    /**
+     * Enables all providers, including any registered later.
+     *
+     * @param enableAll - Whether to enable all providers. Defaults to true.
+     */
+    setEnableAll(enableAll = true) {
+        this._enableAll = enableAll;
+    }
+    clearEnabled() {
+        this._enabled = new Set();
+    }
+    enable(types) {
+        addToSet(this._enabled, types);
+    }
+    disable(types) {
+        removeFromSet(this._enabled, types);
+    }
+    // MARK: Get
+    getRegisteredTypes() {
+        return [...this._providers.keys()];
+    }
+    getEnabledTypes() {
+        return this._enableAll ? this.getRegisteredTypes() : [...this._enabled];
+    }
+    getProvider(providerType) {
+        return this._providers.get(providerType);
+    }
+    getProviders(types) {
+        return filterMaybeArrayValues(mapIterable(types ?? this.getRegisteredTypes(), (x) => this._providers.get(x)));
+    }
+    getAssetsForProvider(providerType) {
+        return this._assets.get(providerType);
+    }
+    // MARK: Connect
+    /**
+     * 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() {
+        return this.config.mintAuthorizeState ?? true;
+    }
+    /**
+     * 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.
+     */
+    async mintAuthorizeStateForProvider(providerType) {
+        const userExternalConnectionFunctions = this._userExternalConnectionFunctions;
+        if (!userExternalConnectionFunctions) {
+            throw new Error(`DbxFirebaseExternalConnectionService: cannot mint an authorize state for "${providerType}" because UserExternalConnectionFunctions was not provided. Add the userExternalConnection functions to the app's functions config map, or configure mintAuthorizeState: false.`);
+        }
+        const { state } = await userExternalConnectionFunctions.userExternalConnection.readUserExternalConnection.authorizeState({ providerType });
+        return state;
+    }
+    /**
+     * 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.
+     */
+    async authorizeUrlWithStateForProvider(providerType) {
+        const authorizeUrl = this.authorizeUrlForProvider(providerType);
+        let result = authorizeUrl;
+        if (authorizeUrl && this.mintsAuthorizeState) {
+            const state = await this.mintAuthorizeStateForProvider(providerType);
+            // appended as text rather than through URL, since an app that shares an origin with its API
+            // configures no authorizeOrigin and the path stays relative
+            result = fixExtraQueryParameters(`${authorizeUrl}?state=${encodeURIComponent(state)}`);
+        }
+        return result;
+    }
+    /**
+     * 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) {
+        const provider = this.getProvider(providerType);
+        let result = null;
+        if (provider) {
+            const pathFactory = this.config.authorizePathFactory ?? DEFAULT_EXTERNAL_CONNECTION_AUTHORIZE_PATH_FACTORY;
+            const path = provider.authorizePath ?? pathFactory(providerType);
+            result = this.config.authorizeOrigin ? `${this.config.authorizeOrigin}${path}` : path;
+        }
+        return result;
+    }
+    /**
+     * 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.
+     */
+    async connectToProvider(providerType) {
+        const provider = this.getProvider(providerType);
+        if (!provider) {
+            throw new Error(`DbxFirebaseExternalConnectionService: no provider registered for "${providerType}".`);
+        }
+        const navigate = this.config.navigate ?? DEFAULT_EXTERNAL_CONNECTION_NAVIGATE_FUNCTION;
+        if (provider.connect) {
+            await provider.connect({
+                providerType,
+                provider,
+                authorizeUrl: this.authorizeUrlForProvider(providerType),
+                mintAuthorizeState: () => this.mintAuthorizeStateForProvider(providerType),
+                navigate
+            });
+        }
+        else {
+            const authorizeUrl = await this.authorizeUrlWithStateForProvider(providerType);
+            if (!authorizeUrl) {
+                throw new Error(`DbxFirebaseExternalConnectionService: no authorize url could be resolved for "${providerType}".`);
+            }
+            await navigate(authorizeUrl);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseExternalConnectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseExternalConnectionService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseExternalConnectionService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+/**
+ * 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()`.
+ */
+class DbxFirebaseUserExternalConnectionCollections {
+}
+/**
+ * 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$)`.
+ */
+class UserExternalConnectionDocumentStore extends AbstractDbxFirebaseDocumentStore {
+    userExternalConnectionFunctions = inject(UserExternalConnectionFunctions);
+    constructor() {
+        super({ firestoreCollection: inject(DbxFirebaseUserExternalConnectionCollections).userExternalConnectionCollection });
+    }
+    /**
+     * 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.
+     */
+    createUserExternalConnection = firebaseDocumentStoreCreateFunction(this, this.userExternalConnectionFunctions.userExternalConnection.createUserExternalConnection);
+    /**
+     * Disconnects the user from a provider. The only write a client can make to the connection pair.
+     */
+    disconnectUserExternalConnection = firebaseDocumentStoreUpdateFunction(this, this.userExternalConnectionFunctions.userExternalConnection.updateUserExternalConnection.disconnect);
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: UserExternalConnectionDocumentStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: UserExternalConnectionDocumentStore });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: UserExternalConnectionDocumentStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+/**
+ * Directive providing a {@link UserExternalConnectionDocumentStore} for a single user's connection document.
+ */
+class DbxFirebaseUserExternalConnectionDocumentStoreDirective extends DbxFirebaseDocumentStoreDirective {
+    constructor() {
+        super(inject(UserExternalConnectionDocumentStore));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseUserExternalConnectionDocumentStoreDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.11", type: DbxFirebaseUserExternalConnectionDocumentStoreDirective, isStandalone: true, selector: "[dbxFirebaseUserExternalConnectionDocument]", providers: provideDbxFirebaseDocumentStoreDirective(DbxFirebaseUserExternalConnectionDocumentStoreDirective, UserExternalConnectionDocumentStore), usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseUserExternalConnectionDocumentStoreDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxFirebaseUserExternalConnectionDocument]',
+                    providers: provideDbxFirebaseDocumentStoreDirective(DbxFirebaseUserExternalConnectionDocumentStoreDirective, UserExternalConnectionDocumentStore),
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * 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.
+ */
+function externalConnectionsLoadingStateFromDocumentLoadingState(state) {
+    const errorCode = state.error?.code;
+    let result;
+    if (state.value) {
+        result = successResult(state.value.e ?? {});
+    }
+    else if (errorCode === DBX_FIREBASE_MODEL_DOES_NOT_EXIST_ERROR || errorCode === FIRESTORE_PERMISSION_DENIED_ERROR_CODE) {
+        result = successResult({});
+    }
+    else if (state.error) {
+        result = { ...state, value: undefined };
+    }
+    else {
+        result = { ...state, value: undefined };
+    }
+    return result;
+}
+/**
+ * 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.
+ */
+function shouldCreateUserExternalConnectionForDocumentLoadingState(state) {
+    return !isLoadingStateLoading(state) && state.value == null && state.error?.code === DBX_FIREBASE_MODEL_DOES_NOT_EXIST_ERROR;
+}
+/**
+ * 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.
+ */
+class DbxFirebaseUserExternalConnectionsStore {
+    userExternalConnectionDocumentStore = inject(UserExternalConnectionDocumentStore);
+    /**
+     * The user's per-provider entries. A missing document (or a denied read) resolves to an empty map.
+     */
+    entriesLoadingState$ = this.userExternalConnectionDocumentStore.dataLoadingState$.pipe(map(externalConnectionsLoadingStateFromDocumentLoadingState), shareReplay(1));
+    /**
+     * 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() {
+        return this.userExternalConnectionDocumentStore.dataLoadingState$.pipe(filter((x) => !isLoadingStateLoading(x)), first(), switchMap((state) => (shouldCreateUserExternalConnectionForDocumentLoadingState(state) ? this.userExternalConnectionDocumentStore.createUserExternalConnection({}) : of(undefined))));
+    }
+    /**
+     * 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) {
+        this.userExternalConnectionDocumentStore.setId(uid);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseUserExternalConnectionsStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseUserExternalConnectionsStore });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseUserExternalConnectionsStore, decorators: [{
+            type: Injectable
+        }] });
+
+const CONNECTION_STATUS_LABELS = {
+    loading: 'Loading',
+    connected: 'Connected',
+    notConnected: 'Not connected',
+    error: 'Needs attention'
+};
+const CONNECTION_STATUS_COLORS = {
+    loading: 'grey',
+    connected: 'success',
+    notConnected: 'grey',
+    error: 'warn'
+};
+/**
+ * Fallback icon for a provider whose assets declare neither a logo nor an icon.
+ */
+const DEFAULT_CONNECTION_ICON = 'link';
+/**
+ * Used by actions that declare no confirm config, such as Connect, so they run without a dialog.
+ *
+ * The directive prompts with its defaults for a nullish config, which is not what an action with nothing to
+ * confirm wants.
+ */
+const AUTO_CONFIRM_CONFIG = { autoConfirm: true };
+/**
+ * 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>
+ * ```
+ */
+class DbxFirebaseExternalConnectionListComponent extends AbstractDbxListWrapperDirective {
+    constructor() {
+        super({
+            componentClass: DbxFirebaseExternalConnectionListViewComponent
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseExternalConnectionListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.11", type: DbxFirebaseExternalConnectionListComponent, isStandalone: true, selector: "dbx-firebase-external-connection-list", host: { classAttribute: "dbx-firebase-external-connection-list dbx-list-auto-height dbx-list-card-items-list dbx-list-no-hover-effects" }, usesInheritance: true, ngImport: i0, template: "\n  <dbx-list [state]=\"currentState$\" [config]=\"configSignal()\" [hasMore]=\"hasMore()\" [disabled]=\"disabledSignal()\" [selectionMode]=\"selectionModeSignal()\">\n    <ng-content top select=\"[top]\"></ng-content>\n    <ng-content bottom select=\"[bottom]\"></ng-content>\n    <ng-content empty select=\"[empty]\"></ng-content>\n    <ng-content emptyLoading select=\"[emptyLoading]\"></ng-content>\n    <ng-content end select=\"[end]\"></ng-content>\n  </dbx-list>", isInline: true, dependencies: [{ kind: "ngmodule", type: DbxListWrapperComponentImportsModule }, { kind: "component", type: i1$1.DbxListComponent, selector: "dbx-list", inputs: ["padded", "state", "config", "disabled", "selectionMode", "hasMore"], outputs: ["contentScrolled"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseExternalConnectionListComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-firebase-external-connection-list',
+                    template: DEFAULT_LIST_WRAPPER_COMPONENT_CONFIGURATION_TEMPLATE,
+                    imports: [DbxListWrapperComponentImportsModule],
+                    host: {
+                        class: 'dbx-firebase-external-connection-list dbx-list-auto-height dbx-list-card-items-list dbx-list-no-hover-effects'
+                    },
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: () => [] });
+class DbxFirebaseExternalConnectionListViewComponent extends AbstractDbxListViewDirective {
+    config = {
+        componentClass: DbxFirebaseExternalConnectionListViewItemComponent,
+        mapValuesToItemValues: (values) => of(values.map((value) => ({
+            ...value,
+            itemValue: value,
+            // the template paints its own leading avatar, so the built-in icon slot stays empty
+            icon: undefined,
+            // The key carries the row's rendered state, not just its identity. An item value reaches its
+            // component through the injected DBX_VALUE_LIST_VIEW_ITEM provider, and
+            // `dbxInjectionComponentConfigIsEqual` deliberately ignores the provider array — so under a
+            // stable key the component is never recreated and would keep rendering the state it was built
+            // with. Here that would pin every row to its initial 'loading' status forever.
+            key: `${value.row.providerType}_${value.row.status}_${value.row.entry?.uat?.getTime() ?? 0}`
+        })))
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseExternalConnectionListViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.11", type: DbxFirebaseExternalConnectionListViewComponent, isStandalone: true, selector: "dbx-firebase-external-connection-list-view", host: { classAttribute: "dbx-list-item-p0" }, providers: provideDbxListView(DbxFirebaseExternalConnectionListViewComponent), usesInheritance: true, ngImport: i0, template: "<dbx-list-view [config]=\"config\"></dbx-list-view>", isInline: true, dependencies: [{ kind: "ngmodule", type: DbxValueListViewComponentImportsModule }, { kind: "component", type: i1$1.DbxValueListViewComponent, selector: "dbx-list-view" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseExternalConnectionListViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-firebase-external-connection-list-view',
+                    template: DEFAULT_DBX_VALUE_LIST_COMPONENT_CONFIGURATION_TEMPLATE,
+                    imports: [DbxValueListViewComponentImportsModule],
+                    providers: provideDbxListView(DbxFirebaseExternalConnectionListViewComponent),
+                    host: {
+                        // the item template owns all of its padding, including the leading avatar's inset
+                        class: 'dbx-list-item-p0'
+                    },
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }] });
+/**
+ * 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.
+ */
+class DbxFirebaseExternalConnectionListViewItemComponent extends AbstractDbxValueListViewItemComponent {
+    defaultIcon = DEFAULT_CONNECTION_ICON;
+    autoConfirmConfig = AUTO_CONFIRM_CONFIG;
+    get row() {
+        return this.itemValue.row;
+    }
+    get assets() {
+        return this.row.assets;
+    }
+    /**
+     * 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() {
+        return this.itemValue.actions ?? [];
+    }
+    get statusLabel() {
+        return CONNECTION_STATUS_LABELS[this.row.status];
+    }
+    get statusColor() {
+        return CONNECTION_STATUS_COLORS[this.row.status];
+    }
+    get connectedAt() {
+        return this.row.status === 'connected' ? this.row.entry?.coa : undefined;
+    }
+    /**
+     * 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() {
+        const { status, entry, assets } = this.row;
+        let result;
+        if (status === 'connected' || status === 'error') {
+            result = entry?.l ?? entry?.ea ?? assets.description;
+        }
+        else {
+            result = assets.description;
+        }
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseExternalConnectionListViewItemComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.11", type: DbxFirebaseExternalConnectionListViewItemComponent, isStandalone: true, selector: "dbx-firebase-external-connection-list-view-item", usesInheritance: true, ngImport: i0, template: `
+    <div class="dbx-list-item-padded-thick dbx-firebase-external-connection-item">
+      <div class="dbx-flex-bar dbx-pb1">
+        <dbx-avatar class="dbx-icon-spacer dbx-firebase-external-connection-tile" [avatarTile]="true" avatarStyle="square" [avatarUrl]="assets.logoUrl" [avatarIcon]="assets.icon ?? defaultIcon" [avatarImageFilter]="assets.logoFilter" [avatarIgnoreDefaultUrl]="true" [avatarColor]="statusColor" [avatarColorTone]="18"></dbx-avatar>
+        <div class="dbx-flex-fill">
+          <div class="dbx-text-title-medium">{{ assets.providerName }}</div>
+          @if (detail; as detailValue) {
+            <div class="dbx-text-body-small dbx-hint">{{ detailValue }}</div>
+          }
+        </div>
+        <dbx-chip [small]="true" [color]="statusColor">{{ statusLabel }}</dbx-chip>
+      </div>
+
+      @if (connectedAt; as connectedAtValue) {
+        <div class="dbx-text-body-small dbx-hint">Connected {{ connectedAtValue | date: 'medium' }}</div>
+      }
+
+      @if (actions.length) {
+        <div class="dbx-flex-bar dbx-pt2">
+          @for (action of actions; track action.label) {
+            <!-- dbxActionValue is not used: each action's handler takes no input and the confirm marks it ready, dialog or not -->
+            <div dbxAction [dbxActionHandler]="action.handler" [dbxActionConfirm]="action.confirm ?? autoConfirmConfig">
+              <dbx-button dbxActionButton [stroked]="true" [text]="action.label" [icon]="action.icon"></dbx-button>
+              <dbx-error dbxActionError></dbx-error>
+            </div>
+          }
+        </div>
+      }
+    </div>
+  `, isInline: true, dependencies: [{ kind: "directive", type: DbxActionButtonDirective, selector: "[dbxActionButton]", inputs: ["dbxActionButtonEcho"] }, { kind: "directive", type: DbxActionConfirmDirective, selector: "[dbxActionConfirm]", inputs: ["dbxActionConfirm", "dbxActionConfirmSkip"] }, { kind: "directive", type: DbxActionDirective, selector: "dbx-action,[dbxAction]", exportAs: ["action", "dbxAction"] }, { kind: "directive", type: DbxActionErrorDirective, selector: "[dbxActionError]" }, { kind: "directive", type: DbxActionHandlerDirective, selector: "[dbxActionHandler]", inputs: ["dbxActionHandler"] }, { kind: "component", type: DbxAvatarComponent, selector: "dbx-avatar", inputs: ["context", "avatarSelector", "avatarUid", "avatarUrl", "avatarName", "avatarKey", "avatarIcon", "avatarStyle", "avatarSize", "avatarHideOnError", "avatarTile", "avatarColor", "avatarColorTone", "avatarImageFit", "avatarImageFilter", "avatarIgnoreDefaultUrl"] }, { kind: "component", type: DbxButtonComponent, selector: "dbx-button", inputs: ["bar", "type", "buttonStyle", "color", "spinnerColor", "customButtonColor", "customTextColor", "customSpinnerColor", "basic", "tonal", "raised", "stroked", "flat", "iconOnly", "fab", "customContent", "allowClickPropagation", "mode"] }, { kind: "directive", type: DbxChipDirective, selector: "dbx-chip", inputs: ["small", "block", "color", "display", "tone"] }, { kind: "component", type: DbxErrorComponent, selector: "dbx-error", inputs: ["error", "iconOnly"], outputs: ["popoverOpened"] }, { kind: "pipe", type: DatePipe, name: "date" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseExternalConnectionListViewItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-firebase-external-connection-list-view-item',
+                    template: `
+    <div class="dbx-list-item-padded-thick dbx-firebase-external-connection-item">
+      <div class="dbx-flex-bar dbx-pb1">
+        <dbx-avatar class="dbx-icon-spacer dbx-firebase-external-connection-tile" [avatarTile]="true" avatarStyle="square" [avatarUrl]="assets.logoUrl" [avatarIcon]="assets.icon ?? defaultIcon" [avatarImageFilter]="assets.logoFilter" [avatarIgnoreDefaultUrl]="true" [avatarColor]="statusColor" [avatarColorTone]="18"></dbx-avatar>
+        <div class="dbx-flex-fill">
+          <div class="dbx-text-title-medium">{{ assets.providerName }}</div>
+          @if (detail; as detailValue) {
+            <div class="dbx-text-body-small dbx-hint">{{ detailValue }}</div>
+          }
+        </div>
+        <dbx-chip [small]="true" [color]="statusColor">{{ statusLabel }}</dbx-chip>
+      </div>
+
+      @if (connectedAt; as connectedAtValue) {
+        <div class="dbx-text-body-small dbx-hint">Connected {{ connectedAtValue | date: 'medium' }}</div>
+      }
+
+      @if (actions.length) {
+        <div class="dbx-flex-bar dbx-pt2">
+          @for (action of actions; track action.label) {
+            <!-- dbxActionValue is not used: each action's handler takes no input and the confirm marks it ready, dialog or not -->
+            <div dbxAction [dbxActionHandler]="action.handler" [dbxActionConfirm]="action.confirm ?? autoConfirmConfig">
+              <dbx-button dbxActionButton [stroked]="true" [text]="action.label" [icon]="action.icon"></dbx-button>
+              <dbx-error dbxActionError></dbx-error>
+            </div>
+          }
+        </div>
+      }
+    </div>
+  `,
+                    imports: [DatePipe, DbxActionButtonDirective, DbxActionConfirmDirective, DbxActionDirective, DbxActionErrorDirective, DbxActionHandlerDirective, DbxAvatarComponent, DbxButtonComponent, DbxChipDirective, DbxErrorComponent],
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }] });
+
+/**
+ * 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>
+ * ```
+ */
+class DbxFirebaseExternalConnectionsComponent {
+    dbxFirebaseAuthService = inject(DbxFirebaseAuthService);
+    dbxFirebaseExternalConnectionService = inject(DbxFirebaseExternalConnectionService);
+    dbxFirebaseUserExternalConnectionsStore = inject(DbxFirebaseUserExternalConnectionsStore);
+    userExternalConnectionDocumentStore = inject(UserExternalConnectionDocumentStore);
+    constructor() {
+        // currentUid$ rather than userIdentifier$: the latter substitutes NO_AUTH_USER_IDENTIFIER ('0')
+        // when signed out, which would ask Firestore for uec/0.
+        this.dbxFirebaseUserExternalConnectionsStore.setUid(this.dbxFirebaseAuthService.currentUid$);
+        // The connection document has to exist before a provider can be connected: the server asserts a
+        // role against it, and a role map is only consulted for a document that exists. This page is where
+        // it gets created — the user is present and known to want the feature, and creating it is gated
+        // server-side in one place instead of being a side effect of the OAuth handoff. Nothing is created
+        // for a signed-out user: no uid means no document ref, so the load never settles.
+        this.dbxFirebaseUserExternalConnectionsStore.createIfMissing().pipe(takeUntilDestroyed()).subscribe();
+    }
+    _currentUidSignal = toSignal(this.dbxFirebaseAuthService.currentUid$, { initialValue: undefined });
+    /**
+     * THE shared subscription. Every row is computed from this one document read.
+     */
+    _entriesStateSignal = toSignal(this.dbxFirebaseUserExternalConnectionsStore.entriesLoadingState$, { initialValue: beginLoading() });
+    signedInSignal = computed(() => this._currentUidSignal() != null, ...(ngDevMode ? [{ debugName: "signedInSignal" }] : /* istanbul ignore next */ []));
+    errorSignal = computed(() => this._entriesStateSignal().error, ...(ngDevMode ? [{ debugName: "errorSignal" }] : /* istanbul ignore next */ []));
+    rowsSignal = computed(() => {
+        const state = this._entriesStateSignal();
+        return dbxFirebaseExternalConnectionRows({
+            providers: this.dbxFirebaseExternalConnectionService.getProviders(),
+            enabledProviderTypes: this.dbxFirebaseExternalConnectionService.getEnabledTypes(),
+            entries: state.value,
+            loading: isLoadingStateLoading(state)
+        });
+    }, ...(ngDevMode ? [{ debugName: "rowsSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * 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.
+     */
+    listStateSignal = computed(() => successResult(this.rowsSignal().map((row) => ({ row, actions: this.actionsForRow(row) }))), ...(ngDevMode ? [{ debugName: "listStateSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * 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) {
+        const { providerType, assets, status } = row;
+        const provider = this.dbxFirebaseExternalConnectionService.getProvider(providerType);
+        const result = [];
+        if (status !== 'loading') {
+            if (status !== 'connected' && row.enabled) {
+                result.push({
+                    label: assets.connectText ?? (status === 'error' ? 'Reconnect' : 'Connect'),
+                    icon: 'link',
+                    handler: (_, context) => context.startWorkingWithPromise(this.connectToProvider(providerType))
+                });
+            }
+            if (status !== 'notConnected') {
+                result.push({
+                    label: assets.disconnectText ?? 'Disconnect',
+                    icon: 'link_off',
+                    confirm: provider?.disconnectConfirm ?? {
+                        title: `Disconnect ${assets.providerName}?`,
+                        prompt: `This account will no longer be connected to ${assets.providerName}.`,
+                        confirmText: 'Disconnect'
+                    },
+                    handler: (_, context) => context.startWorkingWithLoadingStateObservable(this.disconnectFromProvider(providerType))
+                });
+            }
+        }
+        return result.length ? result : null;
+    }
+    /**
+     * 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.
+     */
+    async connectToProvider(providerType) {
+        await this.dbxFirebaseExternalConnectionService.connectToProvider(providerType);
+    }
+    /**
+     * Disconnects the signed-in user from a provider.
+     *
+     * @param providerType - The provider to disconnect.
+     * @returns The loading state observable of the callable.
+     */
+    disconnectFromProvider(providerType) {
+        return this.userExternalConnectionDocumentStore.disconnectUserExternalConnection({ providerType });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseExternalConnectionsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.11", type: DbxFirebaseExternalConnectionsComponent, isStandalone: true, selector: "dbx-firebase-external-connections", host: { classAttribute: "d-block dbx-firebase-external-connections" }, providers: [UserExternalConnectionDocumentStore, DbxFirebaseUserExternalConnectionsStore], ngImport: i0, template: `
+    @if (signedInSignal()) {
+      @if (errorSignal(); as error) {
+        <dbx-error [error]="error"></dbx-error>
+      } @else {
+        <dbx-firebase-external-connection-list [state]="listStateSignal()">
+          <dbx-list-empty-content empty>
+            <p class="dbx-hint no-margin">There are no apps available to connect.</p>
+          </dbx-list-empty-content>
+        </dbx-firebase-external-connection-list>
+      }
+    } @else {
+      <p class="dbx-hint no-margin">Sign in to connect your apps.</p>
+    }
+  `, isInline: true, dependencies: [{ kind: "component", type: DbxErrorComponent, selector: "dbx-error", inputs: ["error", "iconOnly"], outputs: ["popoverOpened"] }, { kind: "component", type: DbxFirebaseExternalConnectionListComponent, selector: "dbx-firebase-external-connection-list" }, { kind: "component", type: DbxListEmptyContentComponent, selector: "dbx-list-empty-content" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseExternalConnectionsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-firebase-external-connections',
+                    template: `
+    @if (signedInSignal()) {
+      @if (errorSignal(); as error) {
+        <dbx-error [error]="error"></dbx-error>
+      } @else {
+        <dbx-firebase-external-connection-list [state]="listStateSignal()">
+          <dbx-list-empty-content empty>
+            <p class="dbx-hint no-margin">There are no apps available to connect.</p>
+          </dbx-list-empty-content>
+        </dbx-firebase-external-connection-list>
+      }
+    } @else {
+      <p class="dbx-hint no-margin">Sign in to connect your apps.</p>
+    }
+  `,
+                    host: {
+                        class: 'd-block dbx-firebase-external-connections'
+                    },
+                    standalone: true,
+                    imports: [DbxErrorComponent, DbxFirebaseExternalConnectionListComponent, DbxListEmptyContentComponent],
+                    providers: [UserExternalConnectionDocumentStore, DbxFirebaseUserExternalConnectionsStore],
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * 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
+ *   ]
+ * })
+ * ```
+ */
+function provideDbxFirebaseExternalConnections(config) {
+    const { appCollectionClass } = config;
+    const providers = [
+        {
+            provide: DbxFirebaseExternalConnectionsConfig,
+            useValue: config
+        },
+        {
+            provide: DbxFirebaseUserExternalConnectionCollections,
+            useExisting: appCollectionClass
+        },
+        {
+            provide: DbxFirebaseExternalConnectionService,
+            useClass: DbxFirebaseExternalConnectionService
+        }
+    ];
+    return makeEnvironmentProviders(providers);
+}
+
+/**
+ * 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.
+ */
+class DbxFirebaseNotificationHealthCheckConfig {
+}
+/**
+ * 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.
+ */
+const DEFAULT_NOTIFICATION_HEALTH_CHECK_PROBE_WATCH_MINUTES = 20;
+/**
+ * Configuration for the {@link DbxFirebaseNotificationHealthCheckPresentationService}.
+ */
+class DbxFirebaseNotificationHealthCheckPresentationServiceConfig {
+}
+/**
+ * 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.
+ */
+const NOTIFICATION_HEALTH_CHECK_STATUS_COLORS = {
+    [NotificationHealthCheckStatus.OK]: 'success',
+    [NotificationHealthCheckStatus.WARNING]: 'warn',
+    [NotificationHealthCheckStatus.ERROR]: 'warn',
+    [NotificationHealthCheckStatus.PENDING]: 'notice',
+    [NotificationHealthCheckStatus.SKIPPED]: 'grey',
+    [NotificationHealthCheckStatus.UNKNOWN]: 'grey'
+};
+/**
+ * Icon for each health check status. Also what distinguishes a warning from an error.
+ */
+const NOTIFICATION_HEALTH_CHECK_STATUS_ICONS = {
+    [NotificationHealthCheckStatus.OK]: 'check_circle',
+    [NotificationHealthCheckStatus.WARNING]: 'warning',
+    [NotificationHealthCheckStatus.ERROR]: 'error',
+    [NotificationHealthCheckStatus.PENDING]: 'hourglass_top',
+    [NotificationHealthCheckStatus.SKIPPED]: 'remove_circle_outline',
+    [NotificationHealthCheckStatus.UNKNOWN]: 'help'
+};
+/**
+ * Human-readable label for each health check status.
+ *
+ * Used as the chip label for an issue code with no registered entry.
+ */
+const NOTIFICATION_HEALTH_CHECK_STATUS_LABELS = {
+    [NotificationHealthCheckStatus.OK]: 'OK',
+    [NotificationHealthCheckStatus.WARNING]: 'Warning',
+    [NotificationHealthCheckStatus.ERROR]: 'Problem',
+    [NotificationHealthCheckStatus.PENDING]: 'Pending',
+    [NotificationHealthCheckStatus.SKIPPED]: 'Not Checked',
+    [NotificationHealthCheckStatus.UNKNOWN]: 'Unknown'
+};
+/**
+ * Human-readable label for each delivery method.
+ */
+const NOTIFICATION_DELIVERY_METHOD_LABELS = {
+    [NotificationDeliveryMethod.EMAIL]: 'Email',
+    [NotificationDeliveryMethod.TEXT]: 'Text Message',
+    [NotificationDeliveryMethod.PUSH]: 'Push Notification',
+    [NotificationDeliveryMethod.NOTIFICATION_SUMMARY]: 'In-App Notification'
+};
+/**
+ * Icon for each delivery method.
+ */
+const NOTIFICATION_DELIVERY_METHOD_ICONS = {
+    [NotificationDeliveryMethod.EMAIL]: 'mail',
+    [NotificationDeliveryMethod.TEXT]: 'sms',
+    [NotificationDeliveryMethod.PUSH]: 'notifications',
+    [NotificationDeliveryMethod.NOTIFICATION_SUMMARY]: 'inbox'
+};
+/**
+ * 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.
+ */
+const NOTIFICATION_DELIVERY_METHOD_TEST_MESSAGE_LABELS = {
+    [NotificationDeliveryMethod.EMAIL]: 'Send Test Email',
+    [NotificationDeliveryMethod.TEXT]: 'Send Test Text Message',
+    [NotificationDeliveryMethod.PUSH]: 'Send Test Push Notification',
+    [NotificationDeliveryMethod.NOTIFICATION_SUMMARY]: 'Send Test In-App Notification'
+};
+/**
+ * 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."
+ */
+const NOTIFICATION_DELIVERY_METHOD_TEST_MESSAGE_NOUNS = {
+    [NotificationDeliveryMethod.EMAIL]: 'test email',
+    [NotificationDeliveryMethod.TEXT]: 'test text message',
+    [NotificationDeliveryMethod.PUSH]: 'test push notification',
+    [NotificationDeliveryMethod.NOTIFICATION_SUMMARY]: 'test in-app notification'
+};
+/**
+ * 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.
+ */
+const NOTIFICATION_DELIVERY_METHOD_SHORT_LABELS = {
+    [NotificationDeliveryMethod.EMAIL]: 'Email',
+    [NotificationDeliveryMethod.TEXT]: 'Text',
+    [NotificationDeliveryMethod.PUSH]: 'Push',
+    [NotificationDeliveryMethod.NOTIFICATION_SUMMARY]: 'In-App'
+};
+/**
+ * What each probe lifecycle code says happened to the test message.
+ *
+ * The other half of the composed probe chip label — see {@link notificationHealthCheckProbeIssueLabel}.
+ */
+const NOTIFICATION_HEALTH_CHECK_PROBE_ISSUE_OUTCOMES = {
+    [KnownNotificationHealthCheckIssueCode.PROBE_PENDING]: 'Sent',
+    [KnownNotificationHealthCheckIssueCode.PROBE_DELIVERED]: 'Delivered',
+    [KnownNotificationHealthCheckIssueCode.PROBE_FAILED]: 'Failed',
+    [KnownNotificationHealthCheckIssueCode.PROBE_DISPATCH_FAILED]: 'Not Sent',
+    [MailgunNotificationHealthCheckIssueCode.PROBE_NOT_CONFIGURED]: 'Unavailable'
+};
+/**
+ * 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.
+ */
+function notificationHealthCheckProbeIssueLabel(code, method) {
+    const outcome = NOTIFICATION_HEALTH_CHECK_PROBE_ISSUE_OUTCOMES[code];
+    return outcome == null ? undefined : `Test ${NOTIFICATION_DELIVERY_METHOD_SHORT_LABELS[method] ?? 'Message'} ${outcome}`;
+}
+/**
+ * Presentation entries for every issue code the library and the Mailgun email check emit.
+ *
+ * None of them set a colour — see {@link DbxFirebaseNotificationHealthCheckPresentationEntry.color}.
+ */
+const DEFAULT_NOTIFICATION_HEALTH_CHECK_PRESENTATION_ENTRIES = [
+    // configuration
+    { code: KnownNotificationHealthCheckIssueCode.SEND_SERVICE_NOT_CONFIGURED, label: 'Not Available', icon: 'block' },
+    { code: KnownNotificationHealthCheckIssueCode.SEND_SERVICE_HEALTH_CHECK_UNAVAILABLE, label: 'Not Verified', icon: 'help' },
+    { code: KnownNotificationHealthCheckIssueCode.NO_DELIVERY_TARGET, label: 'No Destination', icon: 'person_off' },
+    { code: KnownNotificationHealthCheckIssueCode.RECIPIENT_OPTED_OUT, label: 'Opted Out', icon: 'unsubscribe' },
+    { code: KnownNotificationHealthCheckIssueCode.RECIPIENT_DISABLED, label: 'Turned Off', icon: 'notifications_off' },
+    { code: KnownNotificationHealthCheckIssueCode.METHOD_DISABLED_GLOBALLY, label: 'Off Everywhere', icon: 'notifications_off' },
+    { code: KnownNotificationHealthCheckIssueCode.METHOD_DISABLED_FOR_TEMPLATE, label: 'Off For This Type', icon: 'notifications_paused' },
+    { code: KnownNotificationHealthCheckIssueCode.METHOD_DISABLED_FOR_BOX, label: 'Off For A Subscription', icon: 'notifications_paused' },
+    // subscriptions
+    { code: KnownNotificationHealthCheckIssueCode.NO_NOTIFICATION_BOXES, label: 'No Subscriptions', icon: 'inbox' },
+    { code: KnownNotificationHealthCheckIssueCode.NOTIFICATION_BOX_EXCLUSIONS, label: 'Suppressed', icon: 'filter_alt_off' },
+    { code: KnownNotificationHealthCheckIssueCode.NEEDS_CONFIG_SYNC, label: 'Still Saving', icon: 'sync_problem' },
+    { code: KnownNotificationHealthCheckIssueCode.SUBSCRIPTION_BROKEN, label: 'Broken Subscription', icon: 'link_off' },
+    { code: KnownNotificationHealthCheckIssueCode.SUBSCRIPTION_NOT_READY, label: 'Still Setting Up', icon: 'hourglass_top' },
+    // probe. These labels are only the fallback for a finding rendered without a delivery method in hand:
+    // given one, notificationHealthCheckProbeIssueLabel() names it — `Test Email Sent`, `Test Text Sent`.
+    { code: KnownNotificationHealthCheckIssueCode.PROBE_PENDING, label: 'Test Sent', icon: 'hourglass_top' },
+    { code: KnownNotificationHealthCheckIssueCode.PROBE_DELIVERED, label: 'Test Delivered', icon: 'mark_email_read' },
+    { code: KnownNotificationHealthCheckIssueCode.PROBE_FAILED, label: 'Test Failed', icon: 'error' },
+    { code: KnownNotificationHealthCheckIssueCode.PROBE_DISPATCH_FAILED, label: 'Test Not Sent', icon: 'error' },
+    // mailgun
+    { code: MailgunNotificationHealthCheckIssueCode.SUPPRESSED_BOUNCE, label: 'Blocked After Bounce', icon: 'block' },
+    { code: MailgunNotificationHealthCheckIssueCode.SUPPRESSED_COMPLAINT, label: 'Blocked After Spam Report', icon: 'report' },
+    { code: MailgunNotificationHealthCheckIssueCode.SUPPRESSED_UNSUBSCRIBE, label: 'Unsubscribed', icon: 'unsubscribe' },
+    { code: MailgunNotificationHealthCheckIssueCode.RECENT_DELIVERY_FAILURE, label: 'Recent Delivery Failed', icon: 'error' },
+    { code: MailgunNotificationHealthCheckIssueCode.RECENT_DELIVERY_SUCCESS, label: 'Recently Delivered', icon: 'mark_email_read' },
+    { code: MailgunNotificationHealthCheckIssueCode.NO_RECENT_ACTIVITY, label: 'No Recent Activity', icon: 'history_toggle_off' },
+    { code: MailgunNotificationHealthCheckIssueCode.DOMAIN_NOT_ACTIVE, label: 'Sending System Down', icon: 'dns' },
+    { code: MailgunNotificationHealthCheckIssueCode.ADDRESS_UNDELIVERABLE, label: 'Address Undeliverable', icon: 'person_off' },
+    { code: MailgunNotificationHealthCheckIssueCode.ADDRESS_DISPOSABLE, label: 'Disposable Address', icon: 'delete_forever' },
+    { code: MailgunNotificationHealthCheckIssueCode.PROBE_NOT_CONFIGURED, label: 'Test Unavailable', icon: 'block' }
+];
+
+/**
+ * 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 })`.
+ */
+class DbxFirebaseNotificationHealthCheckPresentationService {
+    _config = inject(DbxFirebaseNotificationHealthCheckPresentationServiceConfig, { optional: true });
+    _entries = new Map();
+    constructor() {
+        if (this._config?.registerDefaultEntries !== false) {
+            this.register(DEFAULT_NOTIFICATION_HEALTH_CHECK_PRESENTATION_ENTRIES);
+        }
+        if (this._config?.entries) {
+            this.register(this._config.entries);
+        }
+    }
+    /**
+     * 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, override = true) {
+        asArray(entries).forEach((entry) => {
+            if (override || !this._entries.has(entry.code)) {
+                this._entries.set(entry.code, entry);
+            }
+        });
+    }
+    /**
+     * 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) {
+        return this._entries.get(code);
+    }
+    /**
+     * 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, method) {
+        const entry = this._entries.get(issue.c);
+        const probeLabel = method == null ? undefined : notificationHealthCheckProbeIssueLabel(issue.c, method);
+        return {
+            label: probeLabel ?? entry?.label ?? this.labelForStatus(issue.s),
+            icon: entry?.icon ?? this.iconForStatus(issue.s),
+            color: entry?.color ?? this.colorForStatus(issue.s)
+        };
+    }
+    /**
+     * @param status - The status to colour.
+     * @returns The theme colour for the status.
+     */
+    colorForStatus(status) {
+        return NOTIFICATION_HEALTH_CHECK_STATUS_COLORS[status] ?? NOTIFICATION_HEALTH_CHECK_STATUS_COLORS[NotificationHealthCheckStatus.UNKNOWN];
+    }
+    /**
+     * @param status - The status to find an icon for.
+     * @returns The icon for the status.
+     */
+    iconForStatus(status) {
+        return NOTIFICATION_HEALTH_CHECK_STATUS_ICONS[status] ?? NOTIFICATION_HEALTH_CHECK_STATUS_ICONS[NotificationHealthCheckStatus.UNKNOWN];
+    }
+    /**
+     * @param status - The status to label.
+     * @returns The human-readable label for the status.
+     */
+    labelForStatus(status) {
+        return NOTIFICATION_HEALTH_CHECK_STATUS_LABELS[status] ?? NOTIFICATION_HEALTH_CHECK_STATUS_LABELS[NotificationHealthCheckStatus.UNKNOWN];
+    }
+    /**
+     * @param method - The delivery method to label.
+     * @returns The human-readable label for the delivery method.
+     */
+    labelForDeliveryMethod(method) {
+        return NOTIFICATION_DELIVERY_METHOD_LABELS[method] ?? 'Notification';
+    }
+    /**
+     * @param method - The delivery method to find an icon for.
+     * @returns The icon for the delivery method.
+     */
+    iconForDeliveryMethod(method) {
+        return NOTIFICATION_DELIVERY_METHOD_ICONS[method] ?? 'notifications';
+    }
+    /**
+     * @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) {
+        return NOTIFICATION_DELIVERY_METHOD_TEST_MESSAGE_LABELS[method] ?? 'Send Test Message';
+    }
+    /**
+     * @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) {
+        return NOTIFICATION_DELIVERY_METHOD_TEST_MESSAGE_NOUNS[method] ?? 'test message';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationHealthCheckPresentationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationHealthCheckPresentationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationHealthCheckPresentationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * 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.
+ */
+class DbxFirebaseNotificationHealthCheckIssueComponent {
+    _presentationService = inject(DbxFirebaseNotificationHealthCheckPresentationService);
+    issue = input(...(ngDevMode ? [undefined, { debugName: "issue" }] : /* istanbul ignore next */ []));
+    /**
+     * 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.
+     */
+    method = input(...(ngDevMode ? [undefined, { debugName: "method" }] : /* istanbul ignore next */ []));
+    presentationSignal = computed(() => {
+        const issue = this.issue();
+        const method = this.method();
+        return issue ? this._presentationService.presentationForIssue(issue, method) : { label: '', icon: '', color: 'grey' };
+    }, ...(ngDevMode ? [{ debugName: "presentationSignal" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationHealthCheckIssueComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.11", type: DbxFirebaseNotificationHealthCheckIssueComponent, isStandalone: true, selector: "dbx-firebase-notification-healthcheck-issue", inputs: { issue: { classPropertyName: "issue", publicName: "issue", isSignal: true, isRequired: false, transformFunction: null }, method: { classPropertyName: "method", publicName: "method", isSignal: true, isRequired: false, transformFunction: null } }, host: { classAttribute: "d-block dbx-firebase-notification-healthcheck-issue" }, ngImport: i0, template: `
+    @if (issue(); as issueValue) {
+      <div class="dbx-flex-bar dbx-pb1">
+        <dbx-icon-tile class="dbx-icon-spacer" [icon]="presentationSignal().icon" [dbxColor]="presentationSignal().color" [dbxColorTone]="18"></dbx-icon-tile>
+        <dbx-chip [small]="true" [color]="presentationSignal().color">{{ presentationSignal().label }}</dbx-chip>
+      </div>
+      <p class="no-margin">{{ issueValue.m }}</p>
+      @if (issueValue.f) {
+        <p class="dbx-hint no-margin dbx-pt1">{{ issueValue.f }}</p>
+      }
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: DbxChipDirective, selector: "dbx-chip", inputs: ["small", "block", "color", "display", "tone"] }, { kind: "directive", type: DbxColorDirective, selector: "[dbxColor]", inputs: ["dbxColor", "dbxColorTone"], outputs: ["dbxColorChange", "dbxColorToneChange"] }, { kind: "component", type: DbxIconTileComponent, selector: "dbx-icon-tile", inputs: ["icon", "round"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationHealthCheckIssueComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-firebase-notification-healthcheck-issue',
+                    template: `
+    @if (issue(); as issueValue) {
+      <div class="dbx-flex-bar dbx-pb1">
+        <dbx-icon-tile class="dbx-icon-spacer" [icon]="presentationSignal().icon" [dbxColor]="presentationSignal().color" [dbxColorTone]="18"></dbx-icon-tile>
+        <dbx-chip [small]="true" [color]="presentationSignal().color">{{ presentationSignal().label }}</dbx-chip>
+      </div>
+      <p class="no-margin">{{ issueValue.m }}</p>
+      @if (issueValue.f) {
+        <p class="dbx-hint no-margin dbx-pt1">{{ issueValue.f }}</p>
+      }
+    }
+  `,
+                    host: {
+                        class: 'd-block dbx-firebase-notification-healthcheck-issue'
+                    },
+                    standalone: true,
+                    imports: [DbxChipDirective, DbxColorDirective, DbxIconTileComponent],
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], propDecorators: { issue: [{ type: i0.Input, args: [{ isSignal: true, alias: "issue", required: false }] }], method: [{ type: i0.Input, args: [{ isSignal: true, alias: "method", required: false }] }] } });
+
+/**
+ * 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.
+ */
+class DbxFirebaseNotificationHealthCheckMethodComponent {
+    _presentationService = inject(DbxFirebaseNotificationHealthCheckPresentationService);
+    result = input(...(ngDevMode ? [undefined, { debugName: "result" }] : /* istanbul ignore next */ []));
+    /**
+     * 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.
+     */
+    probeAction = input(...(ngDevMode ? [undefined, { debugName: "probeAction" }] : /* istanbul ignore next */ []));
+    methodLabelSignal = computed(() => {
+        const method = this.result()?.me;
+        return method ? this._presentationService.labelForDeliveryMethod(method) : '';
+    }, ...(ngDevMode ? [{ debugName: "methodLabelSignal" }] : /* istanbul ignore next */ []));
+    methodIconSignal = computed(() => {
+        const method = this.result()?.me;
+        return method ? this._presentationService.iconForDeliveryMethod(method) : 'notifications';
+    }, ...(ngDevMode ? [{ debugName: "methodIconSignal" }] : /* istanbul ignore next */ []));
+    statusColorSignal = computed(() => {
+        const status = this.result()?.s;
+        return status ? this._presentationService.colorForStatus(status) : 'grey';
+    }, ...(ngDevMode ? [{ debugName: "statusColorSignal" }] : /* istanbul ignore next */ []));
+    statusLabelSignal = computed(() => {
+        const status = this.result()?.s;
+        return status ? this._presentationService.labelForStatus(status) : '';
+    }, ...(ngDevMode ? [{ debugName: "statusLabelSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * 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.
+     */
+    testMessageSentLabelSignal = computed(() => {
+        const method = this.result()?.me;
+        const noun = method ? this._presentationService.testMessageNounForDeliveryMethod(method) : 'test message';
+        return `${noun.charAt(0).toUpperCase()}${noun.slice(1)} sent`;
+    }, ...(ngDevMode ? [{ debugName: "testMessageSentLabelSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * 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.
+     */
+    probeActionSignal = computed(() => {
+        const probeSupported = this.result()?.pb === true;
+        const probeAction = this.probeAction();
+        return probeSupported ? probeAction : undefined;
+    }, ...(ngDevMode ? [{ debugName: "probeActionSignal" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationHealthCheckMethodComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.11", type: DbxFirebaseNotificationHealthCheckMethodComponent, isStandalone: true, selector: "dbx-firebase-notification-healthcheck-method", inputs: { result: { classPropertyName: "result", publicName: "result", isSignal: true, isRequired: false, transformFunction: null }, probeAction: { classPropertyName: "probeAction", publicName: "probeAction", isSignal: true, isRequired: false, transformFunction: null } }, host: { classAttribute: "d-block dbx-firebase-notification-healthcheck-method" }, ngImport: i0, template: `
+    @if (result(); as resultValue) {
+      <div class="dbx-flex-bar dbx-pb1">
+        <dbx-icon-tile class="dbx-icon-spacer" [icon]="methodIconSignal()" [dbxColor]="statusColorSignal()" [dbxColorTone]="18"></dbx-icon-tile>
+        <div class="dbx-flex-fill">
+          <div class="dbx-text-title-medium">{{ methodLabelSignal() }}</div>
+          @if (resultValue.tg) {
+            <div class="dbx-text-body-small dbx-hint">{{ resultValue.tg }}</div>
+          } @else {
+            <div class="dbx-text-body-small dbx-hint">No destination</div>
+          }
+        </div>
+        <dbx-chip [small]="true" [color]="statusColorSignal()">{{ statusLabelSignal() }}</dbx-chip>
+      </div>
+
+      @for (issue of resultValue.is; track $index) {
+        <div class="dbx-pt2">
+          <dbx-firebase-notification-healthcheck-issue [issue]="issue" [method]="resultValue.me"></dbx-firebase-notification-healthcheck-issue>
+        </div>
+      }
+
+      @if (resultValue.pr; as probe) {
+        <div class="dbx-pt2 dbx-text-body-small dbx-hint">
+          {{ testMessageSentLabelSignal() }} {{ probe.at | date: 'medium' }}
+          @if (probe.d) {
+            · {{ probe.d }}
+          }
+        </div>
+      }
+
+      @if (probeActionSignal(); as probeAction) {
+        <div class="dbx-pt2">
+          <!-- dbxActionDisabled rather than the button's own disabled input, since dbxActionButton drives that from the action's state -->
+          <div dbxAction [dbxActionDisabled]="probeAction.disabled === true" [dbxActionHandler]="probeAction.handler" [dbxActionConfirm]="probeAction.confirm">
+            <dbx-button dbxActionButton [stroked]="true" [text]="probeAction.label" [icon]="probeAction.icon"></dbx-button>
+            <dbx-error dbxActionError></dbx-error>
+          </div>
+        </div>
+        @if (probeAction.notice) {
+          <div class="dbx-small dbx-hint dbx-pt2">{{ probeAction.notice }}</div>
+        }
+      }
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: DbxActionButtonDirective, selector: "[dbxActionButton]", inputs: ["dbxActionButtonEcho"] }, { kind: "directive", type: DbxActionConfirmDirective, selector: "[dbxActionConfirm]", inputs: ["dbxActionConfirm", "dbxActionConfirmSkip"] }, { kind: "directive", type: DbxActionDirective, selector: "dbx-action,[dbxAction]", exportAs: ["action", "dbxAction"] }, { kind: "directive", type: DbxActionDisabledDirective, selector: "[dbxActionDisabled]", inputs: ["dbxActionDisabled"] }, { kind: "directive", type: DbxActionErrorDirective, selector: "[dbxActionError]" }, { kind: "directive", type: DbxActionHandlerDirective, selector: "[dbxActionHandler]", inputs: ["dbxActionHandler"] }, { kind: "component", type: DbxButtonComponent, selector: "dbx-button", inputs: ["bar", "type", "buttonStyle", "color", "spinnerColor", "customButtonColor", "customTextColor", "customSpinnerColor", "basic", "tonal", "raised", "stroked", "flat", "iconOnly", "fab", "customContent", "allowClickPropagation", "mode"] }, { kind: "directive", type: DbxChipDirective, selector: "dbx-chip", inputs: ["small", "block", "color", "display", "tone"] }, { kind: "directive", type: DbxColorDirective, selector: "[dbxColor]", inputs: ["dbxColor", "dbxColorTone"], outputs: ["dbxColorChange", "dbxColorToneChange"] }, { kind: "component", type: DbxErrorComponent, selector: "dbx-error", inputs: ["error", "iconOnly"], outputs: ["popoverOpened"] }, { kind: "component", type: DbxIconTileComponent, selector: "dbx-icon-tile", inputs: ["icon", "round"] }, { kind: "component", type: DbxFirebaseNotificationHealthCheckIssueComponent, selector: "dbx-firebase-notification-healthcheck-issue", inputs: ["issue", "method"] }, { kind: "pipe", type: DatePipe, name: "date" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationHealthCheckMethodComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-firebase-notification-healthcheck-method',
+                    template: `
+    @if (result(); as resultValue) {
+      <div class="dbx-flex-bar dbx-pb1">
+        <dbx-icon-tile class="dbx-icon-spacer" [icon]="methodIconSignal()" [dbxColor]="statusColorSignal()" [dbxColorTone]="18"></dbx-icon-tile>
+        <div class="dbx-flex-fill">
+          <div class="dbx-text-title-medium">{{ methodLabelSignal() }}</div>
+          @if (resultValue.tg) {
+            <div class="dbx-text-body-small dbx-hint">{{ resultValue.tg }}</div>
+          } @else {
+            <div class="dbx-text-body-small dbx-hint">No destination</div>
+          }
+        </div>
+        <dbx-chip [small]="true" [color]="statusColorSignal()">{{ statusLabelSignal() }}</dbx-chip>
+      </div>
+
+      @for (issue of resultValue.is; track $index) {
+        <div class="dbx-pt2">
+          <dbx-firebase-notification-healthcheck-issue [issue]="issue" [method]="resultValue.me"></dbx-firebase-notification-healthcheck-issue>
+        </div>
+      }
+
+      @if (resultValue.pr; as probe) {
+        <div class="dbx-pt2 dbx-text-body-small dbx-hint">
+          {{ testMessageSentLabelSignal() }} {{ probe.at | date: 'medium' }}
+          @if (probe.d) {
+            · {{ probe.d }}
+          }
+        </div>
+      }
+
+      @if (probeActionSignal(); as probeAction) {
+        <div class="dbx-pt2">
+          <!-- dbxActionDisabled rather than the button's own disabled input, since dbxActionButton drives that from the action's state -->
+          <div dbxAction [dbxActionDisabled]="probeAction.disabled === true" [dbxActionHandler]="probeAction.handler" [dbxActionConfirm]="probeAction.confirm">
+            <dbx-button dbxActionButton [stroked]="true" [text]="probeAction.label" [icon]="probeAction.icon"></dbx-button>
+            <dbx-error dbxActionError></dbx-error>
+          </div>
+        </div>
+        @if (probeAction.notice) {
+          <div class="dbx-small dbx-hint dbx-pt2">{{ probeAction.notice }}</div>
+        }
+      }
+    }
+  `,
+                    host: {
+                        class: 'd-block dbx-firebase-notification-healthcheck-method'
+                    },
+                    standalone: true,
+                    imports: [DatePipe, DbxActionButtonDirective, DbxActionConfirmDirective, DbxActionDirective, DbxActionDisabledDirective, DbxActionErrorDirective, DbxActionHandlerDirective, DbxButtonComponent, DbxChipDirective, DbxColorDirective, DbxErrorComponent, DbxIconTileComponent, DbxFirebaseNotificationHealthCheckIssueComponent],
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], propDecorators: { result: [{ type: i0.Input, args: [{ isSignal: true, alias: "result", required: false }] }], probeAction: [{ type: i0.Input, args: [{ isSignal: true, alias: "probeAction", required: false }] }] } });
+
+/**
+ * Delivery methods this report never renders a section for, whatever the check says about them.
+ *
+ * The in-app summary channel is the app's own notification page, so the user is looking at the delivery
+ * target while they read the report — there is nothing a section could tell them that the page does not
+ * already show. The server has no health check service for it either, so it can currently only report
+ * "Not Checked", which reads as a broken channel next to a working inbox.
+ *
+ * The server still checks and stores the method, so an API/callModel consumer keeps the result. Drop the
+ * entry here to bring the section back if the server starts contributing findings worth acting on.
+ */
+const HIDDEN_NOTIFICATION_DELIVERY_METHODS = new Set([NotificationDeliveryMethod.NOTIFICATION_SUMMARY]);
+/**
+ * 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.
+ */
+class DbxFirebaseNotificationHealthCheckComponent {
+    _presentationService = inject(DbxFirebaseNotificationHealthCheckPresentationService);
+    healthCheck = input(...(ngDevMode ? [undefined, { debugName: "healthCheck" }] : /* istanbul ignore next */ []));
+    /**
+     * 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.
+     */
+    probeActions = input(...(ngDevMode ? [undefined, { debugName: "probeActions" }] : /* istanbul ignore next */ []));
+    statusColorSignal = computed(() => {
+        const status = this.healthCheck()?.s;
+        return status ? this._presentationService.colorForStatus(status) : 'grey';
+    }, ...(ngDevMode ? [{ debugName: "statusColorSignal" }] : /* istanbul ignore next */ []));
+    statusIconSignal = computed(() => {
+        const status = this.healthCheck()?.s;
+        return status ? this._presentationService.iconForStatus(status) : 'help';
+    }, ...(ngDevMode ? [{ debugName: "statusIconSignal" }] : /* istanbul ignore next */ []));
+    statusLabelSignal = computed(() => {
+        const status = this.healthCheck()?.s;
+        return status ? this._presentationService.labelForStatus(status) : '';
+    }, ...(ngDevMode ? [{ debugName: "statusLabelSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * 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}.
+     */
+    methodResultsSignal = computed(() => (this.healthCheck()?.m ?? []).filter((result) => !HIDDEN_NOTIFICATION_DELIVERY_METHODS.has(result.me) && !result.is.some((issue) => issue.c === KnownNotificationHealthCheckIssueCode.SEND_SERVICE_NOT_CONFIGURED)), ...(ngDevMode ? [{ debugName: "methodResultsSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * 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.
+     */
+    methodSectionsSignal = computed(() => {
+        const probeActions = this.probeActions();
+        return this.methodResultsSignal().map((result) => ({ result, probeAction: probeActions?.[result.me] }));
+    }, ...(ngDevMode ? [{ debugName: "methodSectionsSignal" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationHealthCheckComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.11", type: DbxFirebaseNotificationHealthCheckComponent, isStandalone: true, selector: "dbx-firebase-notification-healthcheck", inputs: { healthCheck: { classPropertyName: "healthCheck", publicName: "healthCheck", isSignal: true, isRequired: false, transformFunction: null }, probeActions: { classPropertyName: "probeActions", publicName: "probeActions", isSignal: true, isRequired: false, transformFunction: null } }, host: { classAttribute: "d-block dbx-firebase-notification-healthcheck" }, ngImport: i0, template: `
+    @if (healthCheck(); as healthCheckValue) {
+      <div class="dbx-flex-bar dbx-pb3">
+        <dbx-icon-tile class="dbx-icon-spacer" [icon]="statusIconSignal()" [dbxColor]="statusColorSignal()" [dbxColorTone]="18"></dbx-icon-tile>
+        <div class="dbx-flex-fill">
+          <div class="dbx-text-label-medium dbx-uppercase dbx-tracked-wide dbx-hint">Notification Delivery</div>
+          <div class="dbx-text-title-large">{{ statusLabelSignal() }}</div>
+          <div class="dbx-text-body-small dbx-hint">Last checked {{ healthCheckValue.at | date: 'medium' }}</div>
+        </div>
+      </div>
+
+      @for (methodSection of methodSectionsSignal(); track methodSection.result.me) {
+        <dbx-content-pit class="dbx-mb3">
+          <dbx-firebase-notification-healthcheck-method [result]="methodSection.result" [probeAction]="methodSection.probeAction"></dbx-firebase-notification-healthcheck-method>
+        </dbx-content-pit>
+      }
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: DbxColorDirective, selector: "[dbxColor]", inputs: ["dbxColor", "dbxColorTone"], outputs: ["dbxColorChange", "dbxColorToneChange"] }, { kind: "directive", type: DbxContentPitDirective, selector: "dbx-content-pit, [dbxContentPit]", inputs: ["scrollable", "square"] }, { kind: "component", type: DbxIconTileComponent, selector: "dbx-icon-tile", inputs: ["icon", "round"] }, { kind: "component", type: DbxFirebaseNotificationHealthCheckMethodComponent, selector: "dbx-firebase-notification-healthcheck-method", inputs: ["result", "probeAction"] }, { kind: "pipe", type: DatePipe, name: "date" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationHealthCheckComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-firebase-notification-healthcheck',
+                    template: `
+    @if (healthCheck(); as healthCheckValue) {
+      <div class="dbx-flex-bar dbx-pb3">
+        <dbx-icon-tile class="dbx-icon-spacer" [icon]="statusIconSignal()" [dbxColor]="statusColorSignal()" [dbxColorTone]="18"></dbx-icon-tile>
+        <div class="dbx-flex-fill">
+          <div class="dbx-text-label-medium dbx-uppercase dbx-tracked-wide dbx-hint">Notification Delivery</div>
+          <div class="dbx-text-title-large">{{ statusLabelSignal() }}</div>
+          <div class="dbx-text-body-small dbx-hint">Last checked {{ healthCheckValue.at | date: 'medium' }}</div>
+        </div>
+      </div>
+
+      @for (methodSection of methodSectionsSignal(); track methodSection.result.me) {
+        <dbx-content-pit class="dbx-mb3">
+          <dbx-firebase-notification-healthcheck-method [result]="methodSection.result" [probeAction]="methodSection.probeAction"></dbx-firebase-notification-healthcheck-method>
+        </dbx-content-pit>
+      }
+    }
+  `,
+                    host: {
+                        class: 'd-block dbx-firebase-notification-healthcheck'
+                    },
+                    standalone: true,
+                    imports: [DatePipe, DbxColorDirective, DbxContentPitDirective, DbxIconTileComponent, DbxFirebaseNotificationHealthCheckMethodComponent],
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], propDecorators: { healthCheck: [{ type: i0.Input, args: [{ isSignal: true, alias: "healthCheck", required: false }] }], probeActions: [{ type: i0.Input, args: [{ isSignal: true, alias: "probeActions", required: false }] }] } });
+
+/**
+ * Client-side service used for retrieving notification templates.
+ */
+class DbxFirebaseNotificationTemplateService {
+    appNotificationTemplateTypeInfoRecordService = inject(AppNotificationTemplateTypeInfoRecordService);
+    notificationItemSubjectMessagePairForNotificationSummaryItem(item) {
+        const templateType = item.t;
+        const templateDetails = this.appNotificationTemplateTypeInfoRecordService.appNotificationTemplateTypeInfoRecord[templateType];
+        const subject = item.s ?? templateDetails.name;
+        const message = item.g ?? '';
+        const date = item.cat;
+        return {
+            item,
+            subject,
+            message,
+            date
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationTemplateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationTemplateService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationTemplateService, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Selection list wrapper for notification items with view-only default selection mode.
+ */
+class DbxFirebaseNotificationItemListComponent extends AbstractDbxSelectionListWrapperDirective {
+    constructor() {
+        super({
+            componentClass: DbxFirebaseNotificationItemListViewComponent,
+            defaultSelectionMode: 'view'
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.11", type: DbxFirebaseNotificationItemListComponent, isStandalone: true, selector: "dbx-firebase-notificationitem-list", providers: provideDbxListViewWrapper(DbxFirebaseNotificationItemListComponent), usesInheritance: true, ngImport: i0, template: "\n  <dbx-list [state]=\"currentState$\" [config]=\"configSignal()\" [hasMore]=\"hasMore()\" [disabled]=\"disabledSignal()\" [selectionMode]=\"selectionModeSignal()\">\n    <ng-content top select=\"[top]\"></ng-content>\n    <ng-content bottom select=\"[bottom]\"></ng-content>\n    <ng-content empty select=\"[empty]\"></ng-content>\n    <ng-content emptyLoading select=\"[emptyLoading]\"></ng-content>\n    <ng-content end select=\"[end]\"></ng-content>\n  </dbx-list>", isInline: true, dependencies: [{ kind: "ngmodule", type: DbxListWrapperComponentImportsModule }, { kind: "component", type: i1$1.DbxListComponent, selector: "dbx-list", inputs: ["padded", "state", "config", "disabled", "selectionMode", "hasMore"], outputs: ["contentScrolled"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemListComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-firebase-notificationitem-list',
+                    template: DEFAULT_LIST_WRAPPER_COMPONENT_CONFIGURATION_TEMPLATE,
+                    imports: [DbxListWrapperComponentImportsModule],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    providers: provideDbxListViewWrapper(DbxFirebaseNotificationItemListComponent),
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+/**
+ * List view component that renders notification items using the selection list pattern.
+ */
+class DbxFirebaseNotificationItemListViewComponent extends AbstractDbxSelectionListViewDirective {
+    config = {
+        componentClass: DbxFirebaseNotificationItemListViewItemComponent,
+        mapValuesToItemValues: (x) => of(x.map((y) => ({ ...y, key: y.id, icon: y.icon, itemValue: y })))
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemListViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.11", type: DbxFirebaseNotificationItemListViewComponent, isStandalone: true, selector: "dbx-firebase-notificationitem-list-view", providers: provideDbxListView(DbxFirebaseNotificationItemListViewComponent), usesInheritance: true, ngImport: i0, template: "<dbx-selection-list-view [config]=\"config\"></dbx-selection-list-view>", isInline: true, dependencies: [{ kind: "ngmodule", type: DbxSelectionValueListViewComponentImportsModule }, { kind: "component", type: i1$1.DbxSelectionValueListViewComponent, selector: "dbx-selection-list-view" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemListViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-firebase-notificationitem-list-view',
+                    template: DEFAULT_DBX_SELECTION_VALUE_LIST_COMPONENT_CONFIGURATION_TEMPLATE,
+                    imports: [DbxSelectionValueListViewComponentImportsModule],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    providers: provideDbxListView(DbxFirebaseNotificationItemListViewComponent),
+                    standalone: true
+                }]
+        }] });
+/**
+ * Individual list view item component rendering a notification's subject, message, and date.
+ */
+class DbxFirebaseNotificationItemListViewItemComponent extends AbstractDbxValueListViewItemComponent {
+    dbxFirebaseNotificationTemplateService = inject(DbxFirebaseNotificationTemplateService);
+    pairGetter = cachedGetter(() => this.dbxFirebaseNotificationTemplateService.notificationItemSubjectMessagePairForNotificationSummaryItem(this.itemValue));
+    get subject() {
+        return this.pairGetter().subject;
+    }
+    get message() {
+        return this.pairGetter().message;
+    }
+    get date() {
+        return this.pairGetter().date;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemListViewItemComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.11", type: DbxFirebaseNotificationItemListViewItemComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: `
+    <div class="dbx-list-item-padded dbx-list-two-line-item dbx-firebase-notificationitem-list-view-item" role="article" [attr.aria-label]="subject">
+      <div class="item-left">
+        <span class="notificationitem-subject">{{ subject }}</span>
+        <span class="notificationitem-message item-details">{{ message | cutText: 90 }}</span>
+        <span class="notificationitem-date item-details-footnote">{{ date | date: 'medium' }}</span>
+      </div>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "pipe", type: DatePipe, name: "date" }, { kind: "pipe", type: CutTextPipe, name: "cutText" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemListViewItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <div class="dbx-list-item-padded dbx-list-two-line-item dbx-firebase-notificationitem-list-view-item" role="article" [attr.aria-label]="subject">
+      <div class="item-left">
+        <span class="notificationitem-subject">{{ subject }}</span>
+        <span class="notificationitem-message item-details">{{ message | cutText: 90 }}</span>
+        <span class="notificationitem-date item-details-footnote">{{ date | date: 'medium' }}</span>
+      </div>
+    </div>
+  `,
+                    imports: [DatePipe, CutTextPipe],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true
+                }]
+        }] });
+
+/**
+ * Presentational component for notification item content, displaying subject, message, and date.
+ */
+class DbxFirebaseNotificationItemContentComponent {
+    subject = input(...(ngDevMode ? [undefined, { debugName: "subject" }] : /* istanbul ignore next */ []));
+    message = input(...(ngDevMode ? [undefined, { debugName: "message" }] : /* istanbul ignore next */ []));
+    date = input(...(ngDevMode ? [undefined, { debugName: "date" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.11", type: DbxFirebaseNotificationItemContentComponent, isStandalone: true, selector: "dbx-firebase-notificationitem-content", inputs: { subject: { classPropertyName: "subject", publicName: "subject", isSignal: true, isRequired: false, transformFunction: null }, message: { classPropertyName: "message", publicName: "message", isSignal: true, isRequired: false, transformFunction: null }, date: { classPropertyName: "date", publicName: "date", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: "<div class=\"dbx-firebase-notificationitem-content\" role=\"article\" [attr.aria-label]=\"subject()\">\n  <div class=\"notificationitem-header dbx-pb2\">\n    @if (subject()) {\n      <div class=\"notificationitem-subject dbx-pb1\">{{ subject() }}</div>\n    }\n    <ng-content select=\"[header]\"></ng-content>\n    @if (date()) {\n      <div class=\"notificationitem-date dbx-label dbx-small\">{{ date() | date: 'medium' }}</div>\n    }\n  </div>\n  <ng-content select=\"[premessage]\"></ng-content>\n  <div class=\"notificationitem-message\">{{ message() }}</div>\n  <ng-content></ng-content>\n</div>\n", styles: [".dbx-firebase-notificationitem-content .notificationitem-subject{font-size:1.25em}\n"], dependencies: [{ kind: "pipe", type: DatePipe, name: "date" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationItemContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dbx-firebase-notificationitem-content', imports: [DatePipe], changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, template: "<div class=\"dbx-firebase-notificationitem-content\" role=\"article\" [attr.aria-label]=\"subject()\">\n  <div class=\"notificationitem-header dbx-pb2\">\n    @if (subject()) {\n      <div class=\"notificationitem-subject dbx-pb1\">{{ subject() }}</div>\n    }\n    <ng-content select=\"[header]\"></ng-content>\n    @if (date()) {\n      <div class=\"notificationitem-date dbx-label dbx-small\">{{ date() | date: 'medium' }}</div>\n    }\n  </div>\n  <ng-content select=\"[premessage]\"></ng-content>\n  <div class=\"notificationitem-message\">{{ message() }}</div>\n  <ng-content></ng-content>\n</div>\n", styles: [".dbx-firebase-notificationitem-content .notificationitem-subject{font-size:1.25em}\n"] }]
+        }], propDecorators: { subject: [{ type: i0.Input, args: [{ isSignal: true, alias: "subject", required: false }] }], message: [{ type: i0.Input, args: [{ isSignal: true, alias: "message", required: false }] }], date: [{ type: i0.Input, args: [{ isSignal: true, alias: "date", required: false }] }] } });
+
+/**
+ * Prefix used by all widgets.
+ *
+ * Does not include the "-" between the prefix and the template type returned by dbxWidgetTypeForNotificationTemplateType().
+ */
+const FIREBASE_NOTIFICATION_ITEM_WIDGET_TYPE_PREFIX = 'dbxFirebaseNotificationItem';
+const DEFAULT_FIREBASE_NOTIFICATION_ITEM_WIDGET_TYPE = `${FIREBASE_NOTIFICATION_ITEM_WIDGET_TYPE_PREFIX}Default`;
+/**
+ * Derives the widget type string for a given notification template type by prepending the standard prefix.
+ *
+ * @param notificationTemplateType - The notification template type to generate a widget type for.
+ * @returns The prefixed widget type string.
+ */
+function dbxWidgetTypeForNotificationTemplateType(notificationTemplateType) {
+    return `${FIREBASE_NOTIFICATION_ITEM_WIDGET_TYPE_PREFIX}-${notificationTemplateType}`;
+}
+
+/**
+ * Service used for registering widgets used for notification items.
+ */
+class DbxFirebaseNotificationItemWidgetService {
+    dbxWidgetService = inject(DbxWidgetService);
+    dbxFirebaseNotificationTemplateService = inject(DbxFirebaseNotificationTemplateService);
+    _entries = new Map();
+    /**
+     * Used to register a item widget. If widget for the given type is already registered, this will override it by default.
+     *
+     * @param provider - The notification item widget entry to register.
+     * @param override - Whether to override an existing widget for the same notification template type. Defaults to true.
+     * @returns True if the widget was registered, false if it already existed and override was false or the template type was unknown.
+     */
+    register(provider, override = true) {
+        const { componentClass, notificationTemplateType } = provider;
+        const widgetType = dbxWidgetTypeForNotificationTemplateType(notificationTemplateType);
+        let result = false;
+        if (override || !this._entries.has(notificationTemplateType)) {
+            const notificationTemplateTypeInfo = this.dbxFirebaseNotificationTemplateService.appNotificationTemplateTypeInfoRecordService.appNotificationTemplateTypeInfoRecord[notificationTemplateType];
+            if (notificationTemplateTypeInfo) {
+                const entry = {
+                    notificationTemplateType,
                     notificationTemplateTypeInfo,
                     widget: {
                         type: widgetType,
@@ -6460,6 +8207,529 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
                 }]
         }] });
 
+/**
+ * Document store for a single NotificationUser with update, resync, and health check functions.
+ */
+class NotificationUserDocumentStore extends AbstractDbxFirebaseDocumentStore {
+    notificationFunctions = inject(NotificationFunctions);
+    constructor() {
+        super({ firestoreCollection: inject(NotificationFirestoreCollections).notificationUserCollection });
+    }
+    updateNotificationUser = firebaseDocumentStoreUpdateFunction(this, this.notificationFunctions.notificationUser.updateNotificationUser.update);
+    resyncNotificationUser = firebaseDocumentStoreUpdateFunction(this, this.notificationFunctions.notificationUser.updateNotificationUser.resync);
+    /**
+     * 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.
+     */
+    healthCheck = firebaseDocumentStoreInvokeFunction(this, this.notificationFunctions.notificationUser.invokeNotificationUser.healthCheck);
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: NotificationUserDocumentStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: NotificationUserDocumentStore });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: NotificationUserDocumentStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+/**
+ * Counts down the seconds until the input time, once per second.
+ *
+ * Emits 0 and stops ticking as soon as the time passes, so nothing keeps counting while the action it
+ * gates is available. A null input means there is nothing to wait for.
+ *
+ * @param date$ - The time being waited for.
+ * @returns The seconds remaining, counting down to 0.
+ */
+function secondsRemainingUntil(date$) {
+    return date$.pipe(switchMap((date) => date == null
+        ? of(0)
+        : timer(0, 1000).pipe(map(() => Math.max(0, Math.ceil((date.getTime() - Date.now()) / 1000))), takeWhile((secondsRemaining) => secondsRemaining > 0, true))), distinctUntilChanged(), shareReplay(1));
+}
+/**
+ * Counts down the seconds until each delivery method's time, once per second.
+ *
+ * The per-method form of {@link secondsRemainingUntil}. One timer drives every method, so several open
+ * countdowns tick in step rather than drifting apart, and the ticking stops once every window has
+ * passed. A method with nothing to wait for is left out.
+ *
+ * @param datesByMethod$ - The time being waited for on each method.
+ * @returns The seconds remaining per method, counting down to 0.
+ */
+function secondsRemainingUntilByMethod(datesByMethod$) {
+    return datesByMethod$.pipe(switchMap((datesByMethod) => {
+        const pendingEntries = Object.entries(datesByMethod).filter(([, date]) => date != null);
+        return pendingEntries.length === 0
+            ? of({})
+            : timer(0, 1000).pipe(map(() => {
+                const secondsRemainingByMethod = {};
+                pendingEntries.forEach(([method, date]) => {
+                    secondsRemainingByMethod[method] = Math.max(0, Math.ceil((date.getTime() - Date.now()) / 1000));
+                });
+                return secondsRemainingByMethod;
+            }), 
+            // emit the all-zero value, then stop: every window has passed
+            takeWhile((secondsRemainingByMethod) => Object.values(secondsRemainingByMethod).some((x) => x > 0), true));
+    }), distinctUntilChanged(areEqualPOJOValues), shareReplay(1));
+}
+/**
+ * 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.
+ */
+class DbxFirebaseNotificationUserHealthCheckStore extends ComponentStore {
+    notificationUserDocumentStore = inject(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.
+     */
+    _config = inject(DbxFirebaseNotificationHealthCheckConfig, { optional: true });
+    constructor() {
+        super({});
+    }
+    // MARK: Accessors
+    /**
+     * Whether the NotificationUser being checked exists.
+     *
+     * There is nothing to check until notifications have been set up for the account.
+     */
+    exists$ = this.notificationUserDocumentStore.currentExists$;
+    /**
+     * The health check stored on the document.
+     *
+     * The check is persisted on every run, so the most recent one renders without invoking anything.
+     */
+    healthCheck$ = this.notificationUserDocumentStore.data$.pipe(map((x) => x.hc), distinctUntilChanged(), shareReplay(1));
+    /**
+     * 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.
+     */
+    healthCheckResultState$ = this.select((state) => state.healthCheckResultState).pipe(distinctUntilChanged(), shareReplay(1));
+    /**
+     * 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.
+     */
+    latestHealthCheckResult$ = this.healthCheckResultState$.pipe(map((x) => x?.value), distinctUntilChanged(), shareReplay(1));
+    // MARK: Throttle
+    /**
+     * The earliest time another run is allowed, derived from the check stored on the document.
+     *
+     * Undefined until a check has been run.
+     */
+    nextRunAt$ = this.healthCheck$.pipe(map((healthCheck) => notificationUserHealthCheckNextRunAt({ healthCheck, throttleMinutes: this._config?.runThrottleMinutes })), distinctUntilChanged((a, b) => a?.getTime() === b?.getTime()), shareReplay(1));
+    /**
+     * 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.
+     */
+    nextProbeAtByMethod$ = this.healthCheck$.pipe(map((healthCheck) => notificationUserHealthCheckNextProbeAtByMethod({ healthCheck, throttleMinutes: this._config?.probeThrottleMinutes })), distinctUntilChanged(areEqualPOJOValues), shareReplay(1));
+    /**
+     * How long until another run is allowed, counting down once per second.
+     */
+    throttleSecondsRemaining$ = secondsRemainingUntil(this.nextRunAt$);
+    /**
+     * 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.
+     */
+    probeThrottleSecondsRemainingByMethod$ = secondsRemainingUntilByMethod(this.nextProbeAtByMethod$);
+    /**
+     * 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.
+     */
+    isThrottled$ = this.throttleSecondsRemaining$.pipe(map((secondsRemaining) => secondsRemaining > 0), distinctUntilChanged(), shareReplay(1));
+    // MARK: Pending Probes
+    /**
+     * 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.
+     */
+    pendingProbeMethods$ = this.healthCheck$.pipe(map((healthCheck) => notificationHealthCheckPendingProbeMethods(healthCheck)), distinctUntilChanged(areEqualPOJOValues), shareReplay(1));
+    /**
+     * Whether a test message is in flight right now.
+     */
+    hasPendingProbe$ = this.pendingProbeMethods$.pipe(map((x) => x.length > 0), distinctUntilChanged(), shareReplay(1));
+    /**
+     * 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.
+     */
+    _nextProbeVerification$ = this.healthCheck$.pipe(map((healthCheck) => {
+        const methods = notificationHealthCheckPendingProbeMethods(healthCheck);
+        const dispatchedAt = filterMaybeArrayValues((healthCheck?.m ?? []).filter((x) => methods.includes(x.me)).map((x) => x.pr?.at));
+        const watchMinutes = this._config?.probeWatchMinutes ?? DEFAULT_NOTIFICATION_HEALTH_CHECK_PROBE_WATCH_MINUTES;
+        const oldestDispatchedAt = dispatchedAt.length ? new Date(Math.min(...dispatchedAt.map((x) => x.getTime()))) : undefined;
+        const at = notificationUserHealthCheckNextVerifyAt({ healthCheck, throttleSeconds: this._config?.verifyThrottleSeconds }) ?? new Date();
+        const stillWorthWatching = oldestDispatchedAt != null && isAfter(addMinutes(oldestDispatchedAt, watchMinutes), at);
+        return stillWorthWatching ? { methods, at } : undefined;
+    }), distinctUntilChanged(areEqualPOJOValues), shareReplay(1));
+    // MARK: State Changes
+    _setHealthCheckResultState = this.updater((state, healthCheckResultState) => ({ ...state, healthCheckResultState }));
+    // MARK: Effects
+    /**
+     * 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.
+     */
+    runHealthCheck = this.effect((input) => input.pipe(exhaustMap((params) => this.notificationUserDocumentStore.healthCheck(params ?? {}).pipe(startWithBeginLoading(), // emit loading synchronously so a dispatcher can pick this run up off the state
+    catchError((error) => of(errorResult(error))), // an error here would otherwise kill this effect's subscription
+    tap((healthCheckResultState) => this._setHealthCheckResultState(healthCheckResultState))))));
+    /**
+     * 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.
+     */
+    watchPendingProbes = this.effect((input) => input.pipe(switchMap(() => this._nextProbeVerification$.pipe(
+    // The interval is the recovery path: a verification that advances `vat` re-emits the value
+    // above and restarts this timer, while one that fails to reach the server leaves the value
+    // unchanged and is simply retried on the next tick.
+    switchMap((verification) => (verification == null ? EMPTY : timer(Math.max(0, verification.at.getTime() - Date.now()), (this._config?.verifyThrottleSeconds ?? DEFAULT_NOTIFICATION_USER_HEALTH_CHECK_VERIFY_THROTTLE_SECONDS) * MS_IN_SECOND).pipe(map(() => verification.methods)))), withLatestFrom(this.healthCheckResultState$), 
+    // A verification carries the whole stored check forward, so one racing a run the user started
+    // could write back a copy taken before that run's result landed. The user's run always wins.
+    filter(([, healthCheckResultState]) => healthCheckResultState?.loading !== true), exhaustMap(([methods]) => this.notificationUserDocumentStore.healthCheck({ verifyPendingProbesOnly: true, methods }).pipe(catchError(() => EMPTY) // nothing to report: the poll is invisible, and the next tick retries
+    ))))));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationUserHealthCheckStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationUserHealthCheckStore });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationUserHealthCheckStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+/**
+ * Formats a throttle countdown for display.
+ *
+ * @param secondsRemaining - Seconds left in the window.
+ * @returns A short duration, e.g. `9m 12s` or `43s`.
+ */
+function formatSecondsRemaining(secondsRemaining) {
+    const minutes = Math.floor(secondsRemaining / 60);
+    const minutesPrefix = minutes > 0 ? `${minutes}m ` : '';
+    return `${minutesPrefix}${secondsRemaining % 60}s`;
+}
+/**
+ * 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.
+ */
+class DbxFirebaseNotificationHealthCheckViewComponent {
+    _presentationService = inject(DbxFirebaseNotificationHealthCheckPresentationService);
+    healthCheckStore = inject(DbxFirebaseNotificationUserHealthCheckStore);
+    existsSignal = toSignal(this.healthCheckStore.exists$, { initialValue: false });
+    healthCheckSignal = toSignal(this.healthCheckStore.healthCheck$);
+    latestHealthCheckResultSignal = toSignal(this.healthCheckStore.latestHealthCheckResult$);
+    throttleSecondsRemainingSignal = toSignal(this.healthCheckStore.throttleSecondsRemaining$, { initialValue: 0 });
+    isThrottledSignal = toSignal(this.healthCheckStore.isThrottled$, { initialValue: false });
+    probeThrottleSecondsRemainingByMethodSignal = toSignal(this.healthCheckStore.probeThrottleSecondsRemainingByMethod$, { initialValue: {} });
+    _lastRequestedProbeMethod = signal(undefined, ...(ngDevMode ? [{ debugName: "_lastRequestedProbeMethod" }] : /* istanbul ignore next */ []));
+    constructor() {
+        // The report is streamed from the document, so an outcome the server settles shows up on its own.
+        // This is what makes the server settle it without the user asking.
+        this.healthCheckStore.watchPendingProbes();
+    }
+    /**
+     * 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.
+     */
+    lastRequestedProbeMethodSignal = this._lastRequestedProbeMethod.asReadonly();
+    /**
+     * 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.
+     */
+    _sendTestMessageHandlers = new Map(ALL_NOTIFICATION_DELIVERY_METHODS.map((method) => [
+        method,
+        (_, context) => {
+            this._lastRequestedProbeMethod.set(method);
+            this.runHealthCheckAsWork(context, { sendProbe: true, methods: [method] });
+        }
+    ]));
+    /**
+     * Explains why "Run Check" is disabled while the server's run throttle is in effect.
+     */
+    throttleNoticeSignal = computed(() => {
+        const secondsRemaining = this.throttleSecondsRemainingSignal();
+        return secondsRemaining > 0 ? `This was checked a moment ago. Another check can be run in ${formatSecondsRemaining(secondsRemaining)}.` : undefined;
+    }, ...(ngDevMode ? [{ debugName: "throttleNoticeSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * 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.
+     */
+    probeActionsSignal = computed(() => {
+        const secondsRemainingByMethod = this.probeThrottleSecondsRemainingByMethodSignal();
+        const justSentMethod = this.latestHealthCheckResultSignal()?.probesDispatched ? this.lastRequestedProbeMethodSignal() : undefined;
+        const probeActions = {};
+        (this.healthCheckSignal()?.m ?? [])
+            .filter((methodResult) => methodResult.pb === true)
+            .forEach(({ me: method, tg: target, pr: probe }) => {
+            const label = this._presentationService.testMessageLabelForDeliveryMethod(method);
+            const noun = this._presentationService.testMessageNounForDeliveryMethod(method);
+            const methodLabel = this._presentationService.labelForDeliveryMethod(method).toLowerCase();
+            const secondsRemaining = secondsRemainingByMethod[method] ?? 0;
+            probeActions[method] = {
+                label,
+                icon: 'send',
+                disabled: secondsRemaining > 0,
+                notice: this.probeNoticeForMethod({ noun, secondsRemaining, justSent: method === justSentMethod, pending: probe?.s === NotificationHealthCheckStatus.PENDING }),
+                confirm: {
+                    title: label,
+                    prompt: `This sends a real ${methodLabel} to ${target ?? 'your contact details'} so we can confirm whether it arrives. Continue?`,
+                    confirmText: label
+                },
+                handler: this._sendTestMessageHandlers.get(method)
+            };
+        });
+        return probeActions;
+    }, ...(ngDevMode ? [{ debugName: "probeActionsSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * 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.
+     */
+    probeNoticeForMethod(input) {
+        const { noun, secondsRemaining, justSent, pending } = input;
+        const sent = justSent ? `A ${noun} was just sent.` : secondsRemaining > 0 ? `A ${noun} was sent recently.` : undefined;
+        const waiting = pending ? ' The result will appear here on its own as soon as we hear whether it arrived.' : '';
+        const nextAllowed = secondsRemaining > 0 ? ` Another can be sent in ${formatSecondsRemaining(secondsRemaining)}.` : '';
+        return sent == null ? undefined : `${sent}${waiting}${nextAllowed}`;
+    }
+    handleRunHealthCheck = (_, context) => {
+        this.runHealthCheckAsWork(context, {});
+    };
+    /**
+     * 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.
+     */
+    runHealthCheckAsWork(context, params) {
+        this.healthCheckStore.runHealthCheck(params);
+        context.startWorkingWithLoadingStateObservable(this.healthCheckStore.healthCheckResultState$);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationHealthCheckViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.11", type: DbxFirebaseNotificationHealthCheckViewComponent, isStandalone: true, selector: "dbx-firebase-notification-healthcheck-view", host: { classAttribute: "d-block dbx-firebase-notification-healthcheck-view" }, providers: [DbxFirebaseNotificationUserHealthCheckStore], ngImport: i0, template: `
+    @if (existsSignal()) {
+      @if (healthCheckSignal(); as healthCheck) {
+        <dbx-firebase-notification-healthcheck [healthCheck]="healthCheck" [probeActions]="probeActionsSignal()"></dbx-firebase-notification-healthcheck>
+      } @else {
+        <dbx-content-pit class="dbx-mb3">
+          <p class="dbx-hint no-margin">Your notification delivery has not been checked yet. Run a check to find out why you may not be receiving notifications.</p>
+        </dbx-content-pit>
+      }
+
+      <div class="dbx-flex-bar">
+        <!-- the action takes no input, so the bare dbxActionValue marks it value-ready on trigger -->
+        <!-- dbxActionDisabled rather than the button's own disabled input, since dbxActionButton drives that from the action's state -->
+        <div dbxAction dbxActionValue [dbxActionDisabled]="isThrottledSignal()" [dbxActionHandler]="handleRunHealthCheck">
+          <dbx-button dbxActionButton [stroked]="true" text="Run Check" icon="refresh"></dbx-button>
+          <dbx-error dbxActionError></dbx-error>
+        </div>
+      </div>
+      <div>
+        @if (throttleNoticeSignal(); as throttleNotice) {
+          <div class="dbx-small dbx-hint dbx-pt2">{{ throttleNotice }}</div>
+        }
+      </div>
+    } @else {
+      <dbx-content-pit>
+        <p class="dbx-hint no-margin">Notification settings have not been set up for this account yet, so there is nothing to check.</p>
+      </dbx-content-pit>
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: DbxActionButtonDirective, selector: "[dbxActionButton]", inputs: ["dbxActionButtonEcho"] }, { kind: "directive", type: DbxActionDirective, selector: "dbx-action,[dbxAction]", exportAs: ["action", "dbxAction"] }, { kind: "directive", type: DbxActionDisabledDirective, selector: "[dbxActionDisabled]", inputs: ["dbxActionDisabled"] }, { kind: "directive", type: DbxActionErrorDirective, selector: "[dbxActionError]" }, { kind: "directive", type: DbxActionHandlerDirective, selector: "[dbxActionHandler]", inputs: ["dbxActionHandler"] }, { kind: "directive", type: DbxActionValueDirective, selector: "dbxActionValue,[dbxActionValue]", inputs: ["dbxActionValue"] }, { kind: "component", type: DbxButtonComponent, selector: "dbx-button", inputs: ["bar", "type", "buttonStyle", "color", "spinnerColor", "customButtonColor", "customTextColor", "customSpinnerColor", "basic", "tonal", "raised", "stroked", "flat", "iconOnly", "fab", "customContent", "allowClickPropagation", "mode"] }, { kind: "directive", type: DbxContentPitDirective, selector: "dbx-content-pit, [dbxContentPit]", inputs: ["scrollable", "square"] }, { kind: "component", type: DbxErrorComponent, selector: "dbx-error", inputs: ["error", "iconOnly"], outputs: ["popoverOpened"] }, { kind: "component", type: DbxFirebaseNotificationHealthCheckComponent, selector: "dbx-firebase-notification-healthcheck", inputs: ["healthCheck", "probeActions"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationHealthCheckViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-firebase-notification-healthcheck-view',
+                    template: `
+    @if (existsSignal()) {
+      @if (healthCheckSignal(); as healthCheck) {
+        <dbx-firebase-notification-healthcheck [healthCheck]="healthCheck" [probeActions]="probeActionsSignal()"></dbx-firebase-notification-healthcheck>
+      } @else {
+        <dbx-content-pit class="dbx-mb3">
+          <p class="dbx-hint no-margin">Your notification delivery has not been checked yet. Run a check to find out why you may not be receiving notifications.</p>
+        </dbx-content-pit>
+      }
+
+      <div class="dbx-flex-bar">
+        <!-- the action takes no input, so the bare dbxActionValue marks it value-ready on trigger -->
+        <!-- dbxActionDisabled rather than the button's own disabled input, since dbxActionButton drives that from the action's state -->
+        <div dbxAction dbxActionValue [dbxActionDisabled]="isThrottledSignal()" [dbxActionHandler]="handleRunHealthCheck">
+          <dbx-button dbxActionButton [stroked]="true" text="Run Check" icon="refresh"></dbx-button>
+          <dbx-error dbxActionError></dbx-error>
+        </div>
+      </div>
+      <div>
+        @if (throttleNoticeSignal(); as throttleNotice) {
+          <div class="dbx-small dbx-hint dbx-pt2">{{ throttleNotice }}</div>
+        }
+      </div>
+    } @else {
+      <dbx-content-pit>
+        <p class="dbx-hint no-margin">Notification settings have not been set up for this account yet, so there is nothing to check.</p>
+      </dbx-content-pit>
+    }
+  `,
+                    host: {
+                        class: 'd-block dbx-firebase-notification-healthcheck-view'
+                    },
+                    standalone: true,
+                    imports: [DbxActionButtonDirective, DbxActionDirective, DbxActionDisabledDirective, DbxActionErrorDirective, DbxActionHandlerDirective, DbxActionValueDirective, DbxButtonComponent, DbxContentPitDirective, DbxErrorComponent, DbxFirebaseNotificationHealthCheckComponent],
+                    providers: [DbxFirebaseNotificationUserHealthCheckStore],
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Dialog wrapper around {@link DbxFirebaseNotificationHealthCheckViewComponent}.
+ */
+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, config) {
+        return matDialog.open(DbxFirebaseNotificationHealthCheckDialogComponent, {
+            // a report with several delivery methods can exceed the viewport. Material inherits the pane's
+            // max-height down to the dialog surface, which already scrolls, so capping it here keeps the
+            // actions reachable. A percentage cap would not work, as the pane's height is not definite.
+            maxHeight: 'calc(var(--vh100) * 0.9)',
+            injector: config?.injector
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationHealthCheckDialogComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.11", type: DbxFirebaseNotificationHealthCheckDialogComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: `
+    <dbx-dialog-content>
+      <dbx-firebase-notification-healthcheck-view></dbx-firebase-notification-healthcheck-view>
+    </dbx-dialog-content>
+  `, isInline: true, dependencies: [{ kind: "directive", type: DbxDialogContentDirective, selector: "dbx-dialog-content,[dbxDialogContent],.dbx-dialog-content", inputs: ["width"] }, { kind: "component", type: DbxFirebaseNotificationHealthCheckViewComponent, selector: "dbx-firebase-notification-healthcheck-view" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationHealthCheckDialogComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <dbx-dialog-content>
+      <dbx-firebase-notification-healthcheck-view></dbx-firebase-notification-healthcheck-view>
+    </dbx-dialog-content>
+  `,
+                    standalone: true,
+                    imports: [DbxDialogContentDirective, DbxFirebaseNotificationHealthCheckViewComponent],
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }] });
+
+/**
+ * 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.
+ */
+class DbxFirebaseNotificationHealthCheckDialogButtonComponent {
+    _matDialog = inject(MatDialog);
+    _injector = inject(Injector);
+    config = input(...(ngDevMode ? [undefined, { debugName: "config" }] : /* istanbul ignore next */ []));
+    text = input(...(ngDevMode ? [undefined, { debugName: "text" }] : /* istanbul ignore next */ []));
+    icon = input(...(ngDevMode ? [undefined, { debugName: "icon" }] : /* istanbul ignore next */ []));
+    textSignal = computed(() => {
+        const config = this.config();
+        return this.text() ?? config?.text ?? 'Check Notification Delivery';
+    }, ...(ngDevMode ? [{ debugName: "textSignal" }] : /* istanbul ignore next */ []));
+    iconSignal = computed(() => {
+        const config = this.config();
+        return this.icon() ?? config?.icon ?? 'monitor_heart';
+    }, ...(ngDevMode ? [{ debugName: "iconSignal" }] : /* istanbul ignore next */ []));
+    openHealthCheckDialog() {
+        // the dialog renders outside this component's view, so its injector has to be handed over for the
+        // NotificationUserDocumentStore to resolve inside it
+        DbxFirebaseNotificationHealthCheckDialogComponent.openDialog(this._matDialog, { injector: this._injector });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationHealthCheckDialogButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.11", type: DbxFirebaseNotificationHealthCheckDialogButtonComponent, isStandalone: true, selector: "dbx-firebase-notification-healthcheck-dialog-button", inputs: { config: { classPropertyName: "config", publicName: "config", isSignal: true, isRequired: false, transformFunction: null }, text: { classPropertyName: "text", publicName: "text", isSignal: true, isRequired: false, transformFunction: null }, icon: { classPropertyName: "icon", publicName: "icon", isSignal: true, isRequired: false, transformFunction: null } }, host: { classAttribute: "dbx-firebase-notification-healthcheck-dialog-button" }, ngImport: i0, template: `
+    <dbx-button [stroked]="true" [text]="textSignal()" [icon]="iconSignal()" (buttonClick)="openHealthCheckDialog()"></dbx-button>
+  `, isInline: true, dependencies: [{ kind: "component", type: DbxButtonComponent, selector: "dbx-button", inputs: ["bar", "type", "buttonStyle", "color", "spinnerColor", "customButtonColor", "customTextColor", "customSpinnerColor", "basic", "tonal", "raised", "stroked", "flat", "iconOnly", "fab", "customContent", "allowClickPropagation", "mode"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxFirebaseNotificationHealthCheckDialogButtonComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-firebase-notification-healthcheck-dialog-button',
+                    template: `
+    <dbx-button [stroked]="true" [text]="textSignal()" [icon]="iconSignal()" (buttonClick)="openHealthCheckDialog()"></dbx-button>
+  `,
+                    host: {
+                        class: 'dbx-firebase-notification-healthcheck-dialog-button'
+                    },
+                    standalone: true,
+                    imports: [DbxButtonComponent],
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], propDecorators: { config: [{ type: i0.Input, args: [{ isSignal: true, alias: "config", required: false }] }], text: [{ type: i0.Input, args: [{ isSignal: true, alias: "text", required: false }] }], icon: [{ type: i0.Input, args: [{ isSignal: true, alias: "icon", required: false }] }] } });
+
 const DEFAULT_DBX_FIREBASE_NOTIFICATION_ITEM_STORE_POPOVER_KEY = 'notification-item-store-notifications';
 class DbxFirebaseNotificationItemStorePopoverComponent extends AbstractPopoverDirective {
     static openPopover(popupService, { origin, header, icon, emptyText, makeNotificationItemAnchor, notificationItemsLoadingState$ }, popoverKey) {
@@ -6825,23 +9095,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
                 }]
         }], ctorParameters: () => [] });
 
-/**
- * Document store for a single NotificationUser with update and resync functions.
- */
-class NotificationUserDocumentStore extends AbstractDbxFirebaseDocumentStore {
-    notificationFunctions = inject(NotificationFunctions);
-    constructor() {
-        super({ firestoreCollection: inject(NotificationFirestoreCollections).notificationUserCollection });
-    }
-    updateNotificationUser = firebaseDocumentStoreUpdateFunction(this, this.notificationFunctions.notificationUser.updateNotificationUser.update);
-    resyncNotificationUser = firebaseDocumentStoreUpdateFunction(this, this.notificationFunctions.notificationUser.updateNotificationUser.resync);
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: NotificationUserDocumentStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: NotificationUserDocumentStore });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: NotificationUserDocumentStore, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
 /**
  * Directive providing a {@link NotificationUserDocumentStore} for accessing a single notification user document.
  */
@@ -6868,7 +9121,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
  * @returns EnvironmentProviders.
  */
 function provideDbxFirebaseNotifications(config) {
-    const { appNotificationTemplateTypeInfoRecordService } = config;
+    const { appNotificationTemplateTypeInfoRecordService, healthCheckPresentation, healthCheck } = config;
     const providers = [
         {
             provide: AppNotificationTemplateTypeInfoRecordService,
@@ -6894,6 +9147,18 @@ function provideDbxFirebaseNotifications(config) {
             }
         })
     ];
+    if (healthCheckPresentation) {
+        providers.push({
+            provide: DbxFirebaseNotificationHealthCheckPresentationServiceConfig,
+            useValue: healthCheckPresentation
+        });
+    }
+    if (healthCheck) {
+        providers.push({
+            provide: DbxFirebaseNotificationHealthCheckConfig,
+            useValue: healthCheck
+        });
+    }
     return makeEnvironmentProviders(providers);
 }
 
@@ -7252,7 +9517,7 @@ class DbxFirebaseStorageFileDownloadButtonComponent {
         if (downloadUrl || downloadUrl === null) {
             this.downloadUrlSignal.set(downloadUrl);
         }
-    }, { ...(ngDevMode ? { debugName: "storageFileDownloadUrlEffect" } : /* istanbul ignore next */ {}), allowSignalWrites: true });
+    }, ...(ngDevMode ? [{ debugName: "storageFileDownloadUrlEffect" }] : /* istanbul ignore next */ []));
     // Preview
     showPreviewButtonSignal = computed(() => {
         const config = this.configSignal();
@@ -7286,7 +9551,7 @@ class DbxFirebaseStorageFileDownloadButtonComponent {
             this.downloadMimeTypeSignal.set(cachedPair.mimeType);
             this.downloadUrlExpiresAtSignal.set(cachedPair.expiresAt);
         }
-    }, { ...(ngDevMode ? { debugName: "cachedUrlEffect" } : /* istanbul ignore next */ {}), allowSignalWrites: true });
+    }, ...(ngDevMode ? [{ debugName: "cachedUrlEffect" }] : /* istanbul ignore next */ []));
     // Expiration Effect
     downloadUrlExpiresAtDate$ = toObservable(this.downloadUrlExpiresAtSignal).pipe(map(dateFromDateOrTimeSecondsNumber), distinctUntilChanged(isSameDate), shareReplay(1));
     downloadUrlExpiresAtDateSignal = toSignal(this.downloadUrlExpiresAtDate$);
@@ -7308,7 +9573,7 @@ class DbxFirebaseStorageFileDownloadButtonComponent {
             this.downloadMimeTypeSignal.set(undefined);
             this.downloadUrlExpiresAtSignal.set(undefined);
         }
-    }, { ...(ngDevMode ? { debugName: "downloadUrlHasExpiredEffect" } : /* istanbul ignore next */ {}), allowSignalWrites: true });
+    }, ...(ngDevMode ? [{ debugName: "downloadUrlHasExpiredEffect" }] : /* istanbul ignore next */ []));
     // Output Effect
     downloadDetailsSignal = computed(() => {
         const downloadUrl = this.downloadUrlSignal();
@@ -7333,7 +9598,7 @@ class DbxFirebaseStorageFileDownloadButtonComponent {
         if (source?.downloadDetailsChangeCallback) {
             source.downloadDetailsChangeCallback(details);
         }
-    }, { ...(ngDevMode ? { debugName: "sourceDownloadDetailsChangeCallbackEffect" } : /* istanbul ignore next */ {}), allowSignalWrites: true });
+    }, ...(ngDevMode ? [{ debugName: "sourceDownloadDetailsChangeCallbackEffect" }] : /* istanbul ignore next */ []));
     // Handlers
     handleGetDownloadUrl = (value, context) => {
         const source = this.source();
@@ -8495,5 +10760,5 @@ function provideDbxFirebase(config) {
  * Generated bundle index. Do not edit.
  */
 
-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 { 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 };
 //# sourceMappingURL=dereekb-dbx-firebase.mjs.map