@dereekb/dbx-firebase 13.31.0 → 13.32.0

package/fesm2022/dereekb-dbx-firebase.mjs

@@ -1,19 +1,19 @@
 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, 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, DbxChipDirective, DbxColorDirective, DbxIconTileComponent, DbxActionConfirmDirective, 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, 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';
@@ -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])))));
         }
@@ -6182,6 +6262,648 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
                 }]
         }] });
 
+/**
+ * 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"] }, { 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"] }, { 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"] }, { 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.
  */
@@ -6460,6 +7182,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 +8070,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 +8096,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 +8122,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 +8492,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 +8526,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 +8548,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 +8573,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 +9735,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_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, 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, 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, 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, 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, notificationHealthCheckProbeIssueLabel, 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 };
 //# sourceMappingURL=dereekb-dbx-firebase.mjs.map