@justair/justair-library 7.3.0-alpha.756c1bd → 7.3.0-alpha.80c577a

package/dist/constants/dataDownloads.d.ts

@@ -0,0 +1,2 @@
+export const DATA_DOWNLOAD_TYPES: string[];
+//# sourceMappingURL=dataDownloads.d.ts.map

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

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

package/dist/constants/index.d.ts

@@ -2,4 +2,5 @@ export * from "./pollutants.js";
 export * from "./alertLevels.js";
 export * from "./userNotifications.js";
 export * from "./timezones.js";
+export * from "./dataDownloads.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts

@@ -86,12 +86,18 @@ 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 { DATA_DOWNLOAD_TYPES } from "./constants/dataDownloads.js";
 import { dataDownloadSchema } from "./models/dataDownloads.js";
 import { DataDownloads } from "./models/dataDownloads.js";
 import { AqiDataDownload } from "./models/dataDownloads.js";
 import { SampleDataDownload } from "./models/dataDownloads.js";
 import { MAX_RANGE_DAYS as DATA_DOWNLOAD_MAX_RANGE_DAYS } from "./utils/dataDownloadValidation.js";
 import { DATA_DOWNLOAD_ERRORS } from "./utils/dataDownloadValidation.js";
+import { validateDateOrder as validateDataDownloadDateOrder } from "./utils/dataDownloadValidation.js";
+import { validateMaxDateRange as validateDataDownloadMaxDateRange } from "./utils/dataDownloadValidation.js";
+import { validateDownloadEmail as validateDataDownloadEmail } from "./utils/dataDownloadValidation.js";
+import { normalizeDownloadEmail as normalizeDataDownloadEmail } from "./utils/dataDownloadValidation.js";
+import { validateDownloadTimezone as validateDataDownloadTimezone } from "./utils/dataDownloadValidation.js";
 import { PARAMETERS } from "./constants/pollutants.js";
 import { HEAVY_METALS } from "./constants/pollutants.js";
 import { ALERT_LEVEL_WEIGHTS } from "./constants/alertLevels.js";
@@ -106,5 +112,5 @@ import { validateQuietHours } from "./utils/quietHours.js";
 import { getZoneMinutes } from "./utils/quietHours.js";
 import { isInQuietWindow } from "./utils/quietHours.js";
 import { resolveQuietHours } from "./utils/quietHours.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, monitorEpisodesSchema, MonitorEpisode, userNotificationsSchema, UserNotification, AqiAlertNotification, DeviceOfflineNotification, WeeklyDigestNotification, AccountNotification, NOTIFICATION_KINDS, NOTIFICATION_CHANNELS, DELIVERY_STATUSES, dataDownloadSchema, DataDownloads, AqiDataDownload, SampleDataDownload, DATA_DOWNLOAD_MAX_RANGE_DAYS, DATA_DOWNLOAD_ERRORS, PARAMETERS, HEAVY_METALS, ALERT_LEVEL_WEIGHTS, getAlertWeight, splitName, DEFAULT_QUIET_HOURS, DEFAULT_TIMEZONE, QUIET_HOURS_ERRORS, isValidTimeString, isValidIANATimezone, validateQuietHours, getZoneMinutes, isInQuietWindow, resolveQuietHours };
+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, DATA_DOWNLOAD_TYPES, dataDownloadSchema, DataDownloads, AqiDataDownload, SampleDataDownload, DATA_DOWNLOAD_MAX_RANGE_DAYS, DATA_DOWNLOAD_ERRORS, validateDataDownloadDateOrder, validateDataDownloadMaxDateRange, validateDataDownloadEmail, normalizeDataDownloadEmail, validateDataDownloadTimezone, PARAMETERS, HEAVY_METALS, ALERT_LEVEL_WEIGHTS, getAlertWeight, splitName, DEFAULT_QUIET_HOURS, DEFAULT_TIMEZONE, QUIET_HOURS_ERRORS, isValidTimeString, isValidIANATimezone, validateQuietHours, getZoneMinutes, isInQuietWindow, resolveQuietHours };
 //# 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":"AAoIA;;;iBAEC;yBApEwB,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;4BAkCT,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;sCA5CtF,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;mCAuC/B,2BAA2B;8BAA3B,2BAA2B;gCAA3B,2BAA2B;mCAA3B,2BAA2B;+DAO3B,mCAAmC;qCAAnC,mCAAmC;2BA/DD,2BAA2B;6BAA3B,2BAA2B;oCAChB,4BAA4B;+BAA5B,4BAA4B;0BAiBtD,sBAAsB;oCASzC,uBAAuB;iCAzBG,0BAA0B;mCAyBpD,uBAAuB;kCAAvB,uBAAuB;oCACM,qBAAqB;mCADlD,uBAAuB;+BAAvB,uBAAuB;gCAAvB,uBAAuB;kCAAvB,uBAAuB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAmJA;;;iBAEC;yBAnFwB,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;4BAmCT,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;sCA5CtF,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;oCAfF,8BAA8B;mCAsD3D,2BAA2B;8BAA3B,2BAA2B;gCAA3B,2BAA2B;mCAA3B,2BAA2B;+DAqB3B,mCAAmC;qCAAnC,mCAAmC;mEAAnC,mCAAmC;yEAAnC,mCAAmC;mEAAnC,mCAAmC;qEAAnC,mCAAmC;yEAAnC,mCAAmC;2BA9ED,2BAA2B;6BAA3B,2BAA2B;oCAChB,4BAA4B;+BAA5B,4BAA4B;0BAkBtD,sBAAsB;oCASzC,uBAAuB;iCA1BG,0BAA0B;mCA0BpD,uBAAuB;kCAAvB,uBAAuB;oCACM,qBAAqB;mCADlD,uBAAuB;+BAAvB,uBAAuB;gCAAvB,uBAAuB;kCAAvB,uBAAuB"}

package/dist/models/dataDownloads.d.ts

@@ -1,5 +1,261 @@
-export const dataDownloadSchema: any;
-export const DataDownloads: any;
-export const AqiDataDownload: any;
-export const SampleDataDownload: any;
+export const dataDownloadSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+    discriminatorKey: string;
+}, {
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps, mongoose.Document<unknown, {}, {
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps, {
+    id: string;
+}, Omit<mongoose.DefaultSchemaOptions, "timestamps" | "discriminatorKey"> & {
+    timestamps: true;
+    discriminatorKey: string;
+}> & Omit<{
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & mongoose.HydratedDocumentOverrides<{
+    id: string;
+}>, unknown, {
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export const DataDownloads: mongoose.Model<{
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps, {}, {}, {
+    id: string;
+}, mongoose.Document<unknown, {}, {
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps, {
+    id: string;
+}, {
+    timestamps: true;
+    discriminatorKey: string;
+}> & Omit<{
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & mongoose.HydratedDocumentOverrides<{
+    id: string;
+}>, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+    discriminatorKey: string;
+}, {
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps, mongoose.Document<unknown, {}, {
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps, {
+    id: string;
+}, Omit<mongoose.DefaultSchemaOptions, "timestamps" | "discriminatorKey"> & {
+    timestamps: true;
+    discriminatorKey: string;
+}> & Omit<{
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & mongoose.HydratedDocumentOverrides<{
+    id: string;
+}>, unknown, {
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>, {
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export const AqiDataDownload: mongoose.Model<{
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps & {
+    monitorId: mongoose.Types.ObjectId;
+}, {}, {}, {
+    id: string;
+}, mongoose.Document<unknown, {}, {
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps & {
+    monitorId: mongoose.Types.ObjectId;
+}, {
+    id: string;
+}, mongoose.DefaultSchemaOptions> & Omit<{
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps & {
+    monitorId: mongoose.Types.ObjectId;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & mongoose.HydratedDocumentOverrides<{
+    id: string;
+}>, any, {
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps & {
+    monitorId: mongoose.Types.ObjectId;
+}>;
+export const SampleDataDownload: mongoose.Model<{
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps & {
+    siteId: mongoose.Types.ObjectId;
+}, {}, {}, {
+    id: string;
+}, mongoose.Document<unknown, {}, {
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps & {
+    siteId: mongoose.Types.ObjectId;
+}, {
+    id: string;
+}, mongoose.DefaultSchemaOptions> & Omit<{
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps & {
+    siteId: mongoose.Types.ObjectId;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & mongoose.HydratedDocumentOverrides<{
+    id: string;
+}>, any, {
+    timezone: string;
+    orgId: mongoose.Types.ObjectId;
+    dateRangeStart: NativeDate;
+    dateRangeEnd: NativeDate;
+    downloadedAt: NativeDate;
+    email?: string;
+    agreementAcceptedAt?: NativeDate;
+} & mongoose.DefaultTimestampProps & {
+    siteId: mongoose.Types.ObjectId;
+}>;
+import mongoose from "mongoose";
 //# sourceMappingURL=dataDownloads.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dataDownloads.d.ts","sourceRoot":"","sources":["../../src/models/dataDownloads.js"],"names":[],"mappings":"AAsBA,qCAwDE;AAqDF,gCAA0E;AAM1E,kCAEG;AAEH,qCAIE"}
+{"version":3,"file":"dataDownloads.d.ts","sourceRoot":"","sources":["../../src/models/dataDownloads.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DE;AA2DF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0E;AAY1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAIE;qBArKmB,UAAU"}

package/dist/utils/dataDownloadValidation.d.ts

@@ -18,4 +18,8 @@ export function validateDownloadEmail({ email }?: {}): {
     code: "invalid_email";
     message: string;
 }[];
+export function validateDownloadTimezone({ timezone }?: {}): {
+    code: "invalid_timezone";
+    message: string;
+}[];
 //# sourceMappingURL=dataDownloadValidation.d.ts.map

package/dist/utils/dataDownloadValidation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataDownloadValidation.d.ts","sourceRoot":"","sources":["../../src/utils/dataDownloadValidation.js"],"names":[],"mappings":"AAUA,gCAAiC;AAUjC;;;;;GAKG;AAmBI;;;IAcN;AAIM;;;IAcN;AAMM,wDAC0D;AAI1D;;;IAUN"}
+{"version":3,"file":"dataDownloadValidation.d.ts","sourceRoot":"","sources":["../../src/utils/dataDownloadValidation.js"],"names":[],"mappings":"AAWA,gCAAiC;AAUjC;;;;;GAKG;AAmBI;;;IAcN;AAIM;;;IAcN;AAgBM,wDAMN;AAIM;;;IAqBN;AAQM;;;IAaN"}

package/dist/utils/timezone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timezone.d.ts","sourceRoot":"","sources":["../../src/utils/timezone.js"],"names":[],"mappings":"AAaO,iDAYN;AAEM,4DAUN"}
+{"version":3,"file":"timezone.d.ts","sourceRoot":"","sources":["../../src/utils/timezone.js"],"names":[],"mappings":"AAoBO,iDAaN;AAEM,4DAUN"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justair/justair-library",
-  "version": "7.3.0-alpha.756c1bd",
+  "version": "7.3.0-alpha.80c577a",
   "description": "JustAir Internal Library",
   "main": "src/index.js",
   "type": "module",

package/src/constants/dataDownloads.js

@@ -0,0 +1,16 @@
+// DataDownloads vocabulary — source of truth for the `dataType` discriminator
+// values (JA-3080/JA-3245). Kept here (Mongoose-free) so JustAirService and
+// JustAir-Client can import the list without pulling in the models: the client
+// drives the download modal's data-type picker from it, and the service
+// branches on them when building the export.
+//
+// These are persisted values, NOT display labels. Figma labels the second
+// option "Sample Data" while the stored value is "Sample", so a consumer that
+// renders the array directly shows the wrong copy. Labels belong to the
+// consumer; this library has no i18n and no view layer to own them.
+//
+// Order is the order the picker shows. JA-3080 notes concentration is coming
+// as a third type — add it here and register its discriminator in
+// models/dataDownloads.js, so no consumer has to hardcode the string.
+
+export const DATA_DOWNLOAD_TYPES = ["AQI", "Sample"];

package/src/constants/index.js

@@ -11,3 +11,4 @@ export * from "./pollutants.js";
 export * from "./alertLevels.js";
 export * from "./userNotifications.js";
 export * from "./timezones.js";
+export * from "./dataDownloads.js";

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

@@ -7,6 +7,7 @@ import * as barrel from '../index.js';
 import { PARAMETERS, HEAVY_METALS } from '../pollutants.js';
 import { ALERT_LEVEL_WEIGHTS, getAlertWeight } from '../alertLevels.js';
 import { DEFAULT_TIMEZONE } from '../timezones.js';
+import { DATA_DOWNLOAD_TYPES } from '../dataDownloads.js';
 
 test('barrel re-exports PARAMETERS and HEAVY_METALS unchanged (identity, not copies)', () => {
   expect(barrel.PARAMETERS).toBe(PARAMETERS);
@@ -50,3 +51,14 @@ test('barrel exports DEFAULT_TIMEZONE (browser-safe, no Mongoose)', () => {
   expect(barrel.DEFAULT_TIMEZONE).toBe(DEFAULT_TIMEZONE);
   expect(DEFAULT_TIMEZONE).toBe('America/New_York');
 });
+
+test('barrel exports DATA_DOWNLOAD_TYPES (browser-safe, no Mongoose)', () => {
+  expect(barrel.DATA_DOWNLOAD_TYPES).toBe(DATA_DOWNLOAD_TYPES);
+});
+
+// models/dataDownloads.js destructures this list positionally to build the two
+// discriminators, so a reorder would silently swap the persisted dataType
+// values on every future download. Pin contents AND order.
+test('DATA_DOWNLOAD_TYPES pins the persisted dataType values in order', () => {
+  expect(DATA_DOWNLOAD_TYPES).toEqual(['AQI', 'Sample']);
+});

package/src/index.js

@@ -68,6 +68,7 @@ import CustomLogger from "./config/logger.js";
 import { PARAMETERS, HEAVY_METALS } from "./constants/pollutants.js";
 import { ALERT_LEVEL_WEIGHTS, getAlertWeight } from "./constants/alertLevels.js";
 import { DEFAULT_TIMEZONE } from "./constants/timezones.js";
+import { DATA_DOWNLOAD_TYPES } from "./constants/dataDownloads.js";
 import {
   monitorEpisodesSchema,
   MonitorEpisode,
@@ -128,6 +129,20 @@ import {
   // data downloads. Module-internal name is unchanged.
   MAX_RANGE_DAYS as DATA_DOWNLOAD_MAX_RANGE_DAYS,
   DATA_DOWNLOAD_ERRORS,
+  // The rule ships with the number. The enforced bound is
+  // MAX_RANGE_DAYS plus a 1-hour DST grace, so a consumer rebuilding the cap
+  // as `DATA_DOWNLOAD_MAX_RANGE_DAYS * 86400000` builds a stricter limit than
+  // the model and rejects a 745-hour range the schema saves. Same reason
+  // validateQuietHours is exported rather than just DEFAULT_QUIET_HOURS.
+  //
+  // DateOrder applies to every download kind; MaxDateRange applies to AQI
+  // only, since Sample downloads have no length cap. Running both against a
+  // Sample request rejects year-long ranges the model saves without complaint.
+  validateDateOrder as validateDataDownloadDateOrder,
+  validateMaxDateRange as validateDataDownloadMaxDateRange,
+  validateDownloadEmail as validateDataDownloadEmail,
+  normalizeDownloadEmail as normalizeDataDownloadEmail,
+  validateDownloadTimezone as validateDataDownloadTimezone,
 } from "./utils/dataDownloadValidation.js";
 
 export function createLoggerInstance({ DATADOG_API_KEY, APPLICATION_NAME }) {
@@ -224,12 +239,18 @@ export {
   NOTIFICATION_CHANNELS,
   DELIVERY_STATUSES,
   // Data downloads (JA-3080)
+  DATA_DOWNLOAD_TYPES,
   dataDownloadSchema,
   DataDownloads,
   AqiDataDownload,
   SampleDataDownload,
   DATA_DOWNLOAD_MAX_RANGE_DAYS,
   DATA_DOWNLOAD_ERRORS,
+  validateDataDownloadDateOrder,
+  validateDataDownloadMaxDateRange,
+  validateDataDownloadEmail,
+  normalizeDataDownloadEmail,
+  validateDataDownloadTimezone,
   // Pollutant constants
   PARAMETERS,
   HEAVY_METALS,

package/src/models/dataDownloads.js

@@ -1,12 +1,13 @@
 import mongoose from "mongoose";
+import { DATA_DOWNLOAD_TYPES } from "../constants/dataDownloads.js";
 import { DEFAULT_TIMEZONE } from "../constants/timezones.js";
-import { isValidIANATimezone } from "../utils/timezone.js";
 import {
   DATA_DOWNLOAD_ERRORS,
   validateDateOrder,
   validateMaxDateRange,
   validateDownloadEmail,
   normalizeDownloadEmail,
+  validateDownloadTimezone,
 } from "../utils/dataDownloadValidation.js";
 
 // DataDownloads — one doc per data download request (JA-3080). Written by
@@ -20,7 +21,7 @@ import {
 // — same property `userNotifications.js`'s base model has. Write through
 // AqiDataDownload/SampleDataDownload, not DataDownloads, so every stored
 // document has the ref field the admin screen needs to render it.
-const dataDownloadSchema = mongoose.Schema(
+const dataDownloadSchema = new mongoose.Schema(
   {
     orgId: {
       type: mongoose.Types.ObjectId,
@@ -39,18 +40,19 @@ const dataDownloadSchema = mongoose.Schema(
     // Readers feeding this to Intl.DateTimeFormat must still defend.
     timezone: {
       type: String,
+      trim: true,
       default: DEFAULT_TIMEZONE,
       set: (value) => (value === null ? DEFAULT_TIMEZONE : value),
       validate: {
-        validator: isValidIANATimezone,
+        validator: (value) => validateDownloadTimezone({ timezone: value }).length === 0,
         message: "timezone must be a valid IANA timezone identifier",
         type: DATA_DOWNLOAD_ERRORS.INVALID_TIMEZONE,
       },
     },
-    downloadedAt: { type: Date, required: true, default: Date.now },
+    downloadedAt: { type: Date, required: [true, "downloadedAt is required"], default: Date.now },
     // Figma's download modal requires checking "I have reviewed and agree to
-    // the Data Sharing Agreement" before the download proceeds (JA-3245 round
-    // 5, S5). Stored as the acceptance timestamp rather than a boolean so the
+    // the Data Sharing Agreement" before the download proceeds (JA-3245).
+    // Stored as the acceptance timestamp rather than a boolean so the
     // record answers "when did they agree", which is what an audit trail of a
     // consent decision needs. null means no acceptance was recorded — neither
     // JA-3245 nor JA-3080 lists this field, so it stays optional until the
@@ -67,7 +69,13 @@ const dataDownloadSchema = mongoose.Schema(
       set: normalizeDownloadEmail,
       validate: {
         validator: (value) => validateDownloadEmail({ email: value }).length === 0,
-        message: "email must be a valid email address",
+        // Resolved from the rule rather than a static string: validateDownloadEmail
+        // distinguishes "too long" from "malformed", and a static message threw
+        // that away, so a 300-character address came back as "invalid" with no
+        // hint of the real problem.
+        message: (props) =>
+          validateDownloadEmail({ email: props.value })[0]?.message ??
+          "email must be a valid email address",
         type: DATA_DOWNLOAD_ERRORS.INVALID_EMAIL,
       },
     },
@@ -85,6 +93,12 @@ const dataDownloadSchema = mongoose.Schema(
 //
 // Passes the error code as invalidate()'s `kind` so a caught ValidationError
 // can be classified via err.errors.<path>.kind, not by message wording.
+//
+// Same caveat the `timezone` field carries: pre('validate') never runs on a
+// query update, so a `$set` of dateRangeStart/dateRangeEnd can persist a
+// reversed or over-length range even with { runValidators: true }. Deliberate
+// — the rules are cross-field, and query updates have no full document to
+// check. Writers should go through create()/save(); readers must still defend.
 dataDownloadSchema.pre("validate", function () {
   const rangeErrors = validateDateOrder({ start: this.dateRangeStart, end: this.dateRangeEnd });
   for (const error of rangeErrors) {
@@ -131,18 +145,24 @@ sampleDataDownloadSchema.index({ siteId: 1, downloadedAt: -1 });
 
 const DataDownloads = mongoose.model("DataDownloads", dataDownloadSchema);
 
+// Derived from the constant per CLAUDE.md, so adding a type (JA-3080 expects
+// concentration next) is one edit in one file. Positional, and pinned by
+// constantsBarrel.test.js — reordering DATA_DOWNLOAD_TYPES fails that test
+// before it can silently swap the two persisted values.
+const [AQI_TYPE, SAMPLE_TYPE] = DATA_DOWNLOAD_TYPES;
+
 // Registry names are namespaced (matches userNotifications.js): bare "AQI" /
 // "Sample" model-registry keys would collide with a consuming service's own
 // models of those names. { value } keeps the persisted dataType as JA-3245
 // specifies regardless of the registry name.
 const AqiDataDownload = DataDownloads.discriminator("AqiDataDownload", aqiDataDownloadSchema, {
-  value: "AQI",
+  value: AQI_TYPE,
 });
 
 const SampleDataDownload = DataDownloads.discriminator(
   "SampleDataDownload",
   sampleDataDownloadSchema,
-  { value: "Sample" }
+  { value: SAMPLE_TYPE }
 );
 
 export { dataDownloadSchema, DataDownloads, AqiDataDownload, SampleDataDownload };

package/src/utils/dataDownloadValidation.js

@@ -1,10 +1,11 @@
 // Data download validation (JA-3080/JA-3245): the shared field and cross-field
 // rules for a DataDownloads document — date range order, the AQI-only length
-// cap, and the optional email. Pure functions, no DB, no clock reads. Same
-// shape as quietHours.js's cross-field validator.
+// cap, the optional email, and the timezone. Pure functions, no DB, no clock
+// reads. Same shape as quietHours.js's cross-field validator.
 //
 // Two separate rules, deliberately not one function: end-must-not-precede-
 // start applies to every download kind, but the 31-day cap is AQI-only.
+import { isValidIANATimezone } from "./timezone.js";
 
 // Messaging only ("range cannot exceed 31 days"). validateMaxDateRange is the
 // sole authority on the enforced bound; don't rebuild the cap from this.
@@ -78,15 +79,41 @@ export const validateMaxDateRange = ({ start, end } = {}) => {
 
 const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 
+// RFC 5321's maximum forward-path length. Enforced here rather than as a
+// schema `maxlength` so the exported rule and the model agree: a schema-only
+// cap let validateDownloadEmail pass a 300-character address that create()
+// then rejected with kind "maxlength", which isn't a DATA_DOWNLOAD_ERRORS
+// code.
+const MAX_EMAIL_LENGTH = 254;
+
 // Email is optional (JA-3080): a blank form field means "not sharing my email",
-// not "invalid email", so a blank string collapses to null.
-export const normalizeDownloadEmail = (value) =>
-  typeof value === "string" && value.trim() === "" ? null : value;
+// not "invalid email", so a blank string collapses to null. Trims and
+// lowercases to match the schema's `trim`/`lowercase` setters — without that,
+// a consumer normalizing then validating "  A@B.co  " gets INVALID_EMAIL for
+// input the model would have stored.
+export const normalizeDownloadEmail = (value) => {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === "" ? null : normalized;
+};
 
 // Returns { code, message }[]; empty = valid. null/undefined is valid — call
 // normalizeDownloadEmail first so a blank string arrives as null.
 export const validateDownloadEmail = ({ email } = {}) => {
-  if (email === null || email === undefined || EMAIL_PATTERN.test(email)) {
+  if (email === null || email === undefined) {
+    return [];
+  }
+  if (typeof email === "string" && email.length > MAX_EMAIL_LENGTH) {
+    return [
+      {
+        code: DATA_DOWNLOAD_ERRORS.INVALID_EMAIL,
+        message: `email must be ${MAX_EMAIL_LENGTH} characters or fewer`,
+      },
+    ];
+  }
+  if (EMAIL_PATTERN.test(email)) {
     return [];
   }
   return [
@@ -96,3 +123,24 @@ export const validateDownloadEmail = ({ email } = {}) => {
     },
   ];
 };
+
+// Returns { code, message }[]; empty = valid. null/undefined is valid: the
+// schema's setter resolves either to DEFAULT_TIMEZONE, so a consumer
+// pre-validating a request body must accept the same "didn't pick one" shape
+// the model stores. isValidIANATimezone alone rejects null, which would fail
+// a request the model saves happily — the write-path/read-path split the
+// email rules exist to avoid.
+export const validateDownloadTimezone = ({ timezone } = {}) => {
+  if (timezone === null || timezone === undefined) {
+    return [];
+  }
+  if (isValidIANATimezone(timezone)) {
+    return [];
+  }
+  return [
+    {
+      code: DATA_DOWNLOAD_ERRORS.INVALID_TIMEZONE,
+      message: "timezone must be a valid IANA timezone identifier",
+    },
+  ];
+};

package/src/utils/tests/dataDownloadValidation.test.js

@@ -4,6 +4,7 @@ import {
   validateDateOrder,
   validateMaxDateRange,
   validateDownloadEmail,
+  validateDownloadTimezone,
   normalizeDownloadEmail,
 } from "../dataDownloadValidation.js";
 
@@ -100,6 +101,15 @@ describe("normalizeDownloadEmail (blank means 'not shared', not invalid)", () =>
     expect(normalizeDownloadEmail("someone@example.com")).toBe("someone@example.com");
   });
 
+  // Matches the schema's trim/lowercase setters. Without this the exported
+  // pair rejects padded input that AqiDataDownload.create() stores fine.
+  test("trims and lowercases so it agrees with the schema setters", () => {
+    expect(normalizeDownloadEmail("  Someone@Example.com  ")).toBe("someone@example.com");
+    expect(validateDownloadEmail({ email: normalizeDownloadEmail("  Someone@Example.com  ") })).toEqual(
+      []
+    );
+  });
+
   test("passes through non-string values unchanged — not this function's job to type-check", () => {
     expect(normalizeDownloadEmail(null)).toBeNull();
     expect(normalizeDownloadEmail(undefined)).toBeUndefined();
@@ -107,6 +117,21 @@ describe("normalizeDownloadEmail (blank means 'not shared', not invalid)", () =>
 });
 
 describe("validateDownloadEmail (email is optional — JA-3080)", () => {
+  // The 254-character bound is enforced here, not as a schema maxlength,
+  // so the exported rule and the model can't disagree on the same address.
+  test("flags an address longer than 254 characters", () => {
+    const tooLong = `${"a".repeat(250)}@b.co`;
+    expect(validateDownloadEmail({ email: tooLong })).toEqual([
+      { code: DATA_DOWNLOAD_ERRORS.INVALID_EMAIL, message: "email must be 254 characters or fewer" },
+    ]);
+  });
+
+  test("accepts an address at exactly 254 characters", () => {
+    const atBound = `${"a".repeat(249)}@b.co`;
+    expect(atBound.length).toBe(254);
+    expect(validateDownloadEmail({ email: atBound })).toEqual([]);
+  });
+
   test("returns no errors when email is null or undefined", () => {
     expect(validateDownloadEmail({})).toEqual([]);
     expect(validateDownloadEmail({ email: null })).toEqual([]);
@@ -131,3 +156,31 @@ describe("validateDownloadEmail (email is optional — JA-3080)", () => {
     ]);
   });
 });
+
+describe("validateDownloadTimezone", () => {
+  test.each(["America/New_York", "America/Detroit", "UTC", "Asia/Tokyo"])(
+    "accepts %s",
+    (timezone) => {
+      expect(validateDownloadTimezone({ timezone })).toEqual([]);
+    }
+  );
+
+  // The schema setter resolves both to DEFAULT_TIMEZONE, so a consumer
+  // pre-validating a request body must accept what the model stores.
+  test.each([null, undefined])("treats %p as valid (the setter fills the default)", (timezone) => {
+    expect(validateDownloadTimezone({ timezone })).toEqual([]);
+  });
+
+  test("accepts a call with no argument at all", () => {
+    expect(validateDownloadTimezone()).toEqual([]);
+  });
+
+  test.each(["America/Fake_City", "Not/A_Zone", "   ", 5, {}])(
+    "flags %p with INVALID_TIMEZONE",
+    (timezone) => {
+      expect(validateDownloadTimezone({ timezone })).toEqual([
+        expect.objectContaining({ code: DATA_DOWNLOAD_ERRORS.INVALID_TIMEZONE }),
+      ]);
+    }
+  );
+});

package/src/utils/tests/timezone.test.js

@@ -39,6 +39,20 @@ describe('getFormatter', () => {
     expect(getFormatter('America/New_York')).toBe(getFormatter('America/New_York'));
   });
 
+  test('shares one cached formatter across casing variants of the same zone', () => {
+    // Intl accepts any casing, so a raw-string cache key would grow one
+    // permanent entry per spelling of a client-supplied zone (JA-3081).
+    const canonical = getFormatter('America/New_York');
+    expect(getFormatter('america/new_york')).toBe(canonical);
+    expect(getFormatter('AMERICA/NEW_YORK')).toBe(canonical);
+  });
+
+  test('a cached lowercase key still formats in the right zone', () => {
+    const parts = getFormatter('asia/tokyo').formatToParts(new Date('2026-01-01T00:00:00.000Z'));
+    const hour = parts.find((p) => p.type === 'hour').value;
+    expect(hour).toBe('09');
+  });
+
   test('throws for an invalid timezone — isValidIANATimezone exists to guard this', () => {
     expect(() => getFormatter('Not/A_Zone')).toThrow();
   });

package/src/utils/timezone.js

@@ -9,10 +9,18 @@
 // on a cached formatter is cheap. The cache also makes validation and
 // zone-minute lookups (quietHours.js's getZoneMinutes) share one authority:
 // a timezone is valid iff Intl accepts it.
+//
+// Keyed lowercase because Intl treats IANA names case-insensitively:
+// "America/New_York", "america/new_york" and "AMERICA/NEW_YORK" all resolve to
+// the same zone, so keying on the raw string would cache a separate permanent
+// formatter per casing variant. dataDownloads.js validates a per-request
+// `timezone`, so that string can come from a client (JA-3081) — one entry per
+// real zone rather than per spelling keeps the map bounded.
 const formatterCache = new Map();
 
 export const getFormatter = (timeZone) => {
-  let formatter = formatterCache.get(timeZone);
+  const cacheKey = typeof timeZone === "string" ? timeZone.toLowerCase() : timeZone;
+  let formatter = formatterCache.get(cacheKey);
   if (formatter === undefined) {
     formatter = new Intl.DateTimeFormat("en-US", {
       timeZone,
@@ -20,7 +28,7 @@ export const getFormatter = (timeZone) => {
       hour: "2-digit",
       minute: "2-digit",
     });
-    formatterCache.set(timeZone, formatter);
+    formatterCache.set(cacheKey, formatter);
   }
   return formatter;
 };