@awarevue/api-types 2.0.22 → 2.0.23

package/dist/api/commands/presence-tracker.js

@@ -0,0 +1,30 @@
+import { sPersonId, sZoneId } from '../../primitives';
+import { z } from 'zod';
+// COMMANDS
+export const sCheckInPersonCommand = z.object({
+    command: z.literal('presence-tracker.check-in'),
+    params: z.object({
+        personId: sPersonId,
+        zoneId: sZoneId.nullable(),
+    }),
+});
+export const sCheckOutPersonCommand = z.object({
+    command: z.literal('presence-tracker.check-out'),
+    params: z.object({
+        personId: sPersonId,
+        zoneId: sZoneId.nullable(),
+        leave: z.boolean(),
+    }),
+});
+export const sTogglePresenceCommand = z.object({
+    command: z.literal('presence-tracker.toggle-presence'),
+    params: z.object({
+        personId: sPersonId,
+        zoneId: sZoneId.nullable(),
+    }),
+});
+export const presenceTrackerCommands = {
+    'presence-tracker.check-in': sCheckInPersonCommand,
+    'presence-tracker.check-out': sCheckOutPersonCommand,
+    'presence-tracker.toggle-presence': sTogglePresenceCommand,
+};

package/dist/api/commands/server.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { sDeviceParam, sMacroId, sNotificationSeverity, } from '../../primitives';
+// COMMANDS
+export const sRunMacroCommand = z.object({
+    command: z.literal('server.run-macro'),
+    params: z.object({
+        macroId: sMacroId,
+    }),
+});
+export const sNotify = z.object({
+    command: z.literal('server.notify'),
+    params: z.object({
+        source: sDeviceParam,
+        message: z.string().nonempty(),
+        severity: sNotificationSeverity,
+        metadata: z.record(z.unknown()),
+        notificationRef: z.string().nonempty().nullable(),
+        recipientId: z.string().nonempty().nullable(),
+    }),
+});
+export const serverCommands = {
+    'server.run-macro': sRunMacroCommand,
+    'server.notify': sNotify,
+};

package/dist/api/error.js

@@ -0,0 +1,181 @@
+import { z } from 'zod';
+import { sCredentialType } from '../objects/credential';
+// METADATA
+export const sDuplicateMeta = z.object({
+    subject: z.string(),
+    field: z.string(),
+    value: z.string().optional(),
+    existingId: z.string().optional(), // UUID or whatever
+});
+export const sNotFoundMeta = z.object({
+    subject: z.string(),
+    field: z.string(),
+    value: z.string(),
+});
+export const sInvalidMeta = z.object({
+    subject: z.string(),
+    fieldErrors: z.record(z.string()), // key → human msg
+});
+export const sConflictMeta = z.object({
+    subject: z.string(),
+    blockingSubject: z.string().optional(),
+    blockingId: z.string().optional(),
+    value: z.string().optional(),
+});
+export const sVoidMeta = z.object({}).strict();
+export const sAccessRuleConflictMeta = z.object({
+    deviceSchedules: z.record(z.string(), z.array(z.string())),
+});
+export const sZoneAccessRuleConflictMeta = z.object({
+    zoneId: z.string(),
+    accessRuleIds: z.array(z.string()),
+});
+export const sTokenInvalidFormatMeta = z.object({
+    token: z.string(),
+    expectedFormat: z.string(),
+});
+export const sTokenLimitExceededMeta = z.object({
+    limit: z.number(),
+    type: sCredentialType,
+});
+// ERROR CODES
+export var AppErrorCode;
+(function (AppErrorCode) {
+    // generic
+    AppErrorCode["RESOURCE_ALREADY_EXISTS"] = "RESOURCE_ALREADY_EXISTS";
+    AppErrorCode["RESOURCE_NOT_FOUND"] = "RESOURCE_NOT_FOUND";
+    AppErrorCode["RESOURCE_FORBIDDEN"] = "RESOURCE_FORBIDDEN";
+    AppErrorCode["RESOURCE_INVALID"] = "RESOURCE_INVALID";
+    AppErrorCode["RESOURCE_IN_USE"] = "RESOURCE_IN_USE";
+    AppErrorCode["RESOURCE_NOT_SUPPORTED"] = "RESOURCE_NOT_SUPPORTED";
+    AppErrorCode["BAD_REFERENCE"] = "BAD_REFERENCE";
+    AppErrorCode["UNKNOWN"] = "UNKNOWN";
+    AppErrorCode["SERVER_INTERNAL_ERROR"] = "SERVER_INTERNAL_ERROR";
+    AppErrorCode["UNAUTHORIZED"] = "UNAUTHORIZED";
+    AppErrorCode["BAD_REQUEST"] = "BAD_REQUEST";
+    // access
+    AppErrorCode["ACCESS_RULE_NOT_FOUND"] = "ACCESS_RULE_NOT_FOUND";
+    AppErrorCode["ACCESS_RULE_PERMISSION_CONFLICT"] = "ACCESS_RULE_PERMISSION_CONFLICT";
+    // alarm
+    AppErrorCode["ALARM_NOT_FOUND"] = "ALARM_NOT_FOUND";
+    // auth / user
+    AppErrorCode["AUTH_INVALID_CREDENTIALS"] = "AUTH_INVALID_CREDENTIALS";
+    AppErrorCode["AUTH_CITADEL_MODE_ENABLED"] = "AUTH_CITADEL_MODE_ENABLED";
+    AppErrorCode["USER_NOT_FOUND"] = "USER_NOT_FOUND";
+    AppErrorCode["USERNAME_ALREADY_EXISTS"] = "USERNAME_ALREADY_EXISTS";
+    AppErrorCode["EMAIL_ALREADY_EXISTS"] = "EMAIL_ALREADY_EXISTS";
+    AppErrorCode["CANNOT_DELETE_ROOT_USER"] = "CANNOT_DELETE_ROOT_USER";
+    // person / token
+    AppErrorCode["PERSON_NOT_FOUND"] = "PERSON_NOT_FOUND";
+    AppErrorCode["PERSON_INVALID_ID"] = "PERSON_INVALID_ID";
+    AppErrorCode["TOKEN_NOT_SUPPORTED"] = "TOKEN_NOT_SUPPORTED";
+    AppErrorCode["TOKEN_INVALID_FORMAT"] = "TOKEN_INVALID_FORMAT";
+    AppErrorCode["TOKEN_LIMIT_EXCEEDED"] = "TOKEN_LIMIT_EXCEEDED";
+    AppErrorCode["TOKEN_IN_USE"] = "TOKEN_IN_USE";
+    // device
+    AppErrorCode["DEVICE_NOT_FOUND"] = "DEVICE_NOT_FOUND";
+    AppErrorCode["DEVICE_ALREADY_EXISTS"] = "DEVICE_ALREADY_EXISTS";
+    AppErrorCode["DEVICE_INVALID_ID"] = "DEVICE_INVALID_ID";
+    AppErrorCode["DEVICE_INVALID_TYPE"] = "DEVICE_INVALID_TYPE";
+    AppErrorCode["DEVICE_INVALID_RELATION_TYPE"] = "DEVICE_INVALID_RELATION_TYPE";
+    AppErrorCode["DEVICE_INVALID_TEMPLATE"] = "DEVICE_INVALID_TEMPLATE";
+    AppErrorCode["DEVICE_INVALID_PROVIDER_METADATA"] = "DEVICE_INVALID_PROVIDER_METADATA";
+    AppErrorCode["DEVICE_PRESET_ALREADY_EXISTS"] = "DEVICE_PRESET_ALREADY_EXISTS";
+    AppErrorCode["DEVICE_NOT_SUPPORTED"] = "DEVICE_NOT_SUPPORTED";
+    // group / zone / schedule
+    AppErrorCode["GROUP_NOT_FOUND"] = "GROUP_NOT_FOUND";
+    AppErrorCode["GROUP_ALREADY_EXISTS"] = "GROUP_ALREADY_EXISTS";
+    AppErrorCode["ZONE_NOT_FOUND"] = "ZONE_NOT_FOUND";
+    AppErrorCode["ZONE_ALREADY_EXISTS"] = "ZONE_ALREADY_EXISTS";
+    AppErrorCode["ZONE_IN_USE"] = "ZONE_IN_USE";
+    AppErrorCode["ZONE_ACCESS_RULE_CONFLICT"] = "ZONE_ACCESS_RULE_CONFLICT";
+    AppErrorCode["SCHEDULE_NOT_FOUND"] = "SCHEDULE_NOT_FOUND";
+    AppErrorCode["SCHEDULE_ALREADY_EXISTS"] = "SCHEDULE_ALREADY_EXISTS";
+    AppErrorCode["SCHEDULE_IN_USE"] = "SCHEDULE_IN_USE";
+    // permission / role
+    AppErrorCode["PERMISSION_ALREADY_EXISTS"] = "PERMISSION_ALREADY_EXISTS";
+    AppErrorCode["ROLE_ALREADY_EXISTS"] = "ROLE_ALREADY_EXISTS";
+    AppErrorCode["ADMIN_ROLE_CANNOT_UPDATE"] = "ADMIN_ROLE_CANNOT_UPDATE";
+    AppErrorCode["ADMIN_ROLE_CANNOT_DELETE"] = "ADMIN_ROLE_CANNOT_DELETE";
+    // automation / rules
+    AppErrorCode["RULE_ALREADY_EXISTS"] = "RULE_ALREADY_EXISTS";
+    AppErrorCode["RULE_INVALID_BODY"] = "RULE_INVALID_BODY";
+    AppErrorCode["RULE_MISSING_CODE"] = "RULE_MISSING_CODE";
+    // layout / view
+    AppErrorCode["LAYOUT_ALREADY_EXISTS"] = "LAYOUT_ALREADY_EXISTS";
+    AppErrorCode["VIEW_ALREADY_EXISTS"] = "VIEW_ALREADY_EXISTS";
+    // config
+    AppErrorCode["CONFIG_INVALID"] = "CONFIG_INVALID";
+})(AppErrorCode || (AppErrorCode = {}));
+export const errorMetadataSchemas = {
+    [AppErrorCode.RESOURCE_ALREADY_EXISTS]: sDuplicateMeta,
+    [AppErrorCode.RESOURCE_NOT_FOUND]: sNotFoundMeta,
+    [AppErrorCode.RESOURCE_INVALID]: sInvalidMeta,
+    [AppErrorCode.RESOURCE_IN_USE]: sConflictMeta,
+    [AppErrorCode.RESOURCE_NOT_SUPPORTED]: sVoidMeta,
+    [AppErrorCode.RESOURCE_FORBIDDEN]: sVoidMeta,
+    [AppErrorCode.BAD_REFERENCE]: sVoidMeta,
+    // access
+    [AppErrorCode.ACCESS_RULE_NOT_FOUND]: sNotFoundMeta,
+    [AppErrorCode.ACCESS_RULE_PERMISSION_CONFLICT]: sAccessRuleConflictMeta,
+    // alarm
+    [AppErrorCode.ALARM_NOT_FOUND]: sNotFoundMeta,
+    // auth / user
+    [AppErrorCode.AUTH_INVALID_CREDENTIALS]: sVoidMeta,
+    [AppErrorCode.AUTH_CITADEL_MODE_ENABLED]: sVoidMeta,
+    [AppErrorCode.USER_NOT_FOUND]: sNotFoundMeta,
+    [AppErrorCode.USERNAME_ALREADY_EXISTS]: sDuplicateMeta,
+    [AppErrorCode.EMAIL_ALREADY_EXISTS]: sDuplicateMeta,
+    [AppErrorCode.CANNOT_DELETE_ROOT_USER]: sVoidMeta,
+    // person / token
+    [AppErrorCode.PERSON_NOT_FOUND]: sNotFoundMeta,
+    [AppErrorCode.PERSON_INVALID_ID]: sInvalidMeta,
+    [AppErrorCode.TOKEN_NOT_SUPPORTED]: sVoidMeta,
+    [AppErrorCode.TOKEN_INVALID_FORMAT]: sTokenInvalidFormatMeta,
+    [AppErrorCode.TOKEN_LIMIT_EXCEEDED]: sTokenLimitExceededMeta,
+    [AppErrorCode.TOKEN_IN_USE]: sConflictMeta,
+    // device
+    [AppErrorCode.DEVICE_NOT_FOUND]: sNotFoundMeta,
+    [AppErrorCode.DEVICE_ALREADY_EXISTS]: sDuplicateMeta,
+    [AppErrorCode.DEVICE_INVALID_ID]: sInvalidMeta,
+    [AppErrorCode.DEVICE_INVALID_TYPE]: sInvalidMeta,
+    [AppErrorCode.DEVICE_INVALID_RELATION_TYPE]: sInvalidMeta,
+    [AppErrorCode.DEVICE_INVALID_TEMPLATE]: sInvalidMeta,
+    [AppErrorCode.DEVICE_INVALID_PROVIDER_METADATA]: sInvalidMeta,
+    [AppErrorCode.DEVICE_PRESET_ALREADY_EXISTS]: sDuplicateMeta,
+    [AppErrorCode.DEVICE_NOT_SUPPORTED]: sVoidMeta,
+    // group / zone / schedule
+    [AppErrorCode.GROUP_NOT_FOUND]: sNotFoundMeta,
+    [AppErrorCode.GROUP_ALREADY_EXISTS]: sDuplicateMeta,
+    [AppErrorCode.ZONE_NOT_FOUND]: sNotFoundMeta,
+    [AppErrorCode.ZONE_ALREADY_EXISTS]: sDuplicateMeta,
+    [AppErrorCode.ZONE_IN_USE]: sConflictMeta,
+    [AppErrorCode.ZONE_ACCESS_RULE_CONFLICT]: sZoneAccessRuleConflictMeta,
+    [AppErrorCode.SCHEDULE_NOT_FOUND]: sNotFoundMeta,
+    [AppErrorCode.SCHEDULE_ALREADY_EXISTS]: sDuplicateMeta,
+    [AppErrorCode.SCHEDULE_IN_USE]: sConflictMeta,
+    // permission / role
+    [AppErrorCode.PERMISSION_ALREADY_EXISTS]: sDuplicateMeta,
+    [AppErrorCode.ROLE_ALREADY_EXISTS]: sDuplicateMeta,
+    [AppErrorCode.ADMIN_ROLE_CANNOT_UPDATE]: sVoidMeta,
+    [AppErrorCode.ADMIN_ROLE_CANNOT_DELETE]: sVoidMeta,
+    // automation / rules
+    [AppErrorCode.RULE_ALREADY_EXISTS]: sDuplicateMeta,
+    [AppErrorCode.RULE_INVALID_BODY]: sInvalidMeta,
+    [AppErrorCode.RULE_MISSING_CODE]: sVoidMeta,
+    // layout / view
+    [AppErrorCode.LAYOUT_ALREADY_EXISTS]: sDuplicateMeta,
+    [AppErrorCode.VIEW_ALREADY_EXISTS]: sDuplicateMeta,
+    // config
+    [AppErrorCode.CONFIG_INVALID]: sInvalidMeta,
+    [AppErrorCode.UNKNOWN]: sVoidMeta,
+    [AppErrorCode.SERVER_INTERNAL_ERROR]: sVoidMeta,
+    [AppErrorCode.UNAUTHORIZED]: sVoidMeta,
+    [AppErrorCode.BAD_REQUEST]: sVoidMeta,
+};
+export function isErrorResponse(err) {
+    return (!!err &&
+        typeof err === 'object' &&
+        'code' in err &&
+        Object.values(AppErrorCode).includes(err.code));
+}

package/dist/api/events/alarm.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+// EVENTS
+export const sAlarmTriggeredEvent = z.object({
+    kind: z.literal('alarm-triggered'),
+    alarmId: z.string().nonempty(),
+});
+export const sAlarmAcknowledgedEvent = z.object({
+    kind: z.literal('alarm-acknowledged'),
+    alarmId: z.string().nonempty(),
+    userId: z.string().optional(),
+    personId: z.string().optional(),
+});
+export const sAlarmArmedAllEvent = z.object({
+    kind: z.literal('alarm-armed-all'),
+    userId: z.string().optional(),
+    personId: z.string().optional(),
+});
+export const sAlarmDisarmedAllEvent = z.object({
+    kind: z.literal('alarm-disarmed-all'),
+    userId: z.string().optional(),
+    personId: z.string().optional(),
+});
+export const sAlarmArmedEvent = z.object({
+    kind: z.literal('alarm-armed'),
+    subjects: z.array(z.string().nonempty()),
+    userId: z.string().optional(),
+    personId: z.string().optional(),
+});
+export const sAlarmDisarmedEvent = z.object({
+    kind: z.literal('alarm-disarmed'),
+    subjects: z.array(z.string().nonempty()),
+    userId: z.string().optional(),
+    personId: z.string().optional(),
+});
+export const sAlarmArmReleasedEvent = z.object({
+    kind: z.literal('alarm-arm-released'),
+    userId: z.string().optional(),
+    personId: z.string().optional(),
+});
+export const sAlarmRearmedEvent = z.object({
+    kind: z.literal('alarm-rearmed'),
+});
+export const alarmEventSchemasByKind = {
+    'alarm-triggered': sAlarmTriggeredEvent,
+    'alarm-acknowledged': sAlarmAcknowledgedEvent,
+    'alarm-armed-all': sAlarmArmedAllEvent,
+    'alarm-disarmed-all': sAlarmDisarmedAllEvent,
+    'alarm-armed': sAlarmArmedEvent,
+    'alarm-disarmed': sAlarmDisarmedEvent,
+    'alarm-arm-released': sAlarmArmReleasedEvent,
+    'alarm-rearmed': sAlarmRearmedEvent,
+};

package/dist/{events → api/events}/all.d.ts

@@ -9,8 +9,8 @@ import { PresenceTrackerEvent } from './presence-tracker';
 import { ReaderEvent } from './reader';
 import { ServerEvent } from './server';
 import { NvrExporterEvent } from './nvr-exporter';
-import { DeviceType } from '../device';
-import { NotificationSeverity } from 'src/primitives';
+import { DeviceType } from '../../objects/device';
+import { NotificationSeverity } from '../../primitives';
 export declare const sDeviceCommandTriggered: z.ZodObject<{
     kind: z.ZodLiteral<"device-command">;
     userId: z.ZodOptional<z.ZodString>;
@@ -141,12 +141,12 @@ export declare const eventSchemaByKind: {
         requestId: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         kind: "nvr-export-started";
-        requestId: string;
         exportId: string;
+        requestId: string;
     }, {
         kind: "nvr-export-started";
-        requestId: string;
         exportId: string;
+        requestId: string;
     }>;
     'nvr-export-deleted': z.ZodObject<{
         kind: z.ZodLiteral<"nvr-export-deleted">;
@@ -188,22 +188,22 @@ export declare const eventSchemaByKind: {
         kind: "person-in";
         personId: string;
         securityChecked: boolean;
-        zoneId: string | null;
         personType: string;
         personFirstName: string;
         personLastName: string;
         personAvatarId: string | null;
         personPosition: string | null;
+        zoneId: string | null;
     }, {
         kind: "person-in";
         personId: string;
         securityChecked: boolean;
-        zoneId: string | null;
         personType: string;
         personFirstName: string;
         personLastName: string;
         personAvatarId: string | null;
         personPosition: string | null;
+        zoneId: string | null;
     }>;
     'person-out': z.ZodObject<{
         kind: z.ZodLiteral<"person-out">;
@@ -221,23 +221,23 @@ export declare const eventSchemaByKind: {
         personId: string;
         securityChecked: boolean;
         isLeave: boolean;
-        zoneId: string | null;
         personType: string;
         personFirstName: string;
         personLastName: string;
         personAvatarId: string | null;
         personPosition: string | null;
+        zoneId: string | null;
     }, {
         kind: "person-out";
         personId: string;
         securityChecked: boolean;
         isLeave: boolean;
-        zoneId: string | null;
         personType: string;
         personFirstName: string;
         personLastName: string;
         personAvatarId: string | null;
         personPosition: string | null;
+        zoneId: string | null;
     }>;
     'panic-button-pressed': z.ZodObject<{
         kind: z.ZodLiteral<"panic-button-pressed">;

package/dist/api/events/all.js

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+import { alarmEventSchemasByKind } from './alarm';
+import { cameraEventSchemasByKind } from './camera';
+import { doorEventSchemaByKind } from './door';
+import { intercomTerminalEventSchemaByKind, } from './intercom-terminal';
+import { ioBoardEventSchemaByKind } from './io-board';
+import { panicButtonEventSchemaByKind } from './panic-button';
+import { presenceTrackerEventSchemaByKind, } from './presence-tracker';
+import { readerEventSchemaByKind } from './reader';
+import { nvrExporterEventSchemasByKind, } from './nvr-exporter';
+export const sDeviceCommandTriggered = z.object({
+    kind: z.literal('device-command'),
+    userId: z.string().nonempty().optional(),
+    command: z.string().nonempty(),
+    args: z.record(z.unknown()),
+});
+export const sMotionDetected = z.object({
+    kind: z.literal('motion-detected'),
+});
+export const sDeviceConnectedEvent = z.object({
+    kind: z.literal('device-connected'),
+    clientId: z.number().int().positive().optional(),
+});
+export const sDeviceDisconnectedEvent = z.object({
+    kind: z.literal('device-disconnected'),
+    clientId: z.number().int().positive().optional(),
+});
+export const sEventHeader = z.object({
+    id: z.string().nonempty(),
+    timestamp: z.number().int().positive(),
+    deviceId: z.string().nonempty(),
+    observedBy: z.string().optional(),
+});
+export const eventKindLabels = {
+    'door-access': 'Door Access',
+    'door-force': 'Force-Opened',
+    'door-tamper': 'Tampered',
+    'door-left-open': 'Left Open',
+    'alarm-triggered': 'Alarm Triggered',
+    'alarm-acknowledged': 'Alarm Acknowledged',
+    'door-relock': 'Relocked',
+    'door-mains-failed': 'Mains Failed',
+    'door-acu-not-responding': 'ACU Not Responding',
+    'door-acu-online': 'ACU Online',
+    'door-mains-restored': 'Mains Restored',
+    'door-tamper-restored': 'Tamper Restored',
+    'motion-detected': 'Motion Detected',
+    'device-command': 'Device Command',
+    'reader-auth': 'Reader Authorized',
+    'alarm-arm-released': 'Alarm Arm Released',
+    'alarm-rearmed': 'Alarm Rearmed',
+    'alarm-armed': 'Alarm Armed',
+    'alarm-disarmed': 'Alarm Disarmed',
+    'alarm-armed-all': 'Alarm Armed All',
+    'alarm-disarmed-all': 'Alarm Disarmed All',
+    'panic-button-pressed': 'Panic Button Pressed',
+    'device-connected': 'Device Connected',
+    'device-disconnected': 'Device Disconnected',
+    'call-state-changed': 'Call State Changed',
+    'object-created': 'Object Created',
+    'object-updated': 'Object Updated',
+    'object-deleted': 'Object Deleted',
+    'ptz-preset-saved': 'PTZ Preset Saved on Device',
+    'person-in': 'Person Checked In',
+    'person-out': 'Person Checked Out',
+    'object-detection-started': 'Object Detection Started',
+    'object-detection-updated': 'Object Detection Updated',
+    'object-detection-ended': 'Object Detection Ended',
+    'scene-created': 'Scene Created',
+    'scene-updated': 'Scene Updated',
+    'scene-ended': 'Scene Ended',
+    'io-board-input-changed': 'IO Board Input Changed',
+    'agent-started': 'Agent Started',
+    'agent-stopped': 'Agent Stopped',
+    'door-opened': 'Door Opened',
+    'door-closed': 'Door Closed',
+    'nvr-export-started': 'NVR Export Started',
+    'nvr-export-deleted': 'NVR Export Deleted',
+    'notification-created': 'Notification Created',
+    'notification-acknowledged': 'Notification Acknowledged',
+};
+export const eventSchemaByKind = {
+    ...alarmEventSchemasByKind,
+    ...cameraEventSchemasByKind,
+    ...doorEventSchemaByKind,
+    ...intercomTerminalEventSchemaByKind,
+    ...ioBoardEventSchemaByKind,
+    ...panicButtonEventSchemaByKind,
+    ...presenceTrackerEventSchemaByKind,
+    ...readerEventSchemaByKind,
+    ...nvrExporterEventSchemasByKind,
+    'motion-detected': sMotionDetected,
+    'device-command': sDeviceCommandTriggered,
+    'device-connected': sDeviceConnectedEvent,
+    'device-disconnected': sDeviceDisconnectedEvent,
+};
+export const eventsByDeviceType = {
+    camera: [
+        ...Object.keys(cameraEventSchemasByKind),
+        'motion-detected',
+    ],
+    door: Object.keys(doorEventSchemaByKind),
+    'io-board': Object.keys(ioBoardEventSchemaByKind),
+    'panic-button': Object.keys(panicButtonEventSchemaByKind),
+    'presence-tracker': Object.keys(presenceTrackerEventSchemaByKind),
+    reader: Object.keys(readerEventSchemaByKind),
+    'motion-sensor': ['motion-detected'],
+    'nvr-exporter': Object.keys(nvrExporterEventSchemasByKind),
+};
+export const isDeviceEvent = (event) => {
+    if (typeof event !== 'object' || event === null)
+        return false;
+    if (!('kind' in event))
+        return false;
+    if (typeof event.kind !== 'string')
+        return false;
+    const schema = eventSchemaByKind[event.kind];
+    if (!schema)
+        return false;
+    const result = schema.safeParse(event);
+    if (!result.success)
+        return false;
+    return true;
+};

package/dist/api/events/camera.js

@@ -0,0 +1,84 @@
+import { sCameraPresetInfo } from '../../primitives';
+import { z } from 'zod';
+// EVENTS
+export const sCameraPtzPresetSaved = z.object({
+    kind: z.literal('ptz-preset-saved'),
+    presetId: z.string().nonempty(),
+    presetInfo: sCameraPresetInfo,
+    assignedRef: z.string().nullable(),
+});
+export const sBoxLocator = z.object({
+    locatorKind: z.literal('box'),
+    x1: z.number(),
+    y1: z.number(),
+    x2: z.number(),
+    y2: z.number(),
+});
+export const sObjectLocator = sBoxLocator;
+export const sObjectDetectionData = z
+    .object({
+    objectKind: z.string().nullable(),
+    probability: z.number(),
+    identifiedObjectId: z.string().nullable(),
+    frameTime: z.number(),
+    startTime: z.number(),
+    endTime: z.number().nullable(),
+})
+    .and(sObjectLocator);
+export const sObjectDetectionStarted = z
+    .object({
+    kind: z.literal('object-detection-started'),
+    providerAssignedRef: z.string().nonempty(),
+    detectionProvider: z.string().nonempty(),
+})
+    .and(sObjectDetectionData);
+export const sObjectDetectionUpdated = z
+    .object({
+    kind: z.literal('object-detection-updated'),
+    providerAssignedRef: z.string().nonempty(),
+    detectionProvider: z.string().nonempty(),
+})
+    .and(sObjectDetectionData);
+export const sObjectDetectionEnded = z
+    .object({
+    kind: z.literal('object-detection-ended'),
+    providerAssignedRef: z.string().nonempty(),
+    detectionProvider: z.string().nonempty(),
+})
+    .and(sObjectDetectionData);
+export const sSceneData = z.object({
+    detections: z.array(z.string()),
+    clipUrl: z.string().optional(),
+    startTime: z.number(),
+    endTime: z.number().nullable(),
+});
+export const sSceneCreated = z
+    .object({
+    kind: z.literal('scene-created'),
+    providerAssignedRef: z.string().nonempty(),
+    detectionProvider: z.string().nonempty(),
+})
+    .and(sSceneData);
+export const sSceneUpdated = z
+    .object({
+    kind: z.literal('scene-updated'),
+    providerAssignedRef: z.string().nonempty(),
+    detectionProvider: z.string().nonempty(),
+})
+    .and(sSceneData);
+export const sSceneEnded = z
+    .object({
+    kind: z.literal('scene-ended'),
+    providerAssignedRef: z.string().nonempty(),
+    detectionProvider: z.string().nonempty(),
+})
+    .and(sSceneData);
+export const cameraEventSchemasByKind = {
+    'ptz-preset-saved': sCameraPtzPresetSaved,
+    'object-detection-started': sObjectDetectionStarted,
+    'object-detection-updated': sObjectDetectionUpdated,
+    'object-detection-ended': sObjectDetectionEnded,
+    'scene-created': sSceneCreated,
+    'scene-updated': sSceneUpdated,
+    'scene-ended': sSceneEnded,
+};

package/dist/api/events/display.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+// EVENTS
+export const sDisplayUnitOfflineEvent = z.object({
+    kind: z.literal('display-unit-offline'),
+});
+//Could report on other events in the future like bad streams, high cpu usage, etc.

package/dist/api/events/door.js

@@ -0,0 +1,59 @@
+import { sCredentialType } from '../../objects/credential';
+import { z } from 'zod';
+// EVENTS
+export const sDoorAccessEvent = z.object({
+    kind: z.literal('door-access'),
+    personId: z.string().optional(),
+    token: z.string().nullable(),
+    tokenType: sCredentialType.nullable(),
+    allowed: z.boolean(),
+    doorExit: z.boolean(),
+    description: z.string(),
+});
+export const sDoorOpened = z.object({
+    kind: z.literal('door-opened'),
+});
+export const sDoorClosed = z.object({
+    kind: z.literal('door-closed'),
+});
+export const sDoorForceEvent = z.object({
+    kind: z.literal('door-force'),
+});
+export const sDoorTamperEvent = z.object({
+    kind: z.literal('door-tamper'),
+});
+export const sDoorLeftOpenEvent = z.object({
+    kind: z.literal('door-left-open'),
+});
+export const sDoorRelockEvent = z.object({
+    kind: z.literal('door-relock'),
+});
+export const sDoorMainsFailedEvent = z.object({
+    kind: z.literal('door-mains-failed'),
+});
+export const sDoorAcuNotRespondingEvent = z.object({
+    kind: z.literal('door-acu-not-responding'),
+});
+export const sDoorMainsRestoredEvent = z.object({
+    kind: z.literal('door-mains-restored'),
+});
+export const sDoorAcuOnlineEvent = z.object({
+    kind: z.literal('door-acu-online'),
+});
+export const sDoorTamperRestoredEvent = z.object({
+    kind: z.literal('door-tamper-restored'),
+});
+export const doorEventSchemaByKind = {
+    'door-access': sDoorAccessEvent,
+    'door-opened': sDoorOpened,
+    'door-closed': sDoorClosed,
+    'door-force': sDoorForceEvent,
+    'door-tamper': sDoorTamperEvent,
+    'door-left-open': sDoorLeftOpenEvent,
+    'door-relock': sDoorRelockEvent,
+    'door-mains-failed': sDoorMainsFailedEvent,
+    'door-acu-not-responding': sDoorAcuNotRespondingEvent,
+    'door-mains-restored': sDoorMainsRestoredEvent,
+    'door-acu-online': sDoorAcuOnlineEvent,
+    'door-tamper-restored': sDoorTamperRestoredEvent,
+};

package/dist/api/events/index.js

@@ -0,0 +1,12 @@
+export * from './camera';
+export * from './door';
+export * from './io-board';
+export * from './intercom-terminal';
+export * from './panic-button';
+export * from './server';
+export * from './reader';
+export * from './alarm';
+export * from './presence-tracker';
+export * from './display';
+export * from './nvr-exporter';
+export * from './all';

package/dist/api/events/intercom-terminal.js

@@ -0,0 +1,16 @@
+import { sCallDirection, sCallState } from '../../primitives';
+import { z } from 'zod';
+// EVENTS
+export const sCallStateChanged = z.object({
+    kind: z.literal('call-state-changed'),
+    userId: z.string().optional(),
+    callId: z.string().nonempty(),
+    state: sCallState,
+    peer: z.string().optional(),
+    sipAccount: z.string().optional(),
+    sipCallId: z.string().optional(),
+    direction: sCallDirection,
+});
+export const intercomTerminalEventSchemaByKind = {
+    'call-state-changed': sCallStateChanged,
+};