@justair/justair-library 6.12.0 → 6.13.0-alpha.ef692bc

package/dist/constants/alertLevels.d.ts

@@ -0,0 +1,10 @@
+export const ALERT_LEVEL_WEIGHTS: {
+    Good: number;
+    Moderate: number;
+    "Unhealthy for SG": number;
+    Unhealthy: number;
+    "Very Unhealthy": number;
+    Hazardous: number;
+};
+export function getAlertWeight(alertLevel: any): any;
+//# sourceMappingURL=alertLevels.d.ts.map

package/dist/constants/alertLevels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alertLevels.d.ts","sourceRoot":"","sources":["../../src/constants/alertLevels.js"],"names":[],"mappings":"AAQA;;;;;;;EAOE;AAOK,qDACsD"}

package/dist/constants/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./pollutants.js";
+export * from "./alertLevels.js";
+export * from "./userNotifications.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/constants/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/constants/index.js"],"names":[],"mappings":""}

package/dist/constants/tests/constantsBarrel.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=constantsBarrel.test.d.ts.map

package/dist/constants/tests/constantsBarrel.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constantsBarrel.test.d.ts","sourceRoot":"","sources":["../../../src/constants/tests/constantsBarrel.test.js"],"names":[],"mappings":""}

package/dist/constants/userNotifications.d.ts

@@ -0,0 +1,4 @@
+export const NOTIFICATION_KINDS: string[];
+export const NOTIFICATION_CHANNELS: string[];
+export const DELIVERY_STATUSES: string[];
+//# sourceMappingURL=userNotifications.d.ts.map

package/dist/constants/userNotifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"userNotifications.d.ts","sourceRoot":"","sources":["../../src/constants/userNotifications.js"],"names":[],"mappings":"AAYA,0CAKE;AAEF,6CAAwE;AAExE,yCAA8D"}

package/dist/index.d.ts

@@ -75,8 +75,21 @@ import { SamplesAudit } from "./models/samples.js";
 import { sampleParameterReferenceConcentrations } from "./models/samples.js";
 import { passwordResetTokenSchema } from "./models/passwordResetToken.js";
 import { PasswordResetToken } from "./models/passwordResetToken.js";
+import { monitorEpisodesSchema } from "./models/monitorEpisodes.js";
+import { MonitorEpisode } from "./models/monitorEpisodes.js";
+import { userNotificationsSchema } from "./models/userNotifications.js";
+import { UserNotification } from "./models/userNotifications.js";
+import { AqiAlertNotification } from "./models/userNotifications.js";
+import { DeviceOfflineNotification } from "./models/userNotifications.js";
+import { WeeklyDigestNotification } from "./models/userNotifications.js";
+import { AccountNotification } from "./models/userNotifications.js";
+import { NOTIFICATION_KINDS } from "./models/userNotifications.js";
+import { NOTIFICATION_CHANNELS } from "./models/userNotifications.js";
+import { DELIVERY_STATUSES } from "./models/userNotifications.js";
 import { PARAMETERS } from "./constants/pollutants.js";
 import { HEAVY_METALS } from "./constants/pollutants.js";
+import { ALERT_LEVEL_WEIGHTS } from "./constants/alertLevels.js";
+import { getAlertWeight } from "./constants/alertLevels.js";
 import { splitName } from "./utils/splitName.js";
-export { Database, adminSchema, Admin, configurationsSchema, Configurations, measurementsSchema, Measurements, monitorRequestsSchema, MonitorRequests, monitorsSchema, Monitors, organizationsSchema, Organizations, usersSchema, Users, COOKIE_CONSENT_CATEGORIES, COOKIE_CONSENT_VALUES, validateCookieConsent, eventsSchema, Events, lightMonitorSchema, LightMonitors, monitorSuppliersSchema, MonitorSuppliers, contextsSchema, Contexts, parametersSchema, Parameters, announcementSchema, Announcements, jobsSchema, Jobs, apiKeySchema, ApiKey, UsageMetrics, usageMetricsSchema, Audit, auditSchema, EventsAudit, eventsAuditSchema, MonitorAudit, monitorAuditSchema, parametersEnum, deploymentTypesEnum, AlertsAudit, Alerts, alertsSchema, alertsAuditSchema, Features, featuresSchema, dataCompletenessSchema, DataCompleteness, networkMetricsSchema, NetworkMetrics, rateOfChangeSchema, RateOfChange, changeStreamCheckpointsSchema, ChangeStreamCheckpoints, sitesSchema, Sites, sampleSitesSchema, SampleSites, sampleSiteAuditSchema, SampleSiteAudit, sampleParametersEnum, samplesSchema, Samples, samplesAuditSchema, SamplesAudit, sampleParameterReferenceConcentrations, passwordResetTokenSchema, PasswordResetToken, PARAMETERS, HEAVY_METALS, splitName };
+export { Database, adminSchema, Admin, configurationsSchema, Configurations, measurementsSchema, Measurements, monitorRequestsSchema, MonitorRequests, monitorsSchema, Monitors, organizationsSchema, Organizations, usersSchema, Users, COOKIE_CONSENT_CATEGORIES, COOKIE_CONSENT_VALUES, validateCookieConsent, eventsSchema, Events, lightMonitorSchema, LightMonitors, monitorSuppliersSchema, MonitorSuppliers, contextsSchema, Contexts, parametersSchema, Parameters, announcementSchema, Announcements, jobsSchema, Jobs, apiKeySchema, ApiKey, UsageMetrics, usageMetricsSchema, Audit, auditSchema, EventsAudit, eventsAuditSchema, MonitorAudit, monitorAuditSchema, parametersEnum, deploymentTypesEnum, AlertsAudit, Alerts, alertsSchema, alertsAuditSchema, Features, featuresSchema, dataCompletenessSchema, DataCompleteness, networkMetricsSchema, NetworkMetrics, rateOfChangeSchema, RateOfChange, changeStreamCheckpointsSchema, ChangeStreamCheckpoints, sitesSchema, Sites, sampleSitesSchema, SampleSites, sampleSiteAuditSchema, SampleSiteAudit, sampleParametersEnum, samplesSchema, Samples, samplesAuditSchema, SamplesAudit, sampleParameterReferenceConcentrations, passwordResetTokenSchema, PasswordResetToken, monitorEpisodesSchema, MonitorEpisode, userNotificationsSchema, UserNotification, AqiAlertNotification, DeviceOfflineNotification, WeeklyDigestNotification, AccountNotification, NOTIFICATION_KINDS, NOTIFICATION_CHANNELS, DELIVERY_STATUSES, PARAMETERS, HEAVY_METALS, ALERT_LEVEL_WEIGHTS, getAlertWeight, splitName };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AA4FA;;;iBAEC;yBA5BwB,oBAAoB;qBADxB,gBAAgB;4BAjEF,mBAAmB;sBAAnB,mBAAmB;qCAI/C,4BAA4B;+BAA5B,4BAA4B;mCAM5B,0BAA0B;6BAA1B,0BAA0B;sCAI1B,6BAA6B;gCAA7B,6BAA6B;+BAQ7B,sBAAsB;yBAAtB,sBAAsB;oCACsB,2BAA2B;8BAA3B,2BAA2B;4BAcvE,mBAAmB;sBAAnB,mBAAmB;0CAAnB,mBAAmB;sCAAnB,mBAAmB;sCAAnB,mBAAmB;6BAMnB,oBAAoB;uBAApB,oBAAoB;mCAnBuB,2BAA2B;8BAA3B,2BAA2B;uCAItE,8BAA8B;iCAA9B,8BAA8B;+BACI,sBAAsB;yBAAtB,sBAAsB;iCAClB,wBAAwB;2BAAxB,wBAAwB;mCAcnB,2BAA2B;8BAA3B,2BAA2B;2BAC5C,kBAAkB;qBAAlB,kBAAkB;6BACd,oBAAoB;uBAApB,oBAAoB;6BACR,0BAA0B;mCAA1B,0BAA0B;sBArCpE,0BAA0B;4BAA1B,0BAA0B;4BAiC1B,oBAAoB;kCAApB,oBAAoB;6BArBpB,sBAAsB;mCAAtB,sBAAsB;+BAAtB,sBAAsB;oCAAtB,sBAAsB;4BA+BtB,oBAAoB;uBAApB,oBAAoB;6BAApB,oBAAoB;kCAApB,oBAAoB;yBACc,sBAAsB;+BAAtB,sBAAsB;uCAIxD,8BAA8B;iCAA9B,8BAA8B;qCACgB,4BAA4B;+BAA5B,4BAA4B;mCAChC,0BAA0B;6BAA1B,0BAA0B;8CAIpE,qCAAqC;wCAArC,qCAAqC;4BAOT,mBAAmB;sBAAnB,mBAAmB;kCAS/C,yBAAyB;4BAAzB,yBAAyB;sCAAzB,yBAAyB;gCAAzB,yBAAyB;qCAAzB,yBAAyB;8BASzB,qBAAqB;wBAArB,qBAAqB;mCAArB,qBAAqB;6BAArB,qBAAqB;uDAArB,qBAAqB;yCACiC,gCAAgC;mCAAhC,gCAAgC;2BAvBpD,2BAA2B;6BAA3B,2BAA2B;0BAC1C,sBAAsB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AA4GA;;;iBAEC;yBA5CwB,oBAAoB;qBADxB,gBAAgB;4BAjEF,mBAAmB;sBAAnB,mBAAmB;qCAI/C,4BAA4B;+BAA5B,4BAA4B;mCAM5B,0BAA0B;6BAA1B,0BAA0B;sCAI1B,6BAA6B;gCAA7B,6BAA6B;+BAQ7B,sBAAsB;yBAAtB,sBAAsB;oCACsB,2BAA2B;8BAA3B,2BAA2B;4BAcvE,mBAAmB;sBAAnB,mBAAmB;0CAAnB,mBAAmB;sCAAnB,mBAAmB;sCAAnB,mBAAmB;6BAMnB,oBAAoB;uBAApB,oBAAoB;mCAnBuB,2BAA2B;8BAA3B,2BAA2B;uCAItE,8BAA8B;iCAA9B,8BAA8B;+BACI,sBAAsB;yBAAtB,sBAAsB;iCAClB,wBAAwB;2BAAxB,wBAAwB;mCAcnB,2BAA2B;8BAA3B,2BAA2B;2BAC5C,kBAAkB;qBAAlB,kBAAkB;6BACd,oBAAoB;uBAApB,oBAAoB;6BACR,0BAA0B;mCAA1B,0BAA0B;sBArCpE,0BAA0B;4BAA1B,0BAA0B;4BAiC1B,oBAAoB;kCAApB,oBAAoB;6BArBpB,sBAAsB;mCAAtB,sBAAsB;+BAAtB,sBAAsB;oCAAtB,sBAAsB;4BA+BtB,oBAAoB;uBAApB,oBAAoB;6BAApB,oBAAoB;kCAApB,oBAAoB;yBACc,sBAAsB;+BAAtB,sBAAsB;uCAIxD,8BAA8B;iCAA9B,8BAA8B;qCACgB,4BAA4B;+BAA5B,4BAA4B;mCAChC,0BAA0B;6BAA1B,0BAA0B;8CAIpE,qCAAqC;wCAArC,qCAAqC;4BAuBT,mBAAmB;sBAAnB,mBAAmB;kCAS/C,yBAAyB;4BAAzB,yBAAyB;sCAAzB,yBAAyB;gCAAzB,yBAAyB;qCAAzB,yBAAyB;8BASzB,qBAAqB;wBAArB,qBAAqB;mCAArB,qBAAqB;6BAArB,qBAAqB;uDAArB,qBAAqB;yCACiC,gCAAgC;mCAAhC,gCAAgC;sCAlCtF,6BAA6B;+BAA7B,6BAA6B;wCAW7B,+BAA+B;iCAA/B,+BAA+B;qCAA/B,+BAA+B;0CAA/B,+BAA+B;yCAA/B,+BAA+B;oCAA/B,+BAA+B;mCAA/B,+BAA+B;sCAA/B,+BAA+B;kCAA/B,+BAA+B;2BAhBG,2BAA2B;6BAA3B,2BAA2B;oCAChB,4BAA4B;+BAA5B,4BAA4B;0BAgBtD,sBAAsB"}

package/dist/models/monitorEpisodes.d.ts

@@ -0,0 +1,266 @@
+export const monitorEpisodesSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    monitor: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    open: boolean;
+    startedAt: Date;
+    alertCount: number;
+    firstNotifiedAt?: Date;
+    endedAt?: Date;
+    peakStatus?: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    monitor: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    open: boolean;
+    startedAt: Date;
+    alertCount: number;
+    firstNotifiedAt?: Date;
+    endedAt?: Date;
+    peakStatus?: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    monitor: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    open: boolean;
+    startedAt: Date;
+    alertCount: number;
+    firstNotifiedAt?: Date;
+    endedAt?: Date;
+    peakStatus?: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+export const MonitorEpisode: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    monitor: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    open: boolean;
+    startedAt: Date;
+    alertCount: number;
+    firstNotifiedAt?: Date;
+    endedAt?: Date;
+    peakStatus?: string;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    monitor: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    open: boolean;
+    startedAt: Date;
+    alertCount: number;
+    firstNotifiedAt?: Date;
+    endedAt?: Date;
+    peakStatus?: string;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    monitor: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    open: boolean;
+    startedAt: Date;
+    alertCount: number;
+    firstNotifiedAt?: Date;
+    endedAt?: Date;
+    peakStatus?: string;
+} & {
+    _id: mongoose.Types.ObjectId;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    monitor: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    open: boolean;
+    startedAt: Date;
+    alertCount: number;
+    firstNotifiedAt?: Date;
+    endedAt?: Date;
+    peakStatus?: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    monitor: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    open: boolean;
+    startedAt: Date;
+    alertCount: number;
+    firstNotifiedAt?: Date;
+    endedAt?: Date;
+    peakStatus?: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    monitor: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    open: boolean;
+    startedAt: Date;
+    alertCount: number;
+    firstNotifiedAt?: Date;
+    endedAt?: Date;
+    peakStatus?: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>>;
+import mongoose from "mongoose";
+//# sourceMappingURL=monitorEpisodes.d.ts.map

package/dist/models/monitorEpisodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monitorEpisodes.d.ts","sourceRoot":"","sources":["../../src/models/monitorEpisodes.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoBE;AA2BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA+E;qBA7E1D,UAAU"}

package/dist/models/monitors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"monitors.d.ts","sourceRoot":"","sources":["../../src/models/monitors.js"],"names":[],"mappings":"AA4KA,iCA6IE;AAuIF,2BAA4D;AA3T5D,qCAiCE;AAGF,+BAAwE;AAtKxE,sCAAoD"}
+{"version":3,"file":"monitors.d.ts","sourceRoot":"","sources":["../../src/models/monitors.js"],"names":[],"mappings":"AA4KA,iCAmJE;AAuIF,2BAA4D;AAjU5D,qCAiCE;AAGF,+BAAwE;AAtKxE,sCAAoD"}

package/dist/models/tests/monitorEpisodes.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=monitorEpisodes.test.d.ts.map

package/dist/models/tests/monitorEpisodes.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monitorEpisodes.test.d.ts","sourceRoot":"","sources":["../../../src/models/tests/monitorEpisodes.test.js"],"names":[],"mappings":""}

package/dist/models/tests/monitorsLeftGoodAt.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=monitorsLeftGoodAt.test.d.ts.map

package/dist/models/tests/monitorsLeftGoodAt.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monitorsLeftGoodAt.test.d.ts","sourceRoot":"","sources":["../../../src/models/tests/monitorsLeftGoodAt.test.js"],"names":[],"mappings":""}

package/dist/models/tests/userNotifications.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=userNotifications.test.d.ts.map

package/dist/models/tests/userNotifications.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"userNotifications.test.d.ts","sourceRoot":"","sources":["../../../src/models/tests/userNotifications.test.js"],"names":[],"mappings":""}

package/dist/models/userNotifications.d.ts

@@ -0,0 +1,175 @@
+declare const baseSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+    discriminatorKey: string;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    channel: string;
+    status: string;
+    sentAt: Date;
+    message?: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    channel: string;
+    status: string;
+    sentAt: Date;
+    message?: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    channel: string;
+    status: string;
+    sentAt: Date;
+    message?: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+export const UserNotification: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    channel: string;
+    status: string;
+    sentAt: Date;
+    message?: string;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    channel: string;
+    status: string;
+    sentAt: Date;
+    message?: string;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    channel: string;
+    status: string;
+    sentAt: Date;
+    message?: string;
+} & {
+    _id: mongoose.Types.ObjectId;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+    discriminatorKey: string;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    channel: string;
+    status: string;
+    sentAt: Date;
+    message?: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    channel: string;
+    status: string;
+    sentAt: Date;
+    message?: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    channel: string;
+    status: string;
+    sentAt: Date;
+    message?: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>>;
+export const AqiAlertNotification: mongoose.Model<any, {}, {}, {}, any, any>;
+export const DeviceOfflineNotification: mongoose.Model<any, {}, {}, {}, any, any>;
+export const WeeklyDigestNotification: mongoose.Model<any, {}, {}, {}, any, any>;
+export const AccountNotification: mongoose.Model<any, {}, {}, {}, any, any>;
+import mongoose from "mongoose";
+export { baseSchema as userNotificationsSchema };
+export { NOTIFICATION_KINDS, NOTIFICATION_CHANNELS, DELIVERY_STATUSES } from "../constants/userNotifications.js";
+//# sourceMappingURL=userNotifications.d.ts.map

package/dist/models/userNotifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"userNotifications.d.ts","sourceRoot":"","sources":["../../src/models/userNotifications.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuBE;AAQF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAwE;AAgBxE,6EAGE;AAOF,kFAGE;AAQF,iFAGE;AAGF,4EAGE;qBA1GmB,UAAU"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justair/justair-library",
-  "version": "6.12.0",
+  "version": "6.13.0-alpha.ef692bc",
   "description": "JustAir Internal Library",
   "main": "src/index.js",
   "type": "module",
@@ -11,8 +11,8 @@
       "default": "./src/index.js"
     },
     "./constants": {
-      "types": "./dist/constants/pollutants.d.ts",
-      "default": "./src/constants/pollutants.js"
+      "types": "./dist/constants/index.d.ts",
+      "default": "./src/constants/index.js"
     },
     "./auth": {
       "types": "./dist/modules/auth/index.d.ts",

package/src/constants/alertLevels.js

@@ -0,0 +1,24 @@
+// AQI alert-level hierarchy — single source of truth (JA-2658, eng review
+// issue 7). Consumers: JustAirNotificationService statusAlerts threshold
+// logic, CalculateAQIService determineHighestAlertLevel, and the
+// MonitorEpisode/UserNotification schema enums.
+//
+// DO NOT change these values — the integers map directly to user
+// alertPreferenceLevel thresholds and Courier email template selection.
+
+export const ALERT_LEVEL_WEIGHTS = {
+  Good: 1,
+  Moderate: 2,
+  "Unhealthy for SG": 3,
+  Unhealthy: 4,
+  "Very Unhealthy": 5,
+  Hazardous: 6,
+};
+
+// Weight lookup with the platform's long-standing fallback: unknown statuses
+// weigh the same as Good, i.e. they never alert and never open episodes.
+// This deliberately covers the legacy "Bad" value still present in the
+// monitorAlertStatus enum (monitors.js) — candidate for a data migration,
+// tracked in JustAirNotificationService/TODOS.md context.
+export const getAlertWeight = (alertLevel) =>
+  ALERT_LEVEL_WEIGHTS[alertLevel] || ALERT_LEVEL_WEIGHTS.Good;

package/src/constants/index.js

@@ -0,0 +1,12 @@
+// Barrel for the `@justair/justair-library/constants` entry point.
+//
+// Backward compatibility contract: this file MUST re-export everything
+// pollutants.js exports, because package.json's `./constants` subpath pointed
+// straight at pollutants.js before alertLevels.js existed — existing
+// `import { PARAMETERS, HEAVY_METALS } from "@justair/justair-library/constants"`
+// call sites across the platform must keep working unchanged.
+// (Verified by src/constants/tests/constantsBarrel.test.js.)
+
+export * from "./pollutants.js";
+export * from "./alertLevels.js";
+export * from "./userNotifications.js";

package/src/constants/tests/constantsBarrel.test.js

@@ -0,0 +1,46 @@
+// The `./constants` package subpath used to point directly at pollutants.js.
+// It now points at the index.js barrel so alertLevels.js can share the entry
+// point. These tests pin the backward-compatibility contract: every consumer
+// importing PARAMETERS / HEAVY_METALS through the barrel must see the exact
+// same objects as before.
+import * as barrel from '../index.js';
+import { PARAMETERS, HEAVY_METALS } from '../pollutants.js';
+import { ALERT_LEVEL_WEIGHTS, getAlertWeight } from '../alertLevels.js';
+
+test('barrel re-exports PARAMETERS and HEAVY_METALS unchanged (identity, not copies)', () => {
+  expect(barrel.PARAMETERS).toBe(PARAMETERS);
+  expect(barrel.HEAVY_METALS).toBe(HEAVY_METALS);
+});
+
+test('barrel exports the alert-level constants', () => {
+  expect(barrel.ALERT_LEVEL_WEIGHTS).toBe(ALERT_LEVEL_WEIGHTS);
+  expect(barrel.getAlertWeight).toBe(getAlertWeight);
+});
+
+test('ALERT_LEVEL_WEIGHTS carries the exact platform hierarchy (values map to thresholds + Courier templates)', () => {
+  expect(ALERT_LEVEL_WEIGHTS).toEqual({
+    Good: 1,
+    Moderate: 2,
+    'Unhealthy for SG': 3,
+    Unhealthy: 4,
+    'Very Unhealthy': 5,
+    Hazardous: 6,
+  });
+});
+
+test('getAlertWeight resolves every known level', () => {
+  expect(getAlertWeight('Good')).toBe(1);
+  expect(getAlertWeight('Moderate')).toBe(2);
+  expect(getAlertWeight('Unhealthy for SG')).toBe(3);
+  expect(getAlertWeight('Unhealthy')).toBe(4);
+  expect(getAlertWeight('Very Unhealthy')).toBe(5);
+  expect(getAlertWeight('Hazardous')).toBe(6);
+});
+
+test('unknown and legacy statuses fall back to the Good weight (never alert, never open episodes)', () => {
+  // "Bad" still exists in the monitorAlertStatus enum — deliberately non-alerting.
+  expect(getAlertWeight('Bad')).toBe(1);
+  expect(getAlertWeight(undefined)).toBe(1);
+  expect(getAlertWeight(null)).toBe(1);
+  expect(getAlertWeight('')).toBe(1);
+});

package/src/constants/userNotifications.js

@@ -0,0 +1,22 @@
+// UserNotification vocabulary — source of truth for the send-log enums
+// (JA-2658). Kept here (Mongoose-free) so consumers can import the kind /
+// channel / status lists without pulling in the models.
+//
+// Three orthogonal axes, deliberately separated:
+// - `kind`    — what the notification is ABOUT (selects the discriminator
+//               that carries the kind-specific payload).
+// - `channel` — HOW it was delivered. Independent of kind: an aqi_alert can
+//               go out over sms and email as two separate rows.
+// - `status`  — the DELIVERY outcome. Universal across every kind; this is
+//               what "status" means and must not be confused with AQI level.
+
+export const NOTIFICATION_KINDS = [
+  "aqi_alert",
+  "device_offline",
+  "weekly_digest",
+  "account",
+];
+
+export const NOTIFICATION_CHANNELS = ["sms", "email", "push", "in_app"];
+
+export const DELIVERY_STATUSES = ["queued", "sent", "failed"];

package/src/index.js

@@ -66,6 +66,22 @@ import {
 import Database from "./config/db.js"; // Import the new Database class
 import CustomLogger from "./config/logger.js";
 import { PARAMETERS, HEAVY_METALS } from "./constants/pollutants.js";
+import { ALERT_LEVEL_WEIGHTS, getAlertWeight } from "./constants/alertLevels.js";
+import {
+  monitorEpisodesSchema,
+  MonitorEpisode,
+} from "./models/monitorEpisodes.js";
+import {
+  userNotificationsSchema,
+  UserNotification,
+  AqiAlertNotification,
+  DeviceOfflineNotification,
+  WeeklyDigestNotification,
+  AccountNotification,
+  NOTIFICATION_KINDS,
+  NOTIFICATION_CHANNELS,
+  DELIVERY_STATUSES,
+} from "./models/userNotifications.js";
 import { splitName } from "./utils/splitName.js";
 
 // Sites related imports
@@ -171,9 +187,24 @@ export {
   // Password reset tokens (JA-2946)
   passwordResetTokenSchema,
   PasswordResetToken,
+  // Notification episodes + send log (JA-2658 / JA-2691 stack)
+  monitorEpisodesSchema,
+  MonitorEpisode,
+  userNotificationsSchema,
+  UserNotification,
+  AqiAlertNotification,
+  DeviceOfflineNotification,
+  WeeklyDigestNotification,
+  AccountNotification,
+  NOTIFICATION_KINDS,
+  NOTIFICATION_CHANNELS,
+  DELIVERY_STATUSES,
   // Pollutant constants
   PARAMETERS,
   HEAVY_METALS,
+  // AQI alert-level hierarchy (single source of truth)
+  ALERT_LEVEL_WEIGHTS,
+  getAlertWeight,
   // Utilities
   splitName,
 };

package/src/models/monitorEpisodes.js

@@ -0,0 +1,80 @@
+import mongoose from "mongoose";
+import { ALERT_LEVEL_WEIGHTS } from "../constants/alertLevels.js";
+
+// MonitorEpisode — one mutable doc per OPEN episode per user+device (JA-2658).
+// Written by JustAirNotificationService's alert cron (JA-2958); read by
+// JustAirUserService GET /users/my-monitors (JA-2691).
+//
+//                 Good→nonGood (cron observes; startedAt = Monitors.leftGoodAt ?? now)
+//    (no doc) ───────────────────────────────► OPEN {open:true, startedAt, peakStatus}
+//                                               │  alert event names this monitor
+//                                               ▼
+//                                              OPEN {firstNotifiedAt set once, alertCount++}
+//                 nonGood→Good / sweep          │
+//    TTL 24mo ◄── CLOSED {open:false, endedAt} ◄┘
+//
+// Conventions the indexes DEPEND on — do not relax:
+// - `open` is the lifecycle state field and the partial-index key. MongoDB
+//   partialFilterExpression does NOT support `$exists: false`, so open-ness
+//   must be an explicit boolean, not the absence of endedAt. Close = one
+//   atomic update: { $set: { open: false, endedAt: <now> } }.
+// - endedAt is OMITTED while open (never null) and set exactly once on close;
+//   the TTL index only ever sees closed docs because open docs carry no date.
+// - firstNotifiedAt is OMITTED until the first alert event that names this
+//   monitor; stamps must be only-if-unset so retries can't move the time.
+// - startedAt is the best-known "left Good" time: precise when CalcAQI has
+//   stamped Monitors.leftGoodAt, first-observation time otherwise (day-one
+//   opens and stale monitors carry the cron-observed fallback).
+
+const alertLevelsEnum = [...Object.keys(ALERT_LEVEL_WEIGHTS)];
+
+const monitorEpisodesSchema = new mongoose.Schema(
+  {
+    user: {
+      type: mongoose.Types.ObjectId,
+      ref: "Users",
+      required: true,
+    },
+    monitor: {
+      type: mongoose.Types.ObjectId,
+      ref: "Monitors",
+      required: true,
+    },
+    open: { type: Boolean, default: true, required: true },
+    startedAt: { type: Date, required: true },
+    firstNotifiedAt: { type: Date },
+    endedAt: { type: Date },
+    alertCount: { type: Number, default: 0 },
+    peakStatus: { type: String, enum: alertLevelsEnum },
+  },
+  { timestamps: true },
+);
+
+// Hot path + correctness guarantee: at most ONE open episode per user+device.
+// Duplicate opens from overlapping cron runs surface as E11000 — writers use
+// ordered:false bulkWrite and tolerate the duplicate as a lost race.
+monitorEpisodesSchema.index(
+  { user: 1, monitor: 1 },
+  { unique: true, partialFilterExpression: { open: true } },
+);
+
+// JA-2691 read: all open episodes for one user — query { user, open: true }.
+monitorEpisodesSchema.index(
+  { user: 1 },
+  { partialFilterExpression: { open: true } },
+);
+
+// JA-2958 lifecycle sweep: fetch/inspect all open episodes without scanning
+// 24 months of closed docs — query includes { open: true }.
+monitorEpisodesSchema.index(
+  { monitor: 1 },
+  { partialFilterExpression: { open: true } },
+);
+
+// Retention: closed episodes expire ~24 months after endedAt. Open episodes
+// carry no endedAt date, so the TTL monitor never touches them.
+monitorEpisodesSchema.index({ endedAt: 1 }, { expireAfterSeconds: 63113904 });
+
+const MonitorEpisode = mongoose.model("MonitorEpisode", monitorEpisodesSchema);
+
+export { monitorEpisodesSchema, MonitorEpisode };

package/src/models/monitors.js

@@ -199,6 +199,12 @@ const monitorsSchema = mongoose.Schema(
     monitorType: String,
     monitorIdFromSupplier: String,
     measurementUpdate: Date,
+    // When the device last crossed Good→nonGood, stamped by CalculateAQIService
+    // updateMonitorStatus and $unset on nonGood→Good recovery — so the field
+    // being PRESENT means "currently nonGood since this time". Absent = never
+    // stamped (or currently Good). Read by JustAirNotificationService as the
+    // MonitorEpisode startedAt source (JA-2691 stack). No default on purpose.
+    leftGoodAt: Date,
     monitorProperties: Object,
     isPrivate: { type: Boolean, default: false, required: true },
     monitorState: {

package/src/models/userNotifications.js

@@ -0,0 +1,121 @@
+import mongoose from "mongoose";
+import { ALERT_LEVEL_WEIGHTS } from "../constants/alertLevels.js";
+import {
+  NOTIFICATION_CHANNELS,
+  DELIVERY_STATUSES,
+} from "../constants/userNotifications.js";
+
+// UserNotification — append-only send log, one doc per outbound notification
+// per channel (JA-2658). Written best-effort by JustAirNotificationService
+// after a send is queued (JA-2958); never blocks or gates the send itself.
+//
+// Shape (reshaped for multi-kind support, superseding the 2026-07-07 eng
+// review's aqi-only draft):
+// - The BASE doc holds only what every notification kind shares: the user,
+//   the delivery `channel`, the delivery `status`, the rendered `message`,
+//   and `sentAt`.
+// - `kind` is the Mongoose discriminator key. Each kind registers a
+//   discriminator carrying its own payload, so kind-specific fields
+//   (e.g. the AQI `alertLevel`, `monitors`, `episodes`) never appear on
+//   rows of a kind that has no such concept.
+// - `status` is the DELIVERY outcome (queued / sent / failed) — NOT the AQI
+//   level. The AQI level lives on the aqi_alert discriminator as `alertLevel`.
+//
+// Reconciliation: one alert EVENT (the per-user threshold gate firing)
+// produces one row PER channel actually sent. Episode alertCount is
+// incremented once per EVENT — reconcile counts against events, not rows.
+
+const alertLevelsEnum = [...Object.keys(ALERT_LEVEL_WEIGHTS)];
+
+const baseSchema = new mongoose.Schema(
+  {
+    user: {
+      type: mongoose.Types.ObjectId,
+      ref: "Users",
+      required: true,
+    },
+    channel: { type: String, enum: NOTIFICATION_CHANNELS, required: true },
+    // Delivery outcome, shared across all kinds. Defaults to "queued" since a
+    // row is written as soon as the send is handed off.
+    status: {
+      type: String,
+      enum: DELIVERY_STATUSES,
+      required: true,
+      default: "queued",
+    },
+    message: String,
+    sentAt: { type: Date, default: Date.now, required: true },
+  },
+  {
+    timestamps: true,
+    discriminatorKey: "kind",
+  },
+);
+
+// Per-user history, newest first — every kind.
+baseSchema.index({ user: 1, sentAt: -1 });
+
+// Retention: rows expire ~24 months after send.
+baseSchema.index({ sentAt: 1 }, { expireAfterSeconds: 63113904 });
+
+const UserNotification = mongoose.model("UserNotification", baseSchema);
+
+// aqi_alert — the only kind carrying monitors / episodes / AQI level.
+// `monitors` lists exactly the monitors named in the message
+// (monitorsAtHighestStatus); `episodes` the matching MonitorEpisode _ids —
+// a row is 1:1 reconcilable with the SMS/email content.
+const aqiAlertSchema = new mongoose.Schema({
+  monitors: [{ type: mongoose.Types.ObjectId, ref: "Monitors" }],
+  episodes: [{ type: mongoose.Types.ObjectId, ref: "MonitorEpisode" }],
+  alertLevel: { type: String, enum: alertLevelsEnum, required: true },
+});
+
+// Device-scoped history for one user — only meaningful where `monitors`
+// exists, so it lives on the discriminator (lands on the same collection).
+aqiAlertSchema.index({ user: 1, monitors: 1, sentAt: -1 });
+
+const AqiAlertNotification = UserNotification.discriminator(
+  "aqi_alert",
+  aqiAlertSchema,
+);
+
+// device_offline — references the device(s) that went quiet, no AQI level.
+const deviceOfflineSchema = new mongoose.Schema({
+  monitors: [{ type: mongoose.Types.ObjectId, ref: "Monitors" }],
+});
+
+const DeviceOfflineNotification = UserNotification.discriminator(
+  "device_offline",
+  deviceOfflineSchema,
+);
+
+// weekly_digest — the period the digest covers; no per-monitor payload.
+const weeklyDigestSchema = new mongoose.Schema({
+  periodStart: Date,
+  periodEnd: Date,
+});
+
+const WeeklyDigestNotification = UserNotification.discriminator(
+  "weekly_digest",
+  weeklyDigestSchema,
+);
+
+// account — no payload beyond the shared base + message.
+const AccountNotification = UserNotification.discriminator(
+  "account",
+  new mongoose.Schema({}),
+);
+
+export {
+  baseSchema as userNotificationsSchema,
+  UserNotification,
+  AqiAlertNotification,
+  DeviceOfflineNotification,
+  WeeklyDigestNotification,
+  AccountNotification,
+};
+export {
+  NOTIFICATION_KINDS,
+  NOTIFICATION_CHANNELS,
+  DELIVERY_STATUSES,
+} from "../constants/userNotifications.js";