@dereekb/firebase 11.0.21 → 11.1.0

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

@@ -0,0 +1,403 @@
+import { type E164PhoneNumber, type EmailAddress, type Maybe, type NeedsSyncBoolean } from '@dereekb/util';
+import { type GrantedReadRole, type GrantedUpdateRole } from '@dereekb/model';
+import { type NotificationBoxId } from './notification.id';
+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 } from '../../common';
+import { type NotificationItem } from './notification.item';
+export declare abstract class NotificationFirestoreCollections {
+    abstract readonly notificationUserCollection: NotificationUserFirestoreCollection;
+    abstract readonly notificationSummaryCollection: NotificationSummaryFirestoreCollection;
+    abstract readonly notificationBoxCollection: NotificationBoxFirestoreCollection;
+    abstract readonly notificationCollectionFactory: NotificationFirestoreCollectionFactory;
+    abstract readonly notificationCollectionGroup: NotificationFirestoreCollectionGroup;
+    abstract readonly notificationWeekCollectionFactory: NotificationWeekFirestoreCollectionFactory;
+    abstract readonly notificationWeekCollectionGroup: NotificationWeekFirestoreCollectionGroup;
+}
+export type NotificationTypes = typeof notificationUserIdentity | typeof notificationSummaryIdentity | typeof notificationBoxIdentity | typeof notificationIdentity | typeof notificationWeekIdentity;
+/**
+ * Notification-related model that is initialized asynchronously at a later time.
+ */
+export interface InitializedNotificationModel {
+    /**
+     * True if this model needs to be sync'd/initialized with the original model.
+     *
+     * Is set false if/when "fi" is set true.
+     */
+    s?: Maybe<NeedsSyncBoolean>;
+    /**
+     * True if this model has been flagged invalid.
+     *
+     * This is for cases where the model cannot be properly initiialized.
+     *
+     * NOTE: The server can also be configured to automatically delete these models instead of marking them as invalid.
+     */
+    fi?: Maybe<SavedToFirestoreIfTrue>;
+}
+export declare const notificationUserIdentity: import("../../common").RootFirestoreModelIdentity<"notificationUser", "nu">;
+/**
+ * A global notification User in the system.
+ *
+ * Keeps track of the NotificationBoxes the user is subscribed to, as well as other global subscriptions.
+ *
+ * The NotificationUser is created automatically by the NotificationBox as a user is created.
+ */
+export interface NotificationUser extends UserRelated, UserRelatedById {
+    /**
+     * List of notification boxes this user is associated with. Cannot be changed directly.
+     */
+    b: NotificationBoxId[];
+    /**
+     * Global config override.
+     *
+     * This config effectively overrides all other configs, both NotificationBox configs and direct/default configs when used.
+     * It does not however get copied to dc/bc when updated.
+     */
+    gc: NotificationUserDefaultNotificationBoxRecipientConfig;
+    /**
+     * Direct/default config.
+     *
+     * This config is retrieved and used for cases where the recipient isn't associated with the NotificationBox but was added on an ad-hoc basis as an additional user as a uid.
+     */
+    dc: NotificationUserDefaultNotificationBoxRecipientConfig;
+    /**
+     * List of NotificationBox configurations.
+     */
+    bc: NotificationUserNotificationBoxRecipientConfig[];
+    /**
+     * Whether or not the user has one or more configs that need to be synced.
+     */
+    ns?: Maybe<NeedsSyncBoolean>;
+}
+export type NotificationUserRoles = 'sync' | GrantedUpdateRole | GrantedReadRole;
+export declare class NotificationUserDocument extends AbstractFirestoreDocument<NotificationUser, NotificationUserDocument, typeof notificationUserIdentity> {
+    get modelIdentity(): import("../../common").RootFirestoreModelIdentity<"notificationUser", "nu">;
+}
+export declare const notificationUserConverter: import("../../common").SnapshotConverterFunctions<NotificationUser, Partial<import("@dereekb/util").ReplaceType<NotificationUser, import("@dereekb/util").MaybeMap<object>, any>>>;
+export declare function notificationUserCollectionReference(context: FirestoreContext): CollectionReference<NotificationUser>;
+export type NotificationUserFirestoreCollection = FirestoreCollection<NotificationUser, NotificationUserDocument>;
+export declare function notificationUserFirestoreCollection(firestoreContext: FirestoreContext): NotificationUserFirestoreCollection;
+/**
+ * An arbitrary summary object
+ */
+export declare const notificationSummaryIdentity: import("../../common").RootFirestoreModelIdentity<"notificationSummary", "ns">;
+/**
+ * The maximum number of notifications that can be stored in a NotificationSummary.
+ */
+export declare const NOTIFICATION_SUMMARY_ITEM_LIMIT = 1000;
+/**
+ * The expected max length of a subject on a NotificationSummary's embedded NotificationItem.
+ */
+export declare const NOTIFICATION_SUMMARY_EMBEDDED_NOTIFICATION_ITEM_SUBJECT_MAX_LENGTH = 80;
+/**
+ * The expected max length of a message on a NotificationSummary's embedded NotificationItem.
+ */
+export declare const NOTIFICATION_SUMMARY_EMBEDDED_NOTIFICATION_ITEM_MESSAGE_MAX_LENGTH = 500;
+/**
+ * Used to hold arbitrary NotificationItems in the system for an object. The id for this is the two-way flat key of the object it represents.
+ *
+ * Notification Items can be delivered here.
+ */
+export interface NotificationSummary {
+    /**
+     * Notification Summary creation date
+     */
+    cat: Date;
+    /**
+     * Model key of the model this box is assigned to.
+     */
+    m: FirestoreModelKey;
+    /**
+     * Owner model key of the model this box is assigned to.
+     *
+     * Is created with a dummy value until it is initialized.
+     */
+    o: FirestoreModelKey;
+    /**
+     * Notification items.
+     *
+     * They are sorted in ascending order, with the newest items at the end.
+     */
+    n: NotificationItem[];
+    /**
+     * Date of the latest notification.
+     */
+    lat?: Maybe<Date>;
+    /**
+     * Date of the last read at time so notifications can be marked as read.
+     */
+    rat?: Maybe<Date>;
+    /**
+     * True if this NotificationSummary needs to be sync'd/initialized with the original model.
+     */
+    s?: Maybe<NeedsSyncBoolean>;
+}
+/**
+ * NotificationSummary roles
+ */
+export type NotificationSummaryRoles = GrantedReadRole;
+export declare class NotificationSummaryDocument extends AbstractFirestoreDocument<NotificationSummary, NotificationSummaryDocument, typeof notificationSummaryIdentity> {
+    get modelIdentity(): import("../../common").RootFirestoreModelIdentity<"notificationSummary", "ns">;
+}
+export declare const notificationSummaryConverter: import("../../common").SnapshotConverterFunctions<NotificationSummary, Partial<import("@dereekb/util").ReplaceType<NotificationSummary, import("@dereekb/util").MaybeMap<object>, any>>>;
+export declare function notificationSummaryCollectionReference(context: FirestoreContext): CollectionReference<NotificationSummary>;
+export type NotificationSummaryFirestoreCollection = FirestoreCollection<NotificationSummary, NotificationSummaryDocument>;
+export declare function notificationSummaryFirestoreCollection(firestoreContext: FirestoreContext): NotificationSummaryFirestoreCollection;
+export declare const notificationBoxIdentity: import("../../common").RootFirestoreModelIdentity<"notificationBox", "nb">;
+/**
+ * A Notification Box in the system for an object. The id for this is the two-way flat key of the object it represents.
+ *
+ * This object is the root collection for notifications for the corresponding object.
+ *
+ * Additional information about what notification templates are available to this type are available on a per-application basis, typically through the
+ * NotificationTemplateTypeInfoRecord configured for the app.
+ *
+ * Update to each recipient is propogated from NotificationUser values.
+ */
+export interface NotificationBox {
+    /**
+     * Notification Box creation date
+     */
+    cat: Date;
+    /**
+     * Model key of the model this box is assigned to.
+     */
+    m: FirestoreModelKey;
+    /**
+     * Owner model key of the model this box is assigned to.
+     *
+     * Is created with a dummy value until it is initialized.
+     */
+    o: FirestoreModelKey;
+    /**
+     * Embedded recipients.
+     */
+    r: NotificationBoxRecipient[];
+    /**
+     * Latest week.
+     */
+    w: YearWeekCode;
+    /**
+     * True if this NotificationBox needs to be sync'd/initialized with the original model.
+     *
+     * Is set false if/when "fi" is set true.
+     */
+    s?: Maybe<NeedsSyncBoolean>;
+    /**
+     * True if this NotificationBox has been flagged invalid.
+     *
+     * This is for cases where the NotificationBox cannot be properly initiialized.
+     *
+     * NOTE: The server can also be configured to automatically delete matching boxes instead of marking them as invalid.
+     */
+    fi?: Maybe<SavedToFirestoreIfTrue>;
+}
+/**
+ * NotificationBox roles
+ *
+ * subscribe: user can subscribe or unsubscribe to/from this notification box and manage themselves.
+ * manageRecipients: user can manage all recipients
+ */
+export type NotificationBoxRoles = 'subscribe' | 'manageRecipients' | 'createNotification' | GrantedReadRole | GrantedUpdateRole;
+export declare class NotificationBoxDocument extends AbstractFirestoreDocument<NotificationBox, NotificationBoxDocument, typeof notificationBoxIdentity> {
+    get modelIdentity(): import("../../common").RootFirestoreModelIdentity<"notificationBox", "nb">;
+}
+export declare const notificationBoxConverter: import("../../common").SnapshotConverterFunctions<NotificationBox, Partial<import("@dereekb/util").ReplaceType<NotificationBox, import("@dereekb/util").MaybeMap<object>, any>>>;
+export declare function notificationBoxCollectionReference(context: FirestoreContext): CollectionReference<NotificationBox>;
+export type NotificationBoxFirestoreCollection = FirestoreCollection<NotificationBox, NotificationBoxDocument>;
+export declare function notificationBoxFirestoreCollection(firestoreContext: FirestoreContext): NotificationBoxFirestoreCollection;
+export declare const notificationIdentity: import("../../common").FirestoreModelIdentityWithParent<import("../../common").RootFirestoreModelIdentity<"notificationBox", "nb">, "notification", "nbn">;
+export declare enum NotificationSendType {
+    /**
+     * Sends only if the NotificationBox exists.
+     *
+     * Does not create a NotificationBox for the model.
+     */
+    SEND_IF_BOX_EXISTS = 0,
+    /**
+     * Creates a NotificationBox if it doesn't exist, and then sends the Notification.
+     */
+    INIT_BOX_AND_SEND = 1,
+    /**
+     * Sends the notification even if the NotificationBox does not exist.
+     */
+    SEND_WITHOUT_CREATING_BOX = 2
+}
+export declare enum NotificationSendState {
+    /**
+     * Notification will not be sent.
+     */
+    NONE = -1,
+    /**
+     * Notification is queued up.
+     */
+    QUEUED = 0,
+    /**
+     * Notification has been sent. Will still show as sent even if there were no messages/recipients to send for this medium.
+     */
+    SENT = 1,
+    /**
+     * Some of the notifications have been sent, but some failed.
+     */
+    SENT_PARTIAL = 2,
+    /**
+     * Notification has been skipped due to the box's settings.
+     */
+    SKIPPED = 3,
+    /**
+     * Notification is flagged as being skipped and should not be reattempetd
+     */
+    NO_TRY = 4,
+    /**
+     * Notification encountered an error while sending and could not be sent.
+     */
+    SEND_ERROR = 5,
+    /**
+     * Notification encountered an error while building and could not be sent.
+     */
+    BUILD_ERROR = 6,
+    /**
+     * Notification encountered an error due to the system not being configured properly.
+     */
+    CONFIG_ERROR = 7
+}
+export declare enum NotificationType {
+    /**
+     * Normal notification that is sent to everyone that is configured for the notification box.
+     */
+    NORMAL = 0,
+    /**
+     * Notification that goes to only the configured users.
+     */
+    AD_HOC = 1
+}
+export declare enum NotificationRecipientSendFlag {
+    /**
+     * Will send to all recipients.
+     */
+    NORMAL = 0,
+    /**
+     * Will not send to any of the configured notification box recipients. Will only to the globally configured message recpients or the notification specified recipients.
+     */
+    SKIP_NOTIFICATION_BOX_RECIPIENTS = 1,
+    /**
+     * Will not send to any of the globally configured message recpients. Will only send to the notification specified recipients or the notification box recipients.
+     */
+    SKIP_GLOBAL_RECIPIENTS = 2,
+    /**
+     * Will only sent to recipients that are configured in this notification. Will not send to globally configured message recipients or notification box recipients.
+     */
+    ONLY_EXPLICIT_RECIPIENTS = 3,
+    /**
+     * Will only sent to globally configured message recipients.
+     */
+    ONLY_GLOBAL_RECIPIENTS = 4
+}
+export interface NotificationSendFlags {
+    /**
+     * Text send state
+     */
+    ts: NotificationSendState;
+    /**
+     * Email send state
+     */
+    es: NotificationSendState;
+    /**
+     * Push notification send state
+     */
+    ps: NotificationSendState;
+    /**
+     * Notification summary send state
+     */
+    ns: NotificationSendState;
+    /**
+     * Push notification recipient send flag. Determines who will recieve the notifications, and if it should be saved to the NotificationWeek once sent.
+     */
+    rf?: Maybe<NotificationRecipientSendFlag>;
+}
+/**
+ * Contains information about which recipients were already sent their messages, etc.
+ */
+export interface NotificationSendCheckpoints {
+    /**
+     * Set of numbers the notification was sent to via text/sms.
+     */
+    tsr: E164PhoneNumber[];
+    /**
+     * Set of emails that the notification was set to via email.
+     */
+    esr: EmailAddress[];
+}
+export interface Notification extends NotificationSendFlags, NotificationSendCheckpoints {
+    /**
+     * Send type
+     */
+    st: NotificationSendType;
+    /**
+     * Notification item
+     */
+    n: NotificationItem;
+    /**
+     * Additional embedded recipients.
+     */
+    r: NotificationRecipientWithConfig[];
+    /**
+     * Minimum time at which this notification should be sent.
+     *
+     * The notification is only guranteed to be sent after this time.
+     *
+     * This value is also used for locking/retrying. When locked for sending it is updated to push sat back a few minutes and increase the send attempts.
+     */
+    sat: Date;
+    /**
+     * Sending attempts count.
+     */
+    a: number;
+    /**
+     * Notification has been delivered or should be archived. This is now safe to sync to the NotificationWeek and then delete this.
+     */
+    d: boolean;
+}
+export type NotificationRoles = GrantedUpdateRole;
+export declare class NotificationDocument extends AbstractFirestoreDocumentWithParent<NotificationBox, Notification, NotificationDocument, typeof notificationIdentity> {
+    get modelIdentity(): import("../../common").FirestoreModelIdentityWithParent<import("../../common").RootFirestoreModelIdentity<"notificationBox", "nb">, "notification", "nbn">;
+}
+export declare const notificationConverter: import("../../common").SnapshotConverterFunctions<Notification, Partial<import("@dereekb/util").ReplaceType<Notification, import("@dereekb/util").MaybeMap<object>, any>>>;
+export declare function notificationCollectionReferenceFactory(context: FirestoreContext): (notificationBox: NotificationBoxDocument) => CollectionReference<Notification>;
+export type NotificationFirestoreCollection = FirestoreCollectionWithParent<Notification, NotificationBox, NotificationDocument, NotificationBoxDocument>;
+export type NotificationFirestoreCollectionFactory = (parent: NotificationBoxDocument) => NotificationFirestoreCollection;
+export declare function notificationFirestoreCollectionFactory(firestoreContext: FirestoreContext): NotificationFirestoreCollectionFactory;
+export declare function notificationCollectionReference(context: FirestoreContext): CollectionGroup<Notification>;
+export type NotificationFirestoreCollectionGroup = FirestoreCollectionGroup<Notification, NotificationDocument>;
+export declare function notificationFirestoreCollectionGroup(firestoreContext: FirestoreContext): NotificationFirestoreCollectionGroup;
+export declare const notificationWeekIdentity: import("../../common").FirestoreModelIdentityWithParent<import("../../common").RootFirestoreModelIdentity<"notificationBox", "nb">, "notificationWeek", "nbnw">;
+/**
+ * The maximum number of notifications that can be stored in a NotificationWeek.
+ */
+export declare const NOTIFICATION_WEEK_NOTIFICATION_ITEM_LIMIT = 5000;
+/**
+ * Notification week. Contains all notifications in the box for the given week.
+ */
+export interface NotificationWeek {
+    /**
+     * YearWeekCode value. Same as the id.
+     */
+    w: YearWeekCode;
+    /**
+     * Notification items.
+     */
+    n: NotificationItem[];
+}
+export type NotificationWeekRoles = GrantedReadRole;
+export declare class NotificationWeekDocument extends AbstractFirestoreDocumentWithParent<NotificationBox, NotificationWeek, NotificationWeekDocument, typeof notificationWeekIdentity> {
+    get modelIdentity(): import("../../common").FirestoreModelIdentityWithParent<import("../../common").RootFirestoreModelIdentity<"notificationBox", "nb">, "notificationWeek", "nbnw">;
+}
+export declare const notificationWeekConverter: import("../../common").SnapshotConverterFunctions<NotificationWeek, Partial<import("@dereekb/util").ReplaceType<NotificationWeek, import("@dereekb/util").MaybeMap<object>, any>>>;
+export declare function notificationWeekCollectionReferenceFactory(context: FirestoreContext): (notificationBox: NotificationBoxDocument) => CollectionReference<NotificationWeek>;
+export type NotificationWeekFirestoreCollection = FirestoreCollectionWithParent<NotificationWeek, NotificationBox, NotificationWeekDocument, NotificationBoxDocument>;
+export type NotificationWeekFirestoreCollectionFactory = (parent: NotificationBoxDocument) => NotificationWeekFirestoreCollection;
+export declare function notificationWeekFirestoreCollectionFactory(firestoreContext: FirestoreContext): NotificationWeekFirestoreCollectionFactory;
+export declare function notificationWeekCollectionReference(context: FirestoreContext): CollectionGroup<NotificationWeek>;
+export type NotificationWeekFirestoreCollectionGroup = FirestoreCollectionGroup<NotificationWeek, NotificationWeekDocument>;
+export declare function notificationWeekFirestoreCollectionGroup(firestoreContext: FirestoreContext): NotificationWeekFirestoreCollectionGroup;

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

@@ -0,0 +1,98 @@
+import { type Maybe } from '@dereekb/util';
+import { type FirestoreModelIdentity, type ReadFirestoreModelKeyInput } from '../../common';
+import { type NotificationTemplateType } from './notification.id';
+/**
+ * Template type identifier of the notification.
+ *
+ * Provides default information for the notification.
+ *
+ * Types are generally intended to be handled case-insensitively by notification services.
+ */
+export interface NotificationTemplateTypeInfo {
+    /**
+     * Notification type
+     */
+    readonly type: NotificationTemplateType;
+    /**
+     * The notification's name
+     */
+    readonly name: string;
+    /**
+     * Description of the notification's content.
+     */
+    readonly description: string;
+    /**
+     * Model identity that this notification is for.
+     *
+     * This model will have a NotificationBox associated with it.
+     */
+    readonly notificationModelIdentity: FirestoreModelIdentity;
+    /**
+     * Optional target model identity that this notification references.
+     *
+     * If not defined, it is assumed that the notificationModelIdentity is the target model.
+     *
+     * This model will not have a NotificationBox associated with it, and is typically a child model of the notificationModelIdentity.
+     */
+    readonly targetModelIdentity?: Maybe<FirestoreModelIdentity>;
+}
+/**
+ * Record of NotificationTemplateTypeInfo keyed by type.
+ */
+export type NotificationTemplateTypeInfoRecord = Record<NotificationTemplateType, NotificationTemplateTypeInfo>;
+/**
+ * Creates a NotificationTemplateTypeInfoRecord from the input details array.
+ *
+ * @param infoArray
+ * @returns
+ */
+export declare function notificationTemplateTypeDetailsRecord(infoArray: NotificationTemplateTypeInfo[]): NotificationTemplateTypeInfoRecord;
+/**
+ * Reference to a NotificationTemplateTypeInfoRecord that contains a AppNotificationTemplateTypeInfoRecordService
+ */
+export interface AppNotificationTemplateTypeInfoRecordServiceRef {
+    readonly appNotificationTemplateTypeInfoRecordService: AppNotificationTemplateTypeInfoRecordService;
+}
+export declare abstract class AppNotificationTemplateTypeInfoRecordService {
+    /**
+     * All records for this app.
+     */
+    abstract readonly appNotificationTemplateTypeInfoRecord: NotificationTemplateTypeInfoRecord;
+    /**
+     * Returns the array of all known NotificationTemplateTypes
+     */
+    abstract getAllKnownTemplateTypes(): NotificationTemplateType[];
+    /**
+     * Returns the array of all known NotificationTemplateTypeInfo
+     */
+    abstract getAllKnownTemplateTypeDetails(): NotificationTemplateTypeInfo[];
+    /**
+     * Returns all individual FirestoreModelIdentity values that are associate with atleast one NotificationTemplateType.
+     */
+    abstract getAllNotificationModelIdentityValues(): FirestoreModelIdentity[];
+    /**
+     * Returns all NotificationTemplateTypes that are associate with the given model input.
+     *
+     * @param model
+     */
+    abstract getTemplateTypesForNotificationModel(model: ReadFirestoreModelKeyInput): NotificationTemplateType[];
+    /**
+     * Returns all NotificationTemplateTypeInfo that are associate with the given model input.
+     *
+     * @param model
+     */
+    abstract getTemplateTypesDetailsForNotificationModel(model: ReadFirestoreModelKeyInput): NotificationTemplateTypeInfo[];
+    /**
+     * Returns all NotificationTemplateTypes that are associate with the given model input.
+     *
+     * @param model
+     */
+    abstract getTemplateTypesForTargetModel(target: ReadFirestoreModelKeyInput): NotificationTemplateType[];
+    /**
+     * Returns all NotificationTemplateTypeInfo that are associate with the given model input.
+     *
+     * @param model
+     */
+    abstract getTemplateTypesDetailsForTargetModel(target: ReadFirestoreModelKeyInput): NotificationTemplateTypeInfo[];
+}
+export declare function appNotificationTemplateTypeInfoRecordService(appNotificationTemplateTypeInfoRecord: NotificationTemplateTypeInfoRecord): AppNotificationTemplateTypeInfoRecordService;

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

@@ -0,0 +1,49 @@
+import { type FactoryWithRequiredInput } from '@dereekb/util';
+import { type FirestoreModelId, type FirestoreModelKey, type FlatFirestoreModelKey, twoWayFlatFirestoreModelKey, inferKeyFromTwoWayFlatFirestoreModelKey, type FirebaseAuthUserId, type RootFirestoreModelIdentity } from '../../common';
+/**
+ * The NotificationBox's id is the two way flat firestore model key of the object that it represents.
+ */
+export type NotificationBoxId = FlatFirestoreModelKey;
+export type NotificationBoxKey = FirestoreModelKey;
+/**
+ * Creates a NotificationBoxId from the input FirestoreModelKey.
+ *
+ * @param modelKey
+ * @returns
+ */
+export declare const notificationBoxIdForModel: typeof twoWayFlatFirestoreModelKey;
+export declare const inferNotificationBoxRelatedModelKey: typeof inferKeyFromTwoWayFlatFirestoreModelKey;
+export type NotificationUserId = FlatFirestoreModelKey;
+export type NotificationUserKey = FirestoreModelKey;
+export type NotificationSummaryId = FlatFirestoreModelKey;
+export type NotificationSummaryKey = FirestoreModelKey;
+/**
+ * Creates a NotificationSummaryId from the input FirestoreModelKey.
+ *
+ * @param modelKey
+ * @returns
+ */
+export declare const notificationSummaryIdForModel: typeof twoWayFlatFirestoreModelKey;
+/**
+ * Function used to retrieve a NotificationSummaryId given the input FirestoreAuthUserId.
+ */
+export type NotificationSummaryIdForUidFunction = FactoryWithRequiredInput<NotificationSummaryId, FirebaseAuthUserId>;
+export declare function notificationSummaryIdForUidFunctionForRootFirestoreModelIdentity(userModelIdentity: RootFirestoreModelIdentity): NotificationSummaryIdForUidFunction;
+export type NotificationWeekId = FirestoreModelId;
+export type NotificationWeekKey = FirestoreModelKey;
+export type NotificationId = FirestoreModelId;
+export type NotificationKey = FirestoreModelKey;
+/**
+ * The default notification template type that can be provided to subscribe to notifications not specified in the configurations.
+ */
+export declare const DEFAULT_NOTIFICATION_TEMPLATE_TYPE = "D";
+/**
+ * Template type identifier of the notification.
+ *
+ * Provides default information for the notification.
+ *
+ * Types are generally intended to be handled case-insensitively by notification services.
+ *
+ * Ideally type type values are shorter to reduce database size impact.
+ */
+export type NotificationTemplateType = string;

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

@@ -0,0 +1,70 @@
+import { type Maybe } from '@dereekb/util';
+import { type FirebaseAuthUserId, type FirestoreModelKey, type SavedToFirestoreIfTrue } from '../../common';
+import { type NotificationId, type NotificationTemplateType } from './notification.id';
+/**
+ * Arbitrary metadata for a job. Derived/managed by the concrete job type.
+ */
+export type NotificationItemMetadata = Readonly<Record<string, any>>;
+export interface NotificationItemSubjectMessagePair<D extends NotificationItemMetadata = {}> {
+    readonly item: NotificationItem<D>;
+    readonly subject: string;
+    readonly message: string;
+    readonly date: Date;
+}
+/**
+ * A notification item.
+ *
+ * Is embedded within a Notification, NotificationWeek, and NotificationSummary.
+ */
+export interface NotificationItem<D extends NotificationItemMetadata = {}> {
+    /**
+     * Unique identifier
+     */
+    id: NotificationId;
+    /**
+     * Notification date/time
+     */
+    cat: Date;
+    /**
+     * Notification template type.
+     */
+    t: NotificationTemplateType;
+    /**
+     * User who created this notification, if applicable.
+     */
+    cb?: Maybe<FirebaseAuthUserId>;
+    /**
+     * Model/object that this notification item is targeting.
+     */
+    m?: Maybe<FirestoreModelKey>;
+    /**
+     * Subject. Used to overwrite the template's default subject.
+     */
+    s?: Maybe<string>;
+    /**
+     * Message. Used to overwrite the template's default message.
+     */
+    g?: Maybe<string>;
+    /**
+     * Arbitrary metadata attached to the notification item.
+     */
+    d?: Maybe<D>;
+    /**
+     * True if this notification item is marked as read/viewed.
+     */
+    v?: Maybe<SavedToFirestoreIfTrue>;
+}
+export declare const firestoreNotificationItem: import("../../common").FirestoreSubObjectFieldMapFunctionsConfig<NotificationItem<{}>, Partial<import("@dereekb/util").ReplaceType<NotificationItem<{}>, import("@dereekb/util").MaybeMap<object>, any>>>;
+export interface UnreadNotificationItemsResult<D extends NotificationItemMetadata = {}> {
+    readonly items: NotificationItem<D>[];
+    readonly considerReadIfCreatedBefore?: Maybe<Date>;
+    readonly read: NotificationItem<D>[];
+    readonly unread: NotificationItem<D>[];
+}
+/**
+ * Returns an object containing input notification items split up by their determined read/unread state.
+ *
+ * @param items
+ */
+export declare function unreadNotificationItems<D extends NotificationItemMetadata = {}>(items: NotificationItem<D>[], considerReadIfCreatedBefore?: Maybe<Date>): UnreadNotificationItemsResult<D>;
+export declare const sortNotificationItemsFunction: import("@dereekb/date").SortByDateFunction<NotificationItem<any>>;