@dereekb/firebase 13.11.2 → 13.11.4

package/src/lib/common/model/model.service.d.ts

@@ -47,6 +47,7 @@ export interface FirebaseModelServiceConfig<C extends FirebaseModelServiceContex
  *   roleMapForModel: (output, context, model) => computeRoles(output, context)
  * });
  * ```
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function firebaseModelService<C extends FirebaseModelServiceContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends GrantedRole = GrantedRole>(config: FirebaseModelServiceConfig<C, T, D, R>): FirebaseModelService<C, T, D, R>;
 /**
@@ -58,6 +59,7 @@ export type FirebaseModelServiceFactory<C extends FirebaseModelServiceContext, T
  *
  * @param config - the service configuration
  * @returns a {@link FirebaseModelServiceFactory} that lazily creates and caches the service
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function firebaseModelServiceFactory<C extends FirebaseModelServiceContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends GrantedRole = GrantedRole>(config: FirebaseModelServiceConfig<C, T, D, R>): FirebaseModelServiceFactory<C, T, D, R>;
 /**
@@ -104,6 +106,7 @@ export type InModelContextFirebaseModelServiceUseFunction<C extends FirebasePerm
  *
  * @param factory - lazy getter for the underlying model service
  * @returns an {@link InContextFirebaseModelServiceFactory} that binds contexts to the service
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function inContextFirebaseModelServiceFactory<C extends FirebaseModelServiceContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends GrantedRole = GrantedRole>(factory: FirebaseModelServiceGetter<C, T, D, R>): InContextFirebaseModelServiceFactory<C, T, D, R>;
 /**
@@ -145,6 +148,7 @@ export type FirebaseModelsServiceTypes<S extends FirebaseModelsService<any, any>
  *
  * @param services - the map of model service getter factories
  * @returns a {@link FirebaseModelsService} that dispatches to the appropriate model service by type
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function firebaseModelsService<X extends FirebaseModelsServiceFactory<C, I>, C extends FirebaseModelServiceContext, I extends FirestoreModelIdentity = FirestoreModelIdentity>(services: X): FirebaseModelsService<X, C>;
 /**
@@ -162,6 +166,7 @@ export type InContextFirebaseModelsServiceFactory<Y> = FirebaseModelsServiceType
  *
  * @param service - the multi-model service to wrap
  * @returns an {@link InContextFirebaseModelsServiceFactory} that binds a context to the service
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function inContextFirebaseModelsServiceFactory<X extends FirebaseModelsServiceFactory<C, I>, C extends FirebaseModelServiceContext, I extends FirestoreModelIdentity = FirestoreModelIdentity>(service: FirebaseModelsService<X, C>): InContextFirebaseModelsServiceFactory<FirebaseModelsService<X, C>>;
 /**
@@ -186,6 +191,7 @@ export type UseFirebaseModelsServiceSelectionUseFunction<Y extends FirebaseModel
  * @param type - the model type to select
  * @param select - selection params including context and key
  * @returns the {@link FirebaseModelsServiceSelectionResult} bound to the specified model
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function selectFromFirebaseModelsService<Y extends FirebaseModelsService<any, any>, T extends FirebaseModelsServiceTypes<Y>>(service: Y, type: T, select: FirebaseModelsServiceSelection<Y, T>): FirebaseModelsServiceSelectionResult<Y, T>;
 /**
@@ -197,6 +203,7 @@ export declare function selectFromFirebaseModelsService<Y extends FirebaseModels
  * @param type - the model type to select
  * @param select - selection params including context, key, and optional role requirements
  * @returns a {@link UsePromiseFunction} for the resolved roles reader
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function useFirebaseModelsService<Y extends FirebaseModelsService<any, any>, T extends FirebaseModelsServiceTypes<Y>>(service: Y, type: T, select: UseFirebaseModelsServiceSelection<Y, T>): UseFirebaseModelsServiceSelectionResult<Y, T>;
 /**
@@ -206,5 +213,6 @@ export declare function useFirebaseModelsService<Y extends FirebaseModelsService
  *
  * @param inContextFirebaseModelsService - context-bound multi-model service
  * @returns a map of collection type strings to their {@link FirestoreModelIdentity} objects
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function buildFirebaseCollectionTypeModelTypeMap<Y extends FirebaseModelsService<any, any>>(inContextFirebaseModelsService: InContextFirebaseModelsService<Y>): import("..").FirestoreModelIdentityTypeMap;

package/src/lib/common/model/permission/permission.service.d.ts

@@ -36,6 +36,7 @@ export declare class FirebaseModelPermissionServiceInstance<C extends FirebaseMo
  *
  * @param delegate - provides model loading and role computation
  * @returns a {@link FirebaseModelPermissionServiceInstance} configured with the given delegate
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function firebaseModelPermissionService<C extends FirebaseModelContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends string = string>(delegate: FirebasePermissionServiceInstanceDelegate<C, T, D, R>): FirebaseModelPermissionServiceInstance<C, T, D, R>;
 /**

package/src/lib/common/model/permission/permission.service.grant.d.ts

@@ -23,6 +23,7 @@ export declare const isAdminInFirebaseModelContext: AsyncDecisionFunction<Fireba
  * const grantIfAdmin = grantModelRolesIfAdminFunction(fullAccessRoleMap);
  * const roles = await grantIfAdmin(context);
  * ```
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function grantModelRolesIfAdminFunction<R extends string = string>(rolesToGrantToAdmin: GetterOrValue<GrantedRoleMap<R>>): GrantRolesIfFunction<FirebaseModelContext, R>;
 /**
@@ -44,6 +45,7 @@ export declare function grantModelRolesIfAdmin<R extends string = string>(contex
  * @param authRoles - the auth roles the user must have
  * @param rolesToGrantToAdmin - the model roles to grant if the auth roles are present
  * @returns a {@link GrantRolesIfFunction} that grants the given roles when the user has the required auth roles
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function grantModelRolesIfHasAuthRolesFunction<R extends string = string>(authRoles: AuthRole[], rolesToGrantToAdmin: GetterOrValue<GrantedRoleMap<R>>): GrantRolesIfFunction<FirebaseModelContext, R>;
 /**
@@ -55,6 +57,7 @@ export type GrantModelRolesIfHasAuthRolesFactory = <R extends string = string>(c
  *
  * @param authRoles - the auth roles the user must have
  * @returns a {@link GrantModelRolesIfHasAuthRolesFactory} pre-configured to check the given auth roles
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function grantModelRolesIfHasAuthRolesFactory(authRoles: IterableOrValue<AuthRole>): GrantModelRolesIfHasAuthRolesFactory;
 /**
@@ -94,6 +97,7 @@ export declare const isOwnerOfUserRelatedModelInFirebaseModelContext: AsyncDecis
  * const grantIfOwner = grantModelRolesIfAuthUserRelatedModelFunction<User>(fullAccessRoleMap);
  * const roles = await grantIfOwner({ model: userData, context });
  * ```
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function grantModelRolesIfAuthUserRelatedModelFunction<T extends UserRelated, R extends string = string>(rolesToGrant: GetterOrValue<GrantedRoleMap<R>>): GrantRolesIfFunction<UserRelatedModelFirebaseModelContext<T>, R>;
 /**
@@ -116,6 +120,7 @@ export type GeneralGrantRolesOnlyIfFunction<C> = <R extends string = string>(con
  * @param grantIf - decision function to evaluate
  * @param grantedRoles - roles to grant if the decision is `true`
  * @returns a {@link GrantRolesOnlyIfFunction} that grants roles or returns no-access with no fallback
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function grantModelRolesOnlyIfFunction<C, R extends string = string>(grantIf: AsyncDecisionFunction<C>, grantedRoles: GetterOrValue<GrantedRoleMap<R>>): GrantRolesOnlyIfFunction<C, R>;
 /**
@@ -152,5 +157,6 @@ export type GrantRolesOtherwiseFunction<R extends string = string> = Getter<Gran
  * );
  * const roles = await grantIfOwner(context, () => noAccessRoleMap());
  * ```
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function grantModelRolesIfFunction<C, R extends string = string>(grantIf: AsyncDecisionFunction<C>, grantedRoles: GetterOrValue<GrantedRoleMap<R>>): GrantRolesIfFunction<C, R>;

package/src/lib/common/storage/accessor/path.model.d.ts

@@ -42,5 +42,6 @@ export type ModelStorageSlashPathFactory<T extends object = object> = (input: Re
  * const path = pathFactory(userDocument, 'profile.png');
  * // path === '/model/avatars/users/abc123/profile.png'
  * ```
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function modelStorageSlashPathFactory<T extends object = object>(config?: ModelStorageSlashPathFactoryConfig): ModelStorageSlashPathFactory<T>;

package/src/lib/common/storage/context.d.ts

@@ -49,5 +49,6 @@ export interface FirebaseStorageContextFactoryConfig {
  * const storageContext = factory(firebaseStorage, { defaultBucketId: 'my-bucket' });
  * const file = storageContext.file('uploads/doc.pdf');
  * ```
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function firebaseStorageContextFactory<F extends FirebaseStorage = FirebaseStorage>(drivers: FirebaseStorageDrivers): FirebaseStorageContextFactory<F>;

package/src/lib/common/storage/driver/accessor.iterate.d.ts

@@ -31,6 +31,7 @@ export type IterateStorageListFilesFactory = FetchPageFactory<IterateStorageList
  * ```ts
  * const factory = iterateStorageListFilesFactory({ maxResults: 100 });
  * ```
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function iterateStorageListFilesFactory(config: IterateStorageListFilesFactoryConfig): IterateStorageListFilesFactory;
 /**

package/src/lib/common/storage/driver/list.d.ts

@@ -50,6 +50,7 @@ export type StorageListFilesResultFactory<S, R> = (input: StorageListFilesResult
  * const result = factory({ storage, folder, options: { maxResults: 50 } }, rawSdkResult);
  * const files = result.files();
  * ```
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function storageListFilesResultFactory<S, R>(delegate: StorageListFilesResultFactoryDelegate<S, R>): StorageListFilesResultFactory<S, R>;
 /**

package/src/lib/common/storage/storage.d.ts

@@ -88,6 +88,7 @@ export interface StoragePathFactoryConfig extends StorageBucketIdRef {
  * const path = pathFactory('images/photo.png');
  * // path === { bucketId: 'my-bucket', pathString: 'images/photo.png' }
  * ```
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function storagePathFactory(config: StoragePathFactoryConfig): StoragePathFactory;
 /**

package/src/lib/model/notification/index.d.ts

@@ -5,6 +5,8 @@ export * from './notification.api.util';
 export * from './notification.action';
 export * from './notification.config';
 export * from './notification.create';
+export * from './notification.create.loggedevent';
+export * from './notification.loggedevent.loader';
 export * from './notification.create.task';
 export * from './notification.details';
 export * from './notification.item';

package/src/lib/model/notification/notification.api.d.ts

@@ -207,6 +207,11 @@ export interface SendNotificationResult {
     readonly notificationTemplateType: Maybe<NotificationTemplateType>;
     readonly isKnownTemplateType: Maybe<boolean>;
     readonly isNotificationTask: boolean;
+    /**
+     * True if the notification was a logged-event record (`st === LOGGED_EVENT`). Logged events bypass
+     * the send pipeline entirely; the factory short-circuits and returns immediately when one is loaded.
+     */
+    readonly isLoggedEvent: boolean;
     readonly isUniqueNotificationTask: boolean;
     readonly uniqueNotificationTaskConflict: boolean;
     readonly isConfiguredTemplateType: Maybe<boolean>;
