@justair/justair-library 6.9.0 → 6.10.0-alpha.b5e7ec1

package/dist/index.d.ts

@@ -70,8 +70,10 @@ import { Samples } from "./models/samples.js";
 import { samplesAuditSchema } from "./models/samples.js";
 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 { PARAMETERS } from "./constants/pollutants.js";
 import { HEAVY_METALS } from "./constants/pollutants.js";
 import { splitName } from "./utils/splitName.js";
-export { Database, adminSchema, Admin, configurationsSchema, Configurations, measurementsSchema, Measurements, monitorRequestsSchema, MonitorRequests, monitorsSchema, Monitors, organizationsSchema, Organizations, usersSchema, Users, 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, PARAMETERS, HEAVY_METALS, splitName };
+export { Database, adminSchema, Admin, configurationsSchema, Configurations, measurementsSchema, Measurements, monitorRequestsSchema, MonitorRequests, monitorsSchema, Monitors, organizationsSchema, Organizations, usersSchema, Users, 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 };
 //# 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":"AAqFA;;;iBAEC;yBA3BwB,oBAAoB;qBADxB,gBAAgB;4BA3DF,mBAAmB;sBAAnB,mBAAmB;qCAI/C,4BAA4B;+BAA5B,4BAA4B;mCAM5B,0BAA0B;6BAA1B,0BAA0B;sCAI1B,6BAA6B;gCAA7B,6BAA6B;+BAQ7B,sBAAsB;yBAAtB,sBAAsB;oCACsB,2BAA2B;8BAA3B,2BAA2B;4BAQ3C,mBAAmB;sBAAnB,mBAAmB;6BAM/C,oBAAoB;uBAApB,oBAAoB;mCAbuB,2BAA2B;8BAA3B,2BAA2B;uCAItE,8BAA8B;iCAA9B,8BAA8B;+BACI,sBAAsB;yBAAtB,sBAAsB;iCAClB,wBAAwB;2BAAxB,wBAAwB;mCAQnB,2BAA2B;8BAA3B,2BAA2B;2BAC5C,kBAAkB;qBAAlB,kBAAkB;6BACd,oBAAoB;uBAApB,oBAAoB;6BACR,0BAA0B;mCAA1B,0BAA0B;sBA/BpE,0BAA0B;4BAA1B,0BAA0B;4BA2B1B,oBAAoB;kCAApB,oBAAoB;6BAfpB,sBAAsB;mCAAtB,sBAAsB;+BAAtB,sBAAsB;oCAAtB,sBAAsB;4BAyBtB,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;2BAtBa,2BAA2B;6BAA3B,2BAA2B;0BAC1C,sBAAsB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAsFA;;;iBAEC;yBA5BwB,oBAAoB;qBADxB,gBAAgB;4BA3DF,mBAAmB;sBAAnB,mBAAmB;qCAI/C,4BAA4B;+BAA5B,4BAA4B;mCAM5B,0BAA0B;6BAA1B,0BAA0B;sCAI1B,6BAA6B;gCAA7B,6BAA6B;+BAQ7B,sBAAsB;yBAAtB,sBAAsB;oCACsB,2BAA2B;8BAA3B,2BAA2B;4BAQ3C,mBAAmB;sBAAnB,mBAAmB;6BAM/C,oBAAoB;uBAApB,oBAAoB;mCAbuB,2BAA2B;8BAA3B,2BAA2B;uCAItE,8BAA8B;iCAA9B,8BAA8B;+BACI,sBAAsB;yBAAtB,sBAAsB;iCAClB,wBAAwB;2BAAxB,wBAAwB;mCAQnB,2BAA2B;8BAA3B,2BAA2B;2BAC5C,kBAAkB;qBAAlB,kBAAkB;6BACd,oBAAoB;uBAApB,oBAAoB;6BACR,0BAA0B;mCAA1B,0BAA0B;sBA/BpE,0BAA0B;4BAA1B,0BAA0B;4BA2B1B,oBAAoB;kCAApB,oBAAoB;6BAfpB,sBAAsB;mCAAtB,sBAAsB;+BAAtB,sBAAsB;oCAAtB,sBAAsB;4BAyBtB,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"}

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

@@ -1 +1 @@
-{"version":3,"file":"admin.d.ts","sourceRoot":"","sources":["../../src/models/admin.js"],"names":[],"mappings":"AAEA,8BAgBG;AAUH,wBAAmD"}
+{"version":3,"file":"admin.d.ts","sourceRoot":"","sources":["../../src/models/admin.js"],"names":[],"mappings":"AAEA,8BAsBG;AAcH,wBAAmD"}

package/dist/models/measurements.d.ts

@@ -6,10 +6,10 @@ export const annotationSchema: mongoose.Schema<any, mongoose.Model<any, any, any
     _id: true;
     timestamps: false;
 }, {
-    source: "admin" | "processing_engine";
-    timestamp: Date;
     comment: string;
     measurementIdentifier: string;
+    source: "admin" | "processing_engine";
+    timestamp: Date;
     adminId?: {
         prototype?: mongoose.Types.ObjectId;
         cacheHexString?: unknown;
@@ -20,10 +20,10 @@ export const annotationSchema: mongoose.Schema<any, mongoose.Model<any, any, any
         isValid?: {};
     };
 }, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
-    source: "admin" | "processing_engine";
-    timestamp: Date;
     comment: string;
     measurementIdentifier: string;
+    source: "admin" | "processing_engine";
+    timestamp: Date;
     adminId?: {
         prototype?: mongoose.Types.ObjectId;
         cacheHexString?: unknown;
@@ -34,10 +34,10 @@ export const annotationSchema: mongoose.Schema<any, mongoose.Model<any, any, any
         isValid?: {};
     };
 }>> & mongoose.FlatRecord<{
-    source: "admin" | "processing_engine";
-    timestamp: Date;
     comment: string;
     measurementIdentifier: string;
+    source: "admin" | "processing_engine";
+    timestamp: Date;
     adminId?: {
         prototype?: mongoose.Types.ObjectId;
         cacheHexString?: unknown;

package/dist/models/passwordResetToken.d.ts

@@ -0,0 +1,158 @@
+export const passwordResetTokenSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    adminId: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    tokenHash: string;
+    used: boolean;
+    expiresAt: Date;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    adminId: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    tokenHash: string;
+    used: boolean;
+    expiresAt: Date;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    adminId: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    tokenHash: string;
+    used: boolean;
+    expiresAt: Date;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+export const PasswordResetToken: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    adminId: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    tokenHash: string;
+    used: boolean;
+    expiresAt: Date;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    adminId: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    tokenHash: string;
+    used: boolean;
+    expiresAt: Date;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    adminId: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    tokenHash: string;
+    used: boolean;
+    expiresAt: Date;
+} & {
+    _id: mongoose.Types.ObjectId;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    adminId: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    tokenHash: string;
+    used: boolean;
+    expiresAt: Date;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    adminId: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    tokenHash: string;
+    used: boolean;
+    expiresAt: Date;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    adminId: {
+        prototype?: mongoose.Types.ObjectId;
+        cacheHexString?: unknown;
+        generate?: {};
+        createFromTime?: {};
+        createFromHexString?: {};
+        createFromBase64?: {};
+        isValid?: {};
+    };
+    tokenHash: string;
+    used: boolean;
+    expiresAt: Date;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>>;
+import mongoose from 'mongoose';
+//# sourceMappingURL=passwordResetToken.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"passwordResetToken.d.ts","sourceRoot":"","sources":["../../src/models/passwordResetToken.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQE;AAKF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA0F;qBA7BrE,UAAU"}

package/dist/modules/audit/actions.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Auth/compliance audit action enum (auth-contracts #4 — EXACT strings, frozen).
+ * Distinct domain from the measurement-lineage `Audit` model in
+ * models/measurements.js: this tracks WHO did WHAT to admin/auth state, for the
+ * government-compliance audit trail.
+ *
+ * Emit sites (in the services): login (success/failure), logout, forgot-password
+ * (requested/completed), silent refresh, and the admin mutation sites
+ * (create/update/delete, role.change when permissionName changes,
+ * deactivate/reactivate when isActive toggles).
+ */
+export const AUDIT_ACTIONS: Readonly<{
+    LOGIN_SUCCESS: "auth.login.success";
+    LOGIN_FAILURE: "auth.login.failure";
+    LOGOUT: "auth.logout";
+    PASSWORD_RESET_REQUESTED: "auth.password.reset.requested";
+    PASSWORD_RESET_COMPLETED: "auth.password.reset.completed";
+    TOKEN_REFRESH: "auth.token.refresh";
+    ADMIN_CREATE: "admin.create";
+    ADMIN_UPDATE: "admin.update";
+    ADMIN_DELETE: "admin.delete";
+    ADMIN_ROLE_CHANGE: "admin.role.change";
+    ADMIN_DEACTIVATE: "admin.deactivate";
+    ADMIN_REACTIVATE: "admin.reactivate";
+}>;
+/** Frozen list of all valid action strings — used as the AuditLog schema enum. */
+export const AUDIT_ACTION_VALUES: readonly ("auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate")[];
+//# sourceMappingURL=actions.d.ts.map

package/dist/modules/audit/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../src/modules/audit/actions.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH;;;;;;;;;;;;;GAaG;AAEH,kFAAkF;AAClF,yTAA+E"}

package/dist/modules/audit/auditLog.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Single canonical audit write path (auth-contracts #4).
+ *
+ *   writeAudit(entry) ──► AuditLog.create
+ *                           │ ok            │ throws (db down, validation)
+ *                           ▼               ▼
+ *                        return true   logger.error + return false  (NEVER throws)
+ *
+ * An audit hiccup must not fail the request it is recording (e.g. a login). The
+ * caller gets a boolean and decides; the failure is logged at error for compliance
+ * follow-up. Inject the consuming service's logger via deps.logger (DI); it falls
+ * back to a no-op rather than raw console so it honors the "no console" rule.
+ *
+ * @param {{action:string, actor?:object, resource?:object, outcome:string,
+ *          reason?:string, metadata?:object, requestId?:string}} entry
+ * @param {{ logger?: { error: Function } }} [deps]
+ * @returns {Promise<boolean>} true if persisted, false if the write failed
+ */
+export function writeAudit({ action, actor, resource, outcome, reason, metadata, requestId }?: {
+    action: string;
+    actor?: object;
+    resource?: object;
+    outcome: string;
+    reason?: string;
+    metadata?: object;
+    requestId?: string;
+}, { logger }?: {
+    logger?: {
+        error: Function;
+    };
+}): Promise<boolean>;
+//# sourceMappingURL=auditLog.d.ts.map

package/dist/modules/audit/auditLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auditLog.d.ts","sourceRoot":"","sources":["../../../src/modules/audit/auditLog.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,+FALW;IAAC,MAAM,EAAC,MAAM,CAAC;IAAC,KAAK,CAAC,EAAC,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAC,MAAM,CAAC;IAAC,OAAO,EAAC,MAAM,CAAC;IAC/D,MAAM,CAAC,EAAC,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAC,MAAM,CAAC;IAAC,SAAS,CAAC,EAAC,MAAM,CAAA;CAAC,eACrD;IAAE,MAAM,CAAC,EAAE;QAAE,KAAK,WAAU;KAAE,CAAA;CAAE,GAC9B,OAAO,CAAC,OAAO,CAAC,CAiB5B"}

package/dist/modules/audit/index.d.ts

@@ -0,0 +1,4 @@
+export { writeAudit } from "./auditLog.js";
+export { AUDIT_ACTIONS, AUDIT_ACTION_VALUES } from "./actions.js";
+export { AuditLog, auditLogSchema } from "./schema.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/audit/index.d.ts.map

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

package/dist/modules/audit/schema.d.ts

@@ -0,0 +1,321 @@
+/**
+ * AuditLog — auth/compliance audit trail (JA-2814, auth-contracts #4).
+ * One model definition; both services import it, neither redefines it. This is NOT
+ * the measurement-lineage `Audit` model (models/measurements.js) — different domain,
+ * different collection.
+ *
+ *   actor (who)   ─┐
+ *   action (what)  ├─► AuditLog doc ──► compliance queries (by actor / action / target)
+ *   resource (tgt) ┘
+ */
+export const auditLogSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
+    outcome: "success" | "failure";
+    metadata?: any;
+    actor?: {
+        adminId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+        email?: string;
+        orgId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+    };
+    resource?: {
+        type?: string;
+    };
+    reason?: string;
+    requestId?: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
+    outcome: "success" | "failure";
+    metadata?: any;
+    actor?: {
+        adminId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+        email?: string;
+        orgId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+    };
+    resource?: {
+        type?: string;
+    };
+    reason?: string;
+    requestId?: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
+    outcome: "success" | "failure";
+    metadata?: any;
+    actor?: {
+        adminId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+        email?: string;
+        orgId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+    };
+    resource?: {
+        type?: string;
+    };
+    reason?: string;
+    requestId?: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+export const AuditLog: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
+    outcome: "success" | "failure";
+    metadata?: any;
+    actor?: {
+        adminId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+        email?: string;
+        orgId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+    };
+    resource?: {
+        type?: string;
+    };
+    reason?: string;
+    requestId?: string;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
+    outcome: "success" | "failure";
+    metadata?: any;
+    actor?: {
+        adminId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+        email?: string;
+        orgId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+    };
+    resource?: {
+        type?: string;
+    };
+    reason?: string;
+    requestId?: string;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
+    outcome: "success" | "failure";
+    metadata?: any;
+    actor?: {
+        adminId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+        email?: string;
+        orgId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+    };
+    resource?: {
+        type?: string;
+    };
+    reason?: string;
+    requestId?: string;
+} & {
+    _id: mongoose.Types.ObjectId;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
+    outcome: "success" | "failure";
+    metadata?: any;
+    actor?: {
+        adminId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+        email?: string;
+        orgId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+    };
+    resource?: {
+        type?: string;
+    };
+    reason?: string;
+    requestId?: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
+    outcome: "success" | "failure";
+    metadata?: any;
+    actor?: {
+        adminId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+        email?: string;
+        orgId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+    };
+    resource?: {
+        type?: string;
+    };
+    reason?: string;
+    requestId?: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    action: "auth.login.success" | "auth.login.failure" | "auth.logout" | "auth.password.reset.requested" | "auth.password.reset.completed" | "auth.token.refresh" | "admin.create" | "admin.update" | "admin.delete" | "admin.role.change" | "admin.deactivate" | "admin.reactivate";
+    outcome: "success" | "failure";
+    metadata?: any;
+    actor?: {
+        adminId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+        email?: string;
+        orgId?: {
+            prototype?: mongoose.Types.ObjectId;
+            cacheHexString?: unknown;
+            generate?: {};
+            createFromTime?: {};
+            createFromHexString?: {};
+            createFromBase64?: {};
+            isValid?: {};
+        };
+    };
+    resource?: {
+        type?: string;
+    };
+    reason?: string;
+    requestId?: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>>;
+import mongoose from 'mongoose';
+//# sourceMappingURL=schema.d.ts.map

package/dist/modules/audit/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/modules/audit/schema.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqBE;AAOF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA4D;qBAzCvC,UAAU"}

package/dist/modules/audit/tests/actions.test.d.ts

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

package/dist/modules/audit/tests/actions.test.d.ts.map

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

package/dist/modules/audit/tests/auditLog.test.d.ts

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

package/dist/modules/audit/tests/auditLog.test.d.ts.map

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

package/dist/modules/audit/tests/schema.test.d.ts

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

package/dist/modules/audit/tests/schema.test.d.ts.map

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