rhombus-node-mcp 0.1.21 → 0.1.23

package/dist/api/guest-management-tool-api.js

@@ -0,0 +1,75 @@
+import { postApi } from "../network.js";
+export async function getAllGuestsByOrg(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/guestmanagement/getAllGuestsByOrg",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(res.errorMsg ?? "Failed to get guests");
+    }
+    return (res.allGuests?.map(guest => ({
+        firstName: guest.firstName ?? undefined,
+        lastName: guest.lastName ?? undefined,
+        email: guest.email ?? undefined,
+        companyName: guest.companyName ?? undefined,
+        locationUuid: guest.locationUuid ?? undefined,
+        hostUserUuid: guest.hostUserUuid ?? undefined,
+        guestType: guest.guestType ?? undefined,
+        checkedInStatus: guest.checkedInEnum ?? undefined,
+        lastCheckedInMs: guest.lastCheckedInMs ?? undefined,
+        lastCheckedOutMs: guest.lastCheckedOutMs ?? undefined,
+        phoneNumber: guest.phoneNumber ?? undefined,
+    })) ?? []);
+}
+export async function getGuestActivityLogs(startTimeMs, endTimeMs, requestModifiers, sessionId) {
+    const body = {};
+    if (startTimeMs)
+        body.createdAfterMs = startTimeMs;
+    if (endTimeMs)
+        body.createdBeforeMs = endTimeMs;
+    const res = await postApi({
+        route: "/guestmanagement/getGuestActivityLogs",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(res.errorMsg ?? "Failed to get guest activity logs");
+    }
+    return (res.guestActivities?.map(a => ({
+        activity: a.activity ?? undefined,
+        email: a.email ?? undefined,
+        guestType: a.guestType ?? undefined,
+        locationUuid: a.locationUuid ?? undefined,
+        hostUserUuid: a.hostUserUuid ?? undefined,
+        timestampMs: a.timestampMs ?? undefined,
+    })) ?? []);
+}
+export async function getActivitiesForLocation(locationUuid, startTimeMs, endTimeMs, requestModifiers, sessionId) {
+    const body = {
+        locationUuid,
+    };
+    if (startTimeMs)
+        body.createdAfterMs = startTimeMs;
+    if (endTimeMs)
+        body.createdBeforeMs = endTimeMs;
+    const res = await postApi({
+        route: "/guestmanagement/getActivitiesForLocation",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error) {
+        throw new Error(res.errorMsg ?? "Failed to get activities for location");
+    }
+    return (res.guestActivities?.map(a => ({
+        activity: a.activity ?? undefined,
+        email: a.email ?? undefined,
+        guestType: a.guestType ?? undefined,
+        locationUuid: a.locationUuid ?? undefined,
+        hostUserUuid: a.hostUserUuid ?? undefined,
+        timestampMs: a.timestampMs ?? undefined,
+    })) ?? []);
+}

package/dist/api/location-tool-api.js

@@ -1,9 +1,56 @@
 import { postApi } from "../network.js";
 export async function getLocations(requestModifiers, sessionId) {
-    return await postApi({
+    const res = await postApi({
         route: "/location/getLocationsV2",
         body: {},
         modifiers: requestModifiers,
         sessionId,
     });
+    return {
+        locations: (res.locations || []).map((loc) => ({
+            uuid: loc.uuid ?? undefined,
+            name: loc.name ?? undefined,
+        })),
+    };
+}
+export async function createLocation(name, address, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/location/createLocation",
+        body: { name, address: address || undefined },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return { uuid: res.locationUuid ?? res.uuid ?? undefined, success: true };
+}
+export async function updateLocation(locationUuid, name, address, requestModifiers, sessionId) {
+    const body = { locationUuid };
+    if (name)
+        body.name = name;
+    if (address)
+        body.address = address;
+    const res = await postApi({
+        route: "/location/updateLocation",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return { success: true };
+}
+export async function getLocationLabels(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/location/getLocationLabelsForOrg",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return (res.locationLabels || []).map((label) => ({
+        uuid: label.uuid ?? undefined,
+        name: label.name ?? undefined,
+    }));
 }

package/dist/api/lpr-tool-api.js

@@ -66,3 +66,29 @@ export async function getVehicleLabels(requestModifiers, sessionId) {
     }
     return processedVehicleLabels;
 }
+export async function searchLicensePlates(query, timeZone, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/search/searchLicensePlates",
+        body: { licensePlateQuery: query },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return (res.licensePlateEvents || []).map((event) => ({
+        licensePlate: event.vehicleLicensePlate ?? undefined,
+        deviceUuid: event.deviceUuid ?? undefined,
+        timestampMs: event.eventTimestamp ?? undefined,
+    }));
+}
+export async function saveVehicle(name, licensePlate, description, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/vehicle/saveVehicle",
+        body: { name, licensePlate, description: description || "" },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return { success: true };
+}

package/dist/api/policy-alerts-tool-api.js

@@ -40,3 +40,57 @@ export async function getExpiringPolicyAlerts(args, requestModifiers, sessionId)
         };
     });
 }
+export async function getPolicyAlertDetails(alertUuid, requestModifiers, sessionId) {
+    const response = await postApi({
+        route: "/event/getPolicyAlertDetails",
+        body: { policyAlertUuid: alertUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    return { policyAlerts: response.policyAlert ? [response.policyAlert] : [] };
+}
+export async function dismissPolicyAlert(alertUuid, requestModifiers, sessionId) {
+    const response = await postApi({
+        route: "/event/dismissPolicyAlertV2",
+        body: { policyAlertUuid: alertUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    return { policyAlerts: [], dismissed: true };
+}
+export async function getUnhealthyDeviceAlerts(requestModifiers, sessionId) {
+    const response = await postApi({
+        route: "/event/getUnhealthyDeviceAlerts",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    return { policyAlerts: response.unhealthyDeviceAlerts || [] };
+}
+export async function getPolicyAlertGroups(payload, requestModifiers, sessionId) {
+    const body = {};
+    if (payload.afterTimestampMs)
+        body.afterTimestampMs = payload.afterTimestampMs;
+    if (payload.beforeTimestampMs)
+        body.beforeTimestampMs = payload.beforeTimestampMs;
+    if (payload.deviceFilter)
+        body.deviceUuids = payload.deviceFilter;
+    if (payload.locationFilter)
+        body.locationUuids = payload.locationFilter;
+    if (payload.maxResults)
+        body.maxResults = payload.maxResults;
+    if (payload.lastTimestampMs != null)
+        body.lastTimestampMs = payload.lastTimestampMs;
+    if (payload.lastUuid)
+        body.lastUuid = payload.lastUuid;
+    const response = await postApi({
+        route: "/event/getPolicyAlertGroupsV2",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    return {
+        ...response,
+        policyAlerts: response.policyAlertGroups || [],
+    };
+}

package/dist/api/report-tool-api.js

@@ -1,13 +1,12 @@
+import { DateTime } from "luxon";
 import { getLogger } from "../logger.js";
 import { postApi } from "../network.js";
+import { ReportTypeEnum } from "../types/schema.js";
 import { formatTimestamp } from "../util.js";
-import { GetCountReportV2WSRequestTypesEnum } from "../types/schema-components.js";
-import { DateTime } from "luxon";
 const REPORT_TYPES_THAT_RETURN_UTC = new Set([
-    GetCountReportV2WSRequestTypesEnum.BANDWIDTH,
-    GetCountReportV2WSRequestTypesEnum.VEHICLES,
-    GetCountReportV2WSRequestTypesEnum.MOTION,
-    GetCountReportV2WSRequestTypesEnum.DWELL,
+    ReportTypeEnum.BANDWIDTH,
+    ReportTypeEnum.LICENSEPLATES,
+    ReportTypeEnum.DWELL,
 ]);
 const logger = getLogger();
 function getUtcTime(datetime, reportType, timeZone) {
@@ -15,8 +14,8 @@ function getUtcTime(datetime, reportType, timeZone) {
         return datetime;
     }
     else {
-        logger.info("timeZone", datetime);
-        return DateTime.fromISO(datetime, { zone: timeZone }).toUTC().toISO();
+        logger.trace("timeZone", datetime);
+        return DateTime.fromISO(datetime, { zone: timeZone }).toUTC().toISO() ?? datetime;
     }
 }
 export async function getOccupancyCountReport(deviceUuid, startTimeMs, endTimeMs, interval, requestModifiers, sessionId) {
@@ -59,7 +58,9 @@ export async function getSummaryCountReport(interval, scope, types, uuid, endTim
         scope,
         startTimeMs,
         types,
-        ...(uuid ? { uuid } : {}),
+        // omit for org
+        ...(uuid && scope !== "ORG" ? { uuid } : {}),
+        ...(timeZone ? { timeZone } : {}),
     };
     const response = await postApi({
         route: "/report/getCountReportV2",
@@ -68,8 +69,8 @@ export async function getSummaryCountReport(interval, scope, types, uuid, endTim
         sessionId,
     });
     // Process response to convert date strings to UTC milliseconds timestamps
-    let newTimeSeriesDataPoints = undefined;
-    if (response && response.timeSeriesDataPoints && Array.isArray(response.timeSeriesDataPoints)) {
+    let newTimeSeriesDataPoints;
+    if (response?.timeSeriesDataPoints && Array.isArray(response.timeSeriesDataPoints)) {
         newTimeSeriesDataPoints = response.timeSeriesDataPoints.map((dataPoint) => {
             const sanitizedDataPoint = {
                 eventCountMap: dataPoint.eventCountMap,
@@ -162,7 +163,7 @@ export async function getThresholdCrossingCountReport(deviceUuid, startTimeMs, e
         }))
         : undefined;
     // Calculate metrics if we have crossing counts and the bucket size is appropriate
-    let metrics = undefined;
+    let metrics;
     if (crossingCounts && crossingCounts.length > 0) {
         // Calculate total entries and exits
         let totalEntries = 0;
@@ -244,17 +245,17 @@ export async function getThresholdCrossingCountReport(deviceUuid, startTimeMs, e
             averageExitsPerHour: totalExits / hoursInPeriod,
             mostEntriesInHour: {
                 count: maxEntries,
-                timestamp: maxEntriesTimestamp ? DateTime.fromMillis(maxEntriesTimestamp).toISO() : "",
+                timestamp: maxEntriesTimestamp ? DateTime.fromMillis(maxEntriesTimestamp).toISO() ?? "" : "",
                 hourLabel: formatHourLabel(maxEntriesTimestamp),
             },
             mostExitsInHour: {
                 count: maxExits,
-                timestamp: maxExitsTimestamp ? DateTime.fromMillis(maxExitsTimestamp).toISO() : "",
+                timestamp: maxExitsTimestamp ? DateTime.fromMillis(maxExitsTimestamp).toISO() ?? "" : "",
                 hourLabel: formatHourLabel(maxExitsTimestamp),
             },
             busiestHour: {
                 totalCount: maxTotal,
-                timestamp: maxTotalTimestamp ? DateTime.fromMillis(maxTotalTimestamp).toISO() : "",
+                timestamp: maxTotalTimestamp ? DateTime.fromMillis(maxTotalTimestamp).toISO() ?? "" : "",
                 hourLabel: formatHourLabel(maxTotalTimestamp),
                 entries: maxTotalEntries,
                 exits: maxTotalExits,
@@ -307,13 +308,10 @@ export async function getCustomLLMReport(promptUuid, promptType, startTimeMs, en
         endTimeMs,
         interval,
     }));
-    const body = {
-        promptUuid,
-        startTimeMs,
-        endTimeMs,
-        interval,
-    };
-    // Determine the correct endpoint based on promptType
+    // PERCENT endpoint uses a different request schema that doesn't accept interval
+    const body = promptType === "PERCENT"
+        ? { promptUuid, startTimeMs, endTimeMs }
+        : { promptUuid, startTimeMs, endTimeMs, interval };
     let route;
     switch (promptType) {
         case "COUNT":
@@ -348,7 +346,7 @@ export async function getCustomLLMReport(promptUuid, promptType, startTimeMs, en
         logger.info(`📊 ${promptType} response structure:`, JSON.stringify({ reportEntries: reportEntries.length }));
         // Aggregate data from all devices
         const aggregatedData = {};
-        reportEntries.forEach(([deviceId, reportData]) => {
+        reportEntries.forEach(([_, reportData]) => {
             if (Array.isArray(reportData)) {
                 reportData.forEach((item) => {
                     const dateKey = item.localDate || new Date().toISOString();
@@ -424,3 +422,327 @@ export async function getCustomLLMReport(promptUuid, promptType, startTimeMs, en
     }));
     return result;
 }
+export async function getAuditFeed(startTimeMs, endTimeMs, requestModifiers, sessionId) {
+    const body = { startTimeMs, endTimeMs };
+    const response = await postApi({
+        route: "/report/getAuditFeed",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    return {
+        error: response.error ?? undefined,
+        errorMsg: response.errorMsg ?? undefined,
+        auditEvents: (response.auditEvents || []).map((event) => ({
+            timestamp: event.timestamp != null ? String(event.timestamp) : undefined,
+            action: event.action ?? undefined,
+            displayText: event.displayText ?? undefined,
+            principalName: event.principalName ?? undefined,
+            principalUuid: event.principalUuid ?? undefined,
+            principalType: event.principalType ?? undefined,
+            targetName: event.targetName ?? undefined,
+            targetUuid: event.targetUuid ?? undefined,
+        })),
+    };
+}
+export async function getDiagnosticFeed(startTimeMs, endTimeMs, requestModifiers, sessionId) {
+    const body = { startTimeMs, endTimeMs };
+    const response = await postApi({
+        route: "/report/getDiagnosticFeed",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    return {
+        error: response.error ?? undefined,
+        errorMsg: response.errorMsg ?? undefined,
+        diagnosticEvents: (response.diagnosticEvents || []).map((event) => ({
+            timestampMs: event.timestamp ?? undefined,
+            deviceUuid: event.deviceUuid ?? undefined,
+            eventType: event.activity ?? undefined,
+            description: event.description ?? undefined,
+        })),
+    };
+}
+export async function getThresholdCrossingEvents(deviceUuid, startTimeMs, endTimeMs, requestModifiers, sessionId) {
+    const body = { deviceUuid, startTimeMs, endTimeMs };
+    const response = await postApi({
+        route: "/report/getThresholdCrossingEvents",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    return {
+        error: response.error ?? undefined,
+        errorMsg: response.errorMsg ?? undefined,
+        events: (response.thresholdEvents || response.events || []).map((event) => ({
+            timestampMs: event.timestampMs ?? undefined,
+            direction: event.direction ?? undefined,
+            objectType: event.objectType ?? undefined,
+        })),
+    };
+}
+export async function getCustomEventsReport(promptUuid, startTimeMs, endTimeMs, interval, requestModifiers, sessionId) {
+    const body = { promptUuid, startTimeMs, endTimeMs, interval };
+    const response = await postApi({
+        route: "/report/getCustomEventsReport",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    return {
+        error: response.error ?? undefined,
+        errorMsg: response.errorMsg ?? undefined,
+        timeSeriesDataPoints: response.timeSeriesDataPoints?.map((dp) => ({
+            dateLocal: dp.dateLocal ?? undefined,
+            dateUtc: dp.dateUtc ?? undefined,
+            eventCountMap: dp.eventCountMap ?? undefined,
+        })),
+    };
+}
+export async function getPeopleCountEvents(deviceUuids, requestModifiers, sessionId) {
+    const body = { deviceUuids };
+    const response = await postApi({
+        route: "/report/getMostRecentPeopleCountEvents",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    return {
+        error: response.error ?? undefined,
+        errorMsg: response.errorMsg ?? undefined,
+        events: (response.events || []).map((event) => ({
+            deviceUuid: event.deviceUuid ?? undefined,
+            timestampMs: event.timestampMs ?? undefined,
+            count: event.count ?? undefined,
+        })),
+    };
+}
+export async function getBatchThresholdCrossingCountReport(deviceUuids, startTimeMs, endTimeMs, bucketSize, crossingObject, dedupe, timeZone, requestModifiers, sessionId) {
+    const body = {
+        deviceUuids,
+        startTimeMs,
+        endTimeMs,
+        bucketSize,
+        crossingObject,
+        dedupe,
+        ...(timeZone ? { timeZone } : {}),
+    };
+    const response = await postApi({
+        route: "/report/getBatchThresholdCrossingCountReport",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (response.error) {
+        throw new Error(response.errorMsg ?? "Failed to get batch threshold crossing report");
+    }
+    const deviceCrossingCounts = response.deviceCrossingCounts ?? response.crossingCounts ?? {};
+    const result = {};
+    for (const [deviceUuid, counts] of Object.entries(deviceCrossingCounts)) {
+        result[deviceUuid] = (counts || []).map((c) => ({
+            timestampMs: c.timestampMs ?? undefined,
+            ingressCount: c.ingressCount ?? undefined,
+            egressCount: c.egressCount ?? undefined,
+        }));
+    }
+    return result;
+}
+export async function getThresholdCrossingCountReportForOrg(startTimeMs, endTimeMs, bucketSize, crossingObject, dedupe, timeZone, requestModifiers, sessionId) {
+    const body = {
+        startTimeMs,
+        endTimeMs,
+        bucketSize,
+        crossingObject,
+        dedupe,
+        ...(timeZone ? { timeZone } : {}),
+    };
+    const response = await postApi({
+        route: "/report/getThresholdCrossingCountReportForOrg",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (response.error) {
+        throw new Error(response.errorMsg ?? "Failed to get org threshold crossing report");
+    }
+    return (response.crossingCounts ?? []).map(c => ({
+        timestampMs: c.timestampMs ?? undefined,
+        ingressCount: c.ingressCount ?? undefined,
+        egressCount: c.egressCount ?? undefined,
+    }));
+}
+export async function getThresholdCrossingCounts(devices, startTimeMs, endTimeMs, crossingObject, dailyResetTimeMinute, requestModifiers, sessionId) {
+    const body = {
+        devices,
+        startTimeMs,
+        endTimeMs,
+        crossingObject,
+    };
+    if (dailyResetTimeMinute != null)
+        body.dailyResetTimeMinute = dailyResetTimeMinute;
+    const response = await postApi({
+        route: "/report/getThresholdCrossingCounts",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (response.error) {
+        throw new Error(response.errorMsg ?? "Failed to get threshold crossing counts");
+    }
+    return (response.counts ?? []).map((c) => ({
+        count: c.count ?? undefined,
+        timestampMs: c.timestampMs ?? undefined,
+    }));
+}
+export async function getCountReportsForDevicesAtLocation(locationUuid, startTimeMs, endTimeMs, interval, type, requestModifiers, sessionId) {
+    const body = {
+        locationUuid,
+        startTimeMs,
+        endTimeMs,
+        interval,
+        type,
+    };
+    const response = await postApi({
+        route: "/report/getCountReportsForDevicesAtLocation",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (response.error) {
+        throw new Error(response.errorMsg ?? "Failed to get count reports for devices at location");
+    }
+    const deviceDataMap = {};
+    const rawMap = response.timeSeriesDataPointsMap ?? {};
+    for (const [deviceUuid, dataPoints] of Object.entries(rawMap)) {
+        deviceDataMap[deviceUuid] = (dataPoints || []).map((dp) => ({
+            dateUtcString: dp.dateLocal ?? dp.dateUtc ?? undefined,
+            eventCountMap: dp.eventCountMap ?? undefined,
+        }));
+    }
+    return deviceDataMap;
+}
+export async function getRunningAverage(uuid, startTimeMs, endTimeMs, interval, scope, timeZone, requestModifiers, sessionId) {
+    const body = {
+        startTimeMs,
+        endTimeMs,
+        interval,
+        scope,
+    };
+    if (uuid)
+        body.uuid = uuid;
+    if (timeZone)
+        body.timeZone = timeZone;
+    const response = await postApi({
+        route: "/report/getRunningAverage",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (response.error) {
+        throw new Error(response.errorMsg ?? "Failed to get running average");
+    }
+    return (response.statsDataPoints ?? []).map((dp) => ({
+        date: dp.date ?? undefined,
+        stats: dp.stats ?? undefined,
+    }));
+}
+export async function triggerScenePrompt(deviceFacetUuid, prompt, promptType, timestampMs, requestModifiers, sessionId) {
+    const body = {
+        deviceFacetUuid,
+        prompt,
+        promptType,
+    };
+    if (timestampMs != null)
+        body.timestampMs = timestampMs;
+    const response = await postApi({
+        route: "/scenequery/triggerPrompt",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (response.error) {
+        throw new Error(response.errorMsg ?? "Failed to trigger scene prompt");
+    }
+    const event = response.event;
+    return {
+        value: event?.value ?? undefined,
+        prompt: event?.prompt ?? undefined,
+        timestampMs: event?.timestampMs ?? undefined,
+        checkCondition: event?.checkCondition ?? undefined,
+        image: event?.image ?? undefined,
+    };
+}
+export async function adHocScenePrompt(deviceFacetUuid, promptUuid, timestampMs, requestModifiers, sessionId) {
+    const body = {
+        deviceFacetUuid,
+        promptUuid,
+    };
+    if (timestampMs != null)
+        body.timestampMs = timestampMs;
+    const response = await postApi({
+        route: "/scenequery/adHocPrompt",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (response.error) {
+        throw new Error(response.errorMsg ?? "Failed to execute ad-hoc scene prompt");
+    }
+    const event = response.event;
+    return {
+        value: event?.value ?? undefined,
+        prompt: event?.prompt ?? undefined,
+        timestampMs: event?.timestampMs ?? undefined,
+        checkCondition: event?.checkCondition ?? undefined,
+        image: event?.image ?? undefined,
+    };
+}
+const MAX_FACE_COUNT_PAGES = 5;
+const FACE_COUNT_PAGE_SIZE = 200;
+export async function getUniqueFaceCount(deviceUuid, startTimeMs, endTimeMs, requestModifiers, sessionId) {
+    const uniquePersonUuids = new Set();
+    let totalFaceEvents = 0;
+    let lastEvaluatedKey;
+    for (let page = 0; page < MAX_FACE_COUNT_PAGES; page++) {
+        const body = {
+            searchFilter: {
+                deviceUuids: [deviceUuid],
+                timestampFilter: {
+                    rangeStart: new Date(startTimeMs).toISOString(),
+                    rangeEnd: new Date(endTimeMs).toISOString(),
+                },
+            },
+            pageRequest: {
+                maxPageSize: FACE_COUNT_PAGE_SIZE,
+                ...(lastEvaluatedKey ? { lastEvaluatedKey } : {}),
+            },
+        };
+        try {
+            const response = await postApi({
+                route: "/faceRecognition/faceEvent/findFaceEventsByOrg",
+                body,
+                modifiers: requestModifiers,
+                sessionId,
+            });
+            if (response.error || !response.faceEvents) {
+                break;
+            }
+            for (const event of response.faceEvents) {
+                totalFaceEvents++;
+                if (event.personUuid) {
+                    uniquePersonUuids.add(event.personUuid);
+                }
+            }
+            if (response.faceEvents.length < FACE_COUNT_PAGE_SIZE || !response.lastEvaluatedKey) {
+                break;
+            }
+            lastEvaluatedKey = response.lastEvaluatedKey;
+        }
+        catch (err) {
+            logger.error("Error fetching face events for enrichment", err);
+            break;
+        }
+    }
+    return { uniqueFaceCount: uniquePersonUuids.size, totalFaceEvents };
+}