@@ -242,7 +247,7 @@ export declare const sendQueuedNotificationsParamsType: Type<SendQueuedNotificat
 /**
  * Aggregate result of processing the notification send queue, with counts of visited, succeeded, failed, and deleted notifications.
  */
-export interface SendQueuedNotificationsResult extends Omit<SendNotificationResult, 'throttled' | 'isNotificationTask' | 'isUniqueNotificationTask' | 'notificationTaskCompletionType' | 'uniqueNotificationTaskConflict' | 'isConfiguredTemplateType' | 'isKnownTemplateType' | 'notificationTemplateType' | 'notificationMarkedDone' | 'deletedNotification' | 'createdBox' | 'success' | 'exists' | 'boxExists' | 'notificationBoxNeedsInitialization' | 'tryRun' | 'loadMessageFunctionFailure' | 'buildMessageFailure'> {
+export interface SendQueuedNotificationsResult extends Omit<SendNotificationResult, 'throttled' | 'isNotificationTask' | 'isLoggedEvent' | 'isUniqueNotificationTask' | 'notificationTaskCompletionType' | 'uniqueNotificationTaskConflict' | 'isConfiguredTemplateType' | 'isKnownTemplateType' | 'notificationTemplateType' | 'notificationMarkedDone' | 'deletedNotification' | 'createdBox' | 'success' | 'exists' | 'boxExists' | 'notificationBoxNeedsInitialization' | 'tryRun' | 'loadMessageFunctionFailure' | 'buildMessageFailure'> {
     readonly excessLoopsDetected: boolean;
     readonly notificationLoopCount: number;
     readonly notificationBoxesCreated: number;
@@ -265,6 +270,34 @@ export interface CleanupSentNotificationsResult {
     readonly notificationsDeleted: number;
     readonly notificationWeeksCreated: number;
     readonly notificationWeeksUpdated: number;
+    /**
+     * Number of logged-event notifications archived to {@link NotificationLoggedEventDay} during cleanup.
+     */
+    readonly notificationLoggedEventsCleanedUp: number;
+}
+/**
+ * Parameters for the `cleanupOldNotificationLoggedEventDays` action.
+ */
+export interface CleanupOldNotificationLoggedEventDaysParams {
+    /**
+     * Number of days of logged-event history to retain. Day documents whose ISO day string ID is older
+     * than `now - retentionDays` are deleted along with their nested page subcollection.
+     */
+    readonly retentionDays: number;
+}
+export declare const cleanupOldNotificationLoggedEventDaysParamsType: Type<CleanupOldNotificationLoggedEventDaysParams>;
+/**
+ * Aggregate result of the `cleanupOldNotificationLoggedEventDays` action.
+ */
+export interface CleanupOldNotificationLoggedEventDaysResult {
+    /**
+     * Number of {@link NotificationLoggedEventDay} wrapper documents deleted.
+     */
+    readonly daysDeleted: number;
+    /**
+     * Number of page documents (including the `_index` doc) deleted across all purged days.
+     */
+    readonly pagesDeleted: number;
 }
 /**
  * Custom (non-CRUD) function type map for notifications. Currently empty — all operations use the CRUD pattern.
@@ -295,6 +328,8 @@ export type NotificationBoxModelCrudFunctionsConfig = {
         };
     };
     readonly notificationWeek: null;
+    readonly notificationLoggedEventDay: null;
+    readonly notificationLoggedEventDayPage: null;
 };
 export declare const notificationBoxModelCrudFunctionsConfig: ModelFirebaseCrudFunctionConfigMap<NotificationBoxModelCrudFunctionsConfig, NotificationTypes>;
 /**

package/src/lib/model/notification/notification.config.d.ts

@@ -311,6 +311,7 @@ export type EncodedNotificationBoxRecipientTemplateConfigRecord = Record<Notific
  * using bitwise encoding for compact storage.
  *
  * @returns a Firestore field converter that encodes and decodes template config records using bitwise encoding
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function firestoreNotificationBoxRecipientTemplateConfigRecord(): import("../..").FirestoreModelFieldMapFunctionsConfig<import("../..").FirestoreEncodedObjectMapFieldValueType<NotificationBoxRecipientTemplateConfig, string>, import("../..").FirestoreMapFieldType<number, string>>;
 /**

package/src/lib/model/notification/notification.create.d.ts

@@ -126,6 +126,7 @@ export interface CreateNotificationTemplateInput extends Partial<Omit<CreateNoti
  *
  * @param input - friendly input with readable field names
  * @returns the low-level template using Firestore field abbreviations
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function createNotificationTemplate(input: CreateNotificationTemplateInput): CreateNotificationTemplate;
 /**
@@ -221,6 +222,7 @@ export interface CreateNotificationDocumentPairResult extends Pick<CreateNotific
  * @returns the document reference and notification data pair, with `notificationCreated` set to false
  * @throws {Error} When neither an accessor nor sufficient context is provided
  * @throws {Error} When `unique=true` but no target model is specified
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function createNotificationDocumentPair(input: CreateNotificationDocumentPairInput): CreateNotificationDocumentPairResult;
 /**

package/src/lib/model/notification/notification.create.loggedevent.d.ts

@@ -0,0 +1,33 @@
+import { type CreateNotificationTemplate, type CreateNotificationTemplateInput } from './notification.create';
+/**
+ * Template for creating a logged-event {@link Notification}. Alias for {@link CreateNotificationTemplate}.
+ */
+export type CreateNotificationLoggedEventTemplate = CreateNotificationTemplate;
+/**
+ * Simplified input for creating logged-event notification templates. Omits fields not applicable to
+ * logged events (recipients, send type, recipient flags) and requires `notificationModel` since
+ * logged events are always associated with a target model.
+ */
+export type CreateNotificationLoggedEventTemplateInput = Omit<CreateNotificationTemplateInput, 'st' | 'recipients' | 'r' | 'rf' | 'sendType'>;
+/**
+ * Creates a {@link CreateNotificationLoggedEventTemplate} with `LOGGED_EVENT` send type and no recipients.
+ *
+ * The persisted {@link Notification} is born with `d: true` and `NO_TRY` channel states (set by
+ * {@link createNotificationDocumentPair}), so it is invisible to the send loop and is archived to
+ * {@link NotificationLoggedEventDay} during cleanup.
+ *
+ * @param input - logged-event template input parameters
+ * @returns the configured logged-event notification template
+ * @throws {Error} When `notificationModel` is not provided.
+ *
+ * @example
+ * ```ts
+ * const template = createNotificationLoggedEventTemplate({
+ *   type: 'workerClockedIn',
+ *   notificationModel: 'project/abc123',
+ *   data: { workerId: 'w_001', at: new Date().toISOString() }
+ * });
+ * ```
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function createNotificationLoggedEventTemplate(input: CreateNotificationLoggedEventTemplateInput): CreateNotificationLoggedEventTemplate;

package/src/lib/model/notification/notification.create.task.d.ts

@@ -41,5 +41,6 @@ export interface CreateNotificationTaskTemplateInput extends Omit<CreateNotifica
  *   data: { reportType: 'monthly' }
  * });
  * ```
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function createNotificationTaskTemplate(input: CreateNotificationTaskTemplateInput): CreateNotificationTaskTemplate;

package/src/lib/model/notification/notification.d.ts

@@ -21,7 +21,7 @@ import { type NotificationBoxSendExclusionList, type NotificationBoxId } from '.
 import { type NotificationBoxRecipient, type NotificationRecipientWithConfig, type NotificationUserNotificationBoxRecipientConfig, type NotificationUserDefaultNotificationBoxRecipientConfig } from './notification.config';
 import { type YearWeekCode } from '@dereekb/date';
 import { type UserRelatedById, type UserRelated } from '../user';
-import { AbstractFirestoreDocument, AbstractFirestoreDocumentWithParent, type CollectionGroup, type CollectionReference, type FirestoreCollection, type FirestoreCollectionGroup, type FirestoreCollectionWithParent, type FirestoreContext, type FirestoreModelKey, type SavedToFirestoreIfTrue, type SavedToFirestoreIfFalse } from '../../common';
+import { AbstractFirestoreDocument, AbstractFirestoreDocumentWithParent, type CollectionGroup, type CollectionReference, type FirestoreCollection, type FirestoreCollectionGroup, type FirestoreCollectionWithParent, type FirestoreContext, type FirestoreModelKey, type SavedToFirestoreIfTrue, type SavedToFirestoreIfFalse, type PagedItemConverter, type PagedItemFirestoreCollection, type PagedItemPageData } from '../../common';
 import { type NotificationItem } from './notification.item';
 /**
  * Abstract class providing access to all notification-related Firestore collections.
@@ -41,11 +41,15 @@ export declare abstract class NotificationFirestoreCollections {
     abstract readonly notificationCollectionGroup: NotificationFirestoreCollectionGroup;
     abstract readonly notificationWeekCollectionFactory: NotificationWeekFirestoreCollectionFactory;
     abstract readonly notificationWeekCollectionGroup: NotificationWeekFirestoreCollectionGroup;
+    abstract readonly notificationLoggedEventDayCollectionFactory: NotificationLoggedEventDayFirestoreCollectionFactory;
+    abstract readonly notificationLoggedEventDayCollectionGroup: NotificationLoggedEventDayFirestoreCollectionGroup;
+    abstract readonly notificationLoggedEventDayPagedItemsCollectionFactory: NotificationLoggedEventDayPagedItemsFirestoreCollectionFactory;
+    abstract readonly notificationLoggedEventDayPageCollectionGroup: NotificationLoggedEventDayPageFirestoreCollectionGroup;
 }
 /**
  * Union of all notification model identity types, used for type-safe identity discrimination.
  */
-export type NotificationTypes = typeof notificationUserIdentity | typeof notificationSummaryIdentity | typeof notificationBoxIdentity | typeof notificationIdentity | typeof notificationWeekIdentity;
+export type NotificationTypes = typeof notificationUserIdentity | typeof notificationSummaryIdentity | typeof notificationBoxIdentity | typeof notificationIdentity | typeof notificationWeekIdentity | typeof notificationLoggedEventDayIdentity | typeof notificationLoggedEventDayPageIdentity;
 /**
  * Notification-related model that is initialized asynchronously at a later time.
  *
@@ -376,6 +380,8 @@ export declare const notificationIdentity: import("../..").FirestoreModelIdentit
  *
  * Determines whether the box must exist, should be created on demand, or can be bypassed entirely.
  * Task-type notifications (`TASK_NOTIFICATION`) bypass the box system and run async workflows instead.
+ * Logged-event notifications (`LOGGED_EVENT`) are write-only records that bypass the send loop and
+ * are archived to {@link NotificationLoggedEventDay} during cleanup.
  */
 export declare enum NotificationSendType {
     /**
@@ -397,7 +403,15 @@ export declare enum NotificationSendType {
      *
      * This is used with Task-type notifications.
      */
-    TASK_NOTIFICATION = 3
+    TASK_NOTIFICATION = 3,
+    /**
+     * A write-only logged event notification.
+     *
+     * Persisted with `d=true` and `NO_TRY` channel states from creation, so the send loop never visits it.
+     * Cleanup archives the notification item into {@link NotificationLoggedEventDay} (a paged, day-keyed
+     * subcollection of {@link NotificationBox}) instead of {@link NotificationWeek}, then deletes the source.
+     */
+    LOGGED_EVENT = 4
 }
 /**
  * Lifecycle state of a notification delivery channel (text, email, push, or summary).
@@ -662,6 +676,7 @@ export declare const notificationConverter: import("../..").SnapshotConverterFun
  *
  * @param context - Firestore context to create subcollection references from
  * @returns a factory function that creates collection references for a given NotificationBox parent
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function notificationCollectionReferenceFactory(context: FirestoreContext): (notificationBox: NotificationBoxDocument) => CollectionReference<Notification>;
 /**
@@ -677,6 +692,7 @@ export type NotificationFirestoreCollectionFactory = (parent: NotificationBoxDoc
  *
  * @param firestoreContext - Firestore context to bind the collection factory to
  * @returns a factory that creates typed Firestore subcollections for Notification documents
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function notificationFirestoreCollectionFactory(firestoreContext: FirestoreContext): NotificationFirestoreCollectionFactory;
 /**
@@ -742,6 +758,7 @@ export declare const notificationWeekConverter: import("../..").SnapshotConverte
  *
  * @param context - Firestore context to create subcollection references from
  * @returns a factory function that creates collection references for a given NotificationBox parent
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function notificationWeekCollectionReferenceFactory(context: FirestoreContext): (notificationBox: NotificationBoxDocument) => CollectionReference<NotificationWeek>;
 /**
@@ -757,6 +774,7 @@ export type NotificationWeekFirestoreCollectionFactory = (parent: NotificationBo
  *
  * @param firestoreContext - Firestore context to bind the collection factory to
  * @returns a factory that creates typed Firestore subcollections for NotificationWeek documents
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function notificationWeekFirestoreCollectionFactory(firestoreContext: FirestoreContext): NotificationWeekFirestoreCollectionFactory;
 /**
@@ -777,3 +795,161 @@ export type NotificationWeekFirestoreCollectionGroup = FirestoreCollectionGroup<
  * @returns a typed Firestore collection group for querying NotificationWeek documents across all parents
  */
 export declare function notificationWeekFirestoreCollectionGroup(firestoreContext: FirestoreContext): NotificationWeekFirestoreCollectionGroup;
+/**
+ * Identity for {@link NotificationLoggedEventDay} wrapper documents. Subcollection of {@link NotificationBox}.
+ * Collection name: `'notificationLoggedEventDay'`, short code: `'nbnle'`.
+ *
+ * Each wrapper document is keyed by an ISO 8601 day string (e.g. `'2026-05-08'`) and exists primarily
+ * as the parent of a per-day paged items subcollection (see {@link notificationLoggedEventDayPageIdentity}).
+ */
+export declare const notificationLoggedEventDayIdentity: import("../..").FirestoreModelIdentityWithParent<import("../..").RootFirestoreModelIdentity<"notificationBox", "nb">, "notificationLoggedEventDay", "nbnle">;
+/**
+ * Identity for the page documents inside a {@link NotificationLoggedEventDay}'s paged items subcollection.
+ * Collection name: `'notificationLoggedEventDayPage'`, short code: `'nbnlep'`.
+ *
+ * The framework manages page IDs (`'_index'`, `'0'`, `'1'`, ...) — consumers interact with the paged
+ * collection accessor and do not address page docs directly.
+ */
+export declare const notificationLoggedEventDayPageIdentity: import("../..").FirestoreModelIdentityWithParent<import("../..").FirestoreModelIdentityWithParent<import("../..").RootFirestoreModelIdentity<"notificationBox", "nb">, "notificationLoggedEventDay", "nbnle">, "notificationLoggedEventDayPage", "nbnlep">;
+/**
+ * Per-item converter applied to {@link NotificationItem} entries when reading/writing logged-event
+ * day pages. Wraps the existing {@link firestoreNotificationItem} sub-object converter so individual
+ * items round-trip through the same field rules used everywhere else NotificationItems are persisted.
+ */
+export declare const notificationLoggedEventDayItemConverter: PagedItemConverter<NotificationItem>;
+/**
+ * Day-keyed wrapper document for a single day's worth of archived logged-event notifications under a
+ * {@link NotificationBox}.
+ *
+ * The document ID is an ISO 8601 day string (e.g. `'2026-05-08'`). The wrapper itself stores only the
+ * day code redundantly in {@link d}; the actual {@link NotificationItem} entries live in the day's
+ * paged subcollection (see {@link notificationLoggedEventDayPagedItemsCollectionFactory}). The split
+ * keeps each day's archive bounded — no single document can exceed the 1MB Firestore cap because
+ * items are distributed across pages by {@link makePagedItemFirestoreCollection}.
+ *
+ * @dbxModel
+ */
+export interface NotificationLoggedEventDay {
+    /**
+     * ISO 8601 day string identifying this day. Matches the document ID.
+     *
+     * @dbxModelVariable day
+     */
+    readonly d: string;
+}
+export type NotificationLoggedEventDayRoles = GrantedReadRole;
+export declare class NotificationLoggedEventDayDocument extends AbstractFirestoreDocumentWithParent<NotificationBox, NotificationLoggedEventDay, NotificationLoggedEventDayDocument, typeof notificationLoggedEventDayIdentity> {
+    get modelIdentity(): import("../..").FirestoreModelIdentityWithParent<import("../..").RootFirestoreModelIdentity<"notificationBox", "nb">, "notificationLoggedEventDay", "nbnle">;
+}
+/**
+ * Firestore snapshot converter for {@link NotificationLoggedEventDay} wrapper documents.
+ */
+export declare const notificationLoggedEventDayConverter: import("../..").SnapshotConverterFunctions<NotificationLoggedEventDay, Partial<import("@dereekb/util").ReplaceType<NotificationLoggedEventDay, import("@dereekb/util").MaybeMap<object>, any>>>;
+/**
+ * Creates a factory that produces {@link NotificationLoggedEventDay} subcollection references for a given {@link NotificationBoxDocument} parent.
+ *
+ * @param context - Firestore context to create subcollection references from
+ * @returns a factory function that creates collection references for a given NotificationBox parent
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function notificationLoggedEventDayCollectionReferenceFactory(context: FirestoreContext): (notificationBox: NotificationBoxDocument) => CollectionReference<NotificationLoggedEventDay>;
+/**
+ * Typed Firestore subcollection for {@link NotificationLoggedEventDay} wrapper documents under a {@link NotificationBox} parent.
+ */
+export type NotificationLoggedEventDayFirestoreCollection = FirestoreCollectionWithParent<NotificationLoggedEventDay, NotificationBox, NotificationLoggedEventDayDocument, NotificationBoxDocument>;
+/**
+ * Factory function that creates a {@link NotificationLoggedEventDayFirestoreCollection} for a given {@link NotificationBoxDocument} parent.
+ */
+export type NotificationLoggedEventDayFirestoreCollectionFactory = (parent: NotificationBoxDocument) => NotificationLoggedEventDayFirestoreCollection;
+/**
+ * Creates a {@link NotificationLoggedEventDayFirestoreCollectionFactory} bound to the given Firestore context.
+ *
+ * @param firestoreContext - Firestore context to bind the collection factory to
+ * @returns a factory that creates typed Firestore subcollections for NotificationLoggedEventDay wrapper documents
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function notificationLoggedEventDayFirestoreCollectionFactory(firestoreContext: FirestoreContext): NotificationLoggedEventDayFirestoreCollectionFactory;
+/**
+ * Creates a collection group reference for querying all {@link NotificationLoggedEventDay} documents across all {@link NotificationBox} parents.
+ *
+ * @param context - Firestore context to create the collection group reference from
+ * @returns a typed collection group for querying NotificationLoggedEventDay documents across all parents
+ */
+export declare function notificationLoggedEventDayCollectionReference(context: FirestoreContext): CollectionGroup<NotificationLoggedEventDay>;
+/**
+ * Typed collection group for querying {@link NotificationLoggedEventDay} documents across all parents.
+ */
+export type NotificationLoggedEventDayFirestoreCollectionGroup = FirestoreCollectionGroup<NotificationLoggedEventDay, NotificationLoggedEventDayDocument>;
+/**
+ * Creates a typed {@link NotificationLoggedEventDayFirestoreCollectionGroup} bound to the given Firestore context.
+ *
+ * @param firestoreContext - Firestore context to bind the collection group to
+ * @returns a typed Firestore collection group for querying NotificationLoggedEventDay documents across all parents
+ */
+export declare function notificationLoggedEventDayFirestoreCollectionGroup(firestoreContext: FirestoreContext): NotificationLoggedEventDayFirestoreCollectionGroup;
+/**
+ * Page-document model shape for the inner paged collection. Each page stores a slice of
+ * {@link NotificationItem} entries in {@link PagedItemPageData.i}, plus a denormalized count.
+ */
+export type NotificationLoggedEventDayPageDocumentData = PagedItemPageData<NotificationItem>;
+/**
+ * {@link AbstractFirestoreDocumentWithParent} implementation for a single page document inside the
+ * {@link NotificationLoggedEventDayPagedItemsFirestoreCollection} of a {@link NotificationLoggedEventDayDocument}.
+ *
+ * Page docs are managed internally by the paged accessor — consumers do not address them directly.
+ */
+export declare class NotificationLoggedEventDayPageDocument extends AbstractFirestoreDocumentWithParent<NotificationLoggedEventDay, NotificationLoggedEventDayPageDocumentData, NotificationLoggedEventDayPageDocument, typeof notificationLoggedEventDayPageIdentity> {
+    get modelIdentity(): import("../..").FirestoreModelIdentityWithParent<import("../..").FirestoreModelIdentityWithParent<import("../..").RootFirestoreModelIdentity<"notificationBox", "nb">, "notificationLoggedEventDay", "nbnle">, "notificationLoggedEventDayPage", "nbnlep">;
+}
+/**
+ * Creates a factory that produces page subcollection references for a given {@link NotificationLoggedEventDayDocument} parent.
+ *
+ * @param context - Firestore context to create subcollection references from
+ * @returns a factory function that creates collection references for a given NotificationLoggedEventDayDocument parent
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function notificationLoggedEventDayPagedItemsCollectionReferenceFactory(context: FirestoreContext): (day: NotificationLoggedEventDayDocument) => CollectionReference<NotificationLoggedEventDayPageDocumentData>;
+/**
+ * Typed paged Firestore subcollection of {@link NotificationItem} entries living under a {@link NotificationLoggedEventDayDocument}.
+ *
+ * Items are distributed across page documents by {@link makePagedItemFirestoreCollection} using the
+ * default count-based dynamic distribution scheme. Consumers should use the paged accessor methods
+ * (e.g. {@link FirestorePagedItemAccessor.loadAllItems}, {@link FirestorePagedItemAccessor.writeAllItemsInTransaction})
+ * rather than the inherited document accessor.
+ */
+export type NotificationLoggedEventDayPagedItemsFirestoreCollection = PagedItemFirestoreCollection<NotificationItem, NotificationLoggedEventDay, NotificationLoggedEventDayPageDocument, NotificationLoggedEventDayDocument>;
+/**
+ * Factory function that creates a {@link NotificationLoggedEventDayPagedItemsFirestoreCollection} for a given {@link NotificationLoggedEventDayDocument} parent.
+ */
+export type NotificationLoggedEventDayPagedItemsFirestoreCollectionFactory = (parent: NotificationLoggedEventDayDocument) => NotificationLoggedEventDayPagedItemsFirestoreCollection;
+/**
+ * Creates a {@link NotificationLoggedEventDayPagedItemsFirestoreCollectionFactory} bound to the given Firestore context.
+ *
+ * Uses the framework's default count-based dynamic page distribution; consumers do not need to provide
+ * a {@link PagedItemDistributionScheme}. The per-item converter delegates to {@link firestoreNotificationItem}.
+ *
+ * @param firestoreContext - Firestore context to bind the collection factory to
+ * @returns a factory that creates paged Firestore subcollections of NotificationItem for a given day
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function notificationLoggedEventDayPagedItemsCollectionFactory(firestoreContext: FirestoreContext): NotificationLoggedEventDayPagedItemsFirestoreCollectionFactory;
+/**
+ * Creates a collection group reference for querying all logged-event page documents across every {@link NotificationLoggedEventDay} parent.
+ *
+ * @param context - Firestore context to create the collection group reference from
+ * @returns a typed collection group for querying logged-event page documents
+ */
+export declare function notificationLoggedEventDayPageCollectionReference(context: FirestoreContext): CollectionGroup<NotificationLoggedEventDayPageDocumentData>;
+/**
+ * Typed collection group for querying logged-event page documents across all parents. Note that the
+ * `_index` doc co-resides with page docs and has a different shape; callers wanting only pages should
+ * filter by document ID where appropriate.
+ */
+export type NotificationLoggedEventDayPageFirestoreCollectionGroup = FirestoreCollectionGroup<NotificationLoggedEventDayPageDocumentData, NotificationLoggedEventDayPageDocument>;
+/**
+ * Creates a typed {@link NotificationLoggedEventDayPageFirestoreCollectionGroup} bound to the given Firestore context.
+ *
+ * @param firestoreContext - Firestore context to bind the collection group to
+ * @returns a typed Firestore collection group for querying logged-event page documents across all parents
+ */
+export declare function notificationLoggedEventDayPageFirestoreCollectionGroup(firestoreContext: FirestoreContext): NotificationLoggedEventDayPageFirestoreCollectionGroup;

package/src/lib/model/notification/notification.details.d.ts

@@ -197,5 +197,6 @@ export declare abstract class AppNotificationTemplateTypeInfoRecordService {
  * );
  * const types = service.getTemplateTypesForNotificationModel('project/abc123');
  * ```
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function appNotificationTemplateTypeInfoRecordService(appNotificationTemplateTypeInfoRecord: NotificationTemplateTypeInfoRecord): AppNotificationTemplateTypeInfoRecordService;

package/src/lib/model/notification/notification.id.d.ts

@@ -12,7 +12,7 @@
  * to be stored in top-level collections while maintaining a bidirectional link to the
  * model they represent.
  */
-import { type FactoryWithRequiredInput } from '@dereekb/util';
+import { type FactoryWithRequiredInput, type ISO8601DayString } from '@dereekb/util';
 import { type FirestoreModelId, type FirestoreModelKey, type FlatFirestoreModelKey, twoWayFlatFirestoreModelKey, inferKeyFromTwoWayFlatFirestoreModelKey, type FirebaseAuthUserId, type RootFirestoreModelIdentity, type FirestoreModelIdInput, type FirestoreCollectionName } from '../../common';
 /**
  * Document ID for a {@link NotificationBox}. Encoded as a two-way flat key of the model it represents.
@@ -116,6 +116,28 @@ export type NotificationWeekId = FirestoreModelId;
  * Full Firestore model key path for a {@link NotificationWeek} document.
  */
 export type NotificationWeekKey = FirestoreModelKey;
+/**
+ * Document ID for a {@link NotificationLoggedEventDay} (an {@link ISO8601DayString} like `'2026-05-08'`).
+ */
+export type NotificationLoggedEventDayId = ISO8601DayString;
+/**
+ * Full Firestore model key path for a {@link NotificationLoggedEventDay} document.
+ */
+export type NotificationLoggedEventDayKey = FirestoreModelKey;
+/**
+ * Returns the {@link NotificationLoggedEventDayId} (an ISO 8601 day string in UTC)
+ * for the given date. Used as the document ID when archiving logged-event notifications.
+ *
+ * @example
+ * ```ts
+ * notificationLoggedEventDayId(new Date('2026-05-08T17:30:00Z'));
+ * // '2026-05-08'
+ * ```
+ *
+ * @param date - the date to derive the day ID from
+ * @returns the UTC ISO day string for that date
+ */
+export declare function notificationLoggedEventDayId(date: Date): NotificationLoggedEventDayId;
 /**
  * Document ID for a {@link Notification}.
  */