@justair/justair-library 6.11.0 → 6.12.0-alpha.25e595a

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,3 @@
+export * from "./pollutants.js";
+export * from "./alertLevels.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/index.d.ts

@@ -75,8 +75,15 @@ 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 { NOTIFICATION_KINDS } 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, NOTIFICATION_KINDS, 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":"AAsGA;;;iBAEC;yBAtCwB,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;4BAiBT,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;sCA5BtF,6BAA6B;+BAA7B,6BAA6B;wCAK7B,+BAA+B;iCAA/B,+BAA+B;mCAA/B,+BAA+B;2BAVG,2BAA2B;6BAA3B,2BAA2B;oCAChB,4BAA4B;+BAA5B,4BAA4B;0BAUtD,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,iCA4IE;AAuIF,2BAA4D;AA1T5D,qCAiCE;AAGF,+BAAwE;AAtKxE,sCAAoD"}
+{"version":3,"file":"monitors.d.ts","sourceRoot":"","sources":["../../src/models/monitors.js"],"names":[],"mappings":"AA4KA,iCAkJE;AAuIF,2BAA4D;AAhU5D,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,330 @@
+export const userNotificationsSchema: 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?: {};
+    };
+    kind: string;
+    monitors: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    episodes: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    sentAt: Date;
+    message?: string;
+    status?: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    kind: string;
+    monitors: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    episodes: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    sentAt: Date;
+    message?: string;
+    status?: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    kind: string;
+    monitors: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    episodes: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    sentAt: Date;
+    message?: string;
+    status?: 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?: {};
+    };
+    kind: string;
+    monitors: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    episodes: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    sentAt: Date;
+    message?: string;
+    status?: string;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    kind: string;
+    monitors: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    episodes: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    sentAt: Date;
+    message?: string;
+    status?: string;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    kind: string;
+    monitors: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    episodes: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    sentAt: Date;
+    message?: string;
+    status?: 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?: {};
+    };
+    kind: string;
+    monitors: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    episodes: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    sentAt: Date;
+    message?: string;
+    status?: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    kind: string;
+    monitors: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    episodes: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    sentAt: Date;
+    message?: string;
+    status?: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    user: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    kind: string;
+    monitors: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    episodes: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    }[];
+    sentAt: Date;
+    message?: string;
+    status?: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>>;
+export const NOTIFICATION_KINDS: string[];
+import mongoose from "mongoose";
+//# 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":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAeE;AAWF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGE;AAjCF,0CAAoD;qBAf/B,UAAU"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justair/justair-library",
-  "version": "6.11.0",
+  "version": "6.12.0-alpha.25e595a",
   "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,11 @@
+// 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";

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/index.js

@@ -66,6 +66,16 @@ 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,
+  NOTIFICATION_KINDS,
+} from "./models/userNotifications.js";
 import { splitName } from "./utils/splitName.js";
 
 // Sites related imports
@@ -171,9 +181,18 @@ export {
   // Password reset tokens (JA-2946)
   passwordResetTokenSchema,
   PasswordResetToken,
+  // Notification episodes + send log (JA-2658 / JA-2691 stack)
+  monitorEpisodesSchema,
+  MonitorEpisode,
+  userNotificationsSchema,
+  UserNotification,
+  NOTIFICATION_KINDS,
   // 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

@@ -198,6 +198,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,51 @@
+import mongoose from "mongoose";
+import { ALERT_LEVEL_WEIGHTS } from "../constants/alertLevels.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.
+//
+// Semantics (locked in the 2026-07-07 eng review):
+// - One alert EVENT (the per-user threshold gate firing) produces one row PER
+//   channel actually sent (kind aqi-sms / aqi-email). Episode alertCount is
+//   incremented once per EVENT — reconcile counts against events, not rows.
+// - `monitors` lists exactly the monitors named in the message
+//   (monitorsAtHighestStatus), and `episodes` the matching MonitorEpisode
+//   _ids — a row is 1:1 reconcilable with the SMS/email content.
+
+const NOTIFICATION_KINDS = ["aqi-sms", "aqi-email"];
+
+const alertLevelsEnum = [...Object.keys(ALERT_LEVEL_WEIGHTS)];
+
+const userNotificationsSchema = new mongoose.Schema(
+  {
+    user: {
+      type: mongoose.Types.ObjectId,
+      ref: "Users",
+      required: true,
+    },
+    kind: { type: String, enum: NOTIFICATION_KINDS, required: true },
+    monitors: [{ type: mongoose.Types.ObjectId, ref: "Monitors" }],
+    episodes: [{ type: mongoose.Types.ObjectId, ref: "MonitorEpisode" }],
+    status: { type: String, enum: alertLevelsEnum },
+    message: String,
+    sentAt: { type: Date, default: Date.now, required: true },
+  },
+  { timestamps: true },
+);
+
+// Per-user history, newest first.
+userNotificationsSchema.index({ user: 1, sentAt: -1 });
+
+// Device-scoped history for one user (multikey on monitors).
+userNotificationsSchema.index({ user: 1, monitors: 1, sentAt: -1 });
+
+// Retention: rows expire ~24 months after send.
+userNotificationsSchema.index({ sentAt: 1 }, { expireAfterSeconds: 63113904 });
+
+const UserNotification = mongoose.model(
+  "UserNotification",
+  userNotificationsSchema,
+);
+
+export { userNotificationsSchema, UserNotification, NOTIFICATION_KINDS };