@awarevue/api-types 2.0.13 → 2.0.15

package/dist/events/camera.js

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

package/dist/events/display.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const sDisplayUnitOfflineEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"display-unit-offline">;
+}, "strip", z.ZodTypeAny, {
+    kind: "display-unit-offline";
+}, {
+    kind: "display-unit-offline";
+}>;
+export type DisplayUnitOfflineEvent = z.infer<typeof sDisplayUnitOfflineEvent>;

package/dist/events/display.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sDisplayUnitOfflineEvent = void 0;
+const zod_1 = require("zod");
+// EVENTS
+exports.sDisplayUnitOfflineEvent = zod_1.z.object({
+    kind: zod_1.z.literal('display-unit-offline'),
+});
+//Could report on other events in the future like bad streams, high cpu usage, etc.

package/dist/events/door.d.ts

@@ -0,0 +1,220 @@
+import { z } from 'zod';
+export declare const sDoorAccessEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"door-access">;
+    personId: z.ZodOptional<z.ZodString>;
+    token: z.ZodNullable<z.ZodString>;
+    tokenType: z.ZodNullable<z.ZodEnum<["card", "pin", "fingerprint"]>>;
+    allowed: z.ZodBoolean;
+    doorExit: z.ZodBoolean;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    kind: "door-access";
+    token: string | null;
+    tokenType: "card" | "pin" | "fingerprint" | null;
+    allowed: boolean;
+    doorExit: boolean;
+    personId?: string | undefined;
+}, {
+    description: string;
+    kind: "door-access";
+    token: string | null;
+    tokenType: "card" | "pin" | "fingerprint" | null;
+    allowed: boolean;
+    doorExit: boolean;
+    personId?: string | undefined;
+}>;
+export declare const sDoorOpened: z.ZodObject<{
+    kind: z.ZodLiteral<"door-opened">;
+}, "strip", z.ZodTypeAny, {
+    kind: "door-opened";
+}, {
+    kind: "door-opened";
+}>;
+export declare const sDoorClosed: z.ZodObject<{
+    kind: z.ZodLiteral<"door-closed">;
+}, "strip", z.ZodTypeAny, {
+    kind: "door-closed";
+}, {
+    kind: "door-closed";
+}>;
+export declare const sDoorForceEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"door-force">;
+}, "strip", z.ZodTypeAny, {
+    kind: "door-force";
+}, {
+    kind: "door-force";
+}>;
+export declare const sDoorTamperEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"door-tamper">;
+}, "strip", z.ZodTypeAny, {
+    kind: "door-tamper";
+}, {
+    kind: "door-tamper";
+}>;
+export declare const sDoorLeftOpenEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"door-left-open">;
+}, "strip", z.ZodTypeAny, {
+    kind: "door-left-open";
+}, {
+    kind: "door-left-open";
+}>;
+export declare const sDoorRelockEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"door-relock">;
+}, "strip", z.ZodTypeAny, {
+    kind: "door-relock";
+}, {
+    kind: "door-relock";
+}>;
+export declare const sDoorMainsFailedEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"door-mains-failed">;
+}, "strip", z.ZodTypeAny, {
+    kind: "door-mains-failed";
+}, {
+    kind: "door-mains-failed";
+}>;
+export declare const sDoorAcuNotRespondingEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"door-acu-not-responding">;
+}, "strip", z.ZodTypeAny, {
+    kind: "door-acu-not-responding";
+}, {
+    kind: "door-acu-not-responding";
+}>;
+export declare const sDoorMainsRestoredEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"door-mains-restored">;
+}, "strip", z.ZodTypeAny, {
+    kind: "door-mains-restored";
+}, {
+    kind: "door-mains-restored";
+}>;
+export declare const sDoorAcuOnlineEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"door-acu-online">;
+}, "strip", z.ZodTypeAny, {
+    kind: "door-acu-online";
+}, {
+    kind: "door-acu-online";
+}>;
+export declare const sDoorTamperRestoredEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"door-tamper-restored">;
+}, "strip", z.ZodTypeAny, {
+    kind: "door-tamper-restored";
+}, {
+    kind: "door-tamper-restored";
+}>;
+export declare const doorEventSchemaByKind: {
+    readonly 'door-access': z.ZodObject<{
+        kind: z.ZodLiteral<"door-access">;
+        personId: z.ZodOptional<z.ZodString>;
+        token: z.ZodNullable<z.ZodString>;
+        tokenType: z.ZodNullable<z.ZodEnum<["card", "pin", "fingerprint"]>>;
+        allowed: z.ZodBoolean;
+        doorExit: z.ZodBoolean;
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        kind: "door-access";
+        token: string | null;
+        tokenType: "card" | "pin" | "fingerprint" | null;
+        allowed: boolean;
+        doorExit: boolean;
+        personId?: string | undefined;
+    }, {
+        description: string;
+        kind: "door-access";
+        token: string | null;
+        tokenType: "card" | "pin" | "fingerprint" | null;
+        allowed: boolean;
+        doorExit: boolean;
+        personId?: string | undefined;
+    }>;
+    readonly 'door-opened': z.ZodObject<{
+        kind: z.ZodLiteral<"door-opened">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "door-opened";
+    }, {
+        kind: "door-opened";
+    }>;
+    readonly 'door-closed': z.ZodObject<{
+        kind: z.ZodLiteral<"door-closed">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "door-closed";
+    }, {
+        kind: "door-closed";
+    }>;
+    readonly 'door-force': z.ZodObject<{
+        kind: z.ZodLiteral<"door-force">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "door-force";
+    }, {
+        kind: "door-force";
+    }>;
+    readonly 'door-tamper': z.ZodObject<{
+        kind: z.ZodLiteral<"door-tamper">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "door-tamper";
+    }, {
+        kind: "door-tamper";
+    }>;
+    readonly 'door-left-open': z.ZodObject<{
+        kind: z.ZodLiteral<"door-left-open">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "door-left-open";
+    }, {
+        kind: "door-left-open";
+    }>;
+    readonly 'door-relock': z.ZodObject<{
+        kind: z.ZodLiteral<"door-relock">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "door-relock";
+    }, {
+        kind: "door-relock";
+    }>;
+    readonly 'door-mains-failed': z.ZodObject<{
+        kind: z.ZodLiteral<"door-mains-failed">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "door-mains-failed";
+    }, {
+        kind: "door-mains-failed";
+    }>;
+    readonly 'door-acu-not-responding': z.ZodObject<{
+        kind: z.ZodLiteral<"door-acu-not-responding">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "door-acu-not-responding";
+    }, {
+        kind: "door-acu-not-responding";
+    }>;
+    readonly 'door-mains-restored': z.ZodObject<{
+        kind: z.ZodLiteral<"door-mains-restored">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "door-mains-restored";
+    }, {
+        kind: "door-mains-restored";
+    }>;
+    readonly 'door-acu-online': z.ZodObject<{
+        kind: z.ZodLiteral<"door-acu-online">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "door-acu-online";
+    }, {
+        kind: "door-acu-online";
+    }>;
+    readonly 'door-tamper-restored': z.ZodObject<{
+        kind: z.ZodLiteral<"door-tamper-restored">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "door-tamper-restored";
+    }, {
+        kind: "door-tamper-restored";
+    }>;
+};
+export type DoorAccessEvent = z.infer<typeof sDoorAccessEvent>;
+export type DoorOpenedEvent = z.infer<typeof sDoorOpened>;
+export type DoorClosedEvent = z.infer<typeof sDoorClosed>;
+export type DoorForceEvent = z.infer<typeof sDoorForceEvent>;
+export type DoorTamperEvent = z.infer<typeof sDoorTamperEvent>;
+export type DoorLeftOpenEvent = z.infer<typeof sDoorLeftOpenEvent>;
+export type DoorRelockEvent = z.infer<typeof sDoorRelockEvent>;
+export type DoorMainsFailedEvent = z.infer<typeof sDoorMainsFailedEvent>;
+export type DoorAcuNotRespondingEvent = z.infer<typeof sDoorAcuNotRespondingEvent>;
+export type DoorMainsRestoredEvent = z.infer<typeof sDoorMainsRestoredEvent>;
+export type DoorAcuOnlineEvent = z.infer<typeof sDoorAcuOnlineEvent>;
+export type DoorTamperRestoredEvent = z.infer<typeof sDoorTamperRestoredEvent>;
+export type DoorEvent = DoorAccessEvent | DoorOpenedEvent | DoorClosedEvent | DoorForceEvent | DoorTamperEvent | DoorLeftOpenEvent | DoorRelockEvent | DoorMainsFailedEvent | DoorAcuNotRespondingEvent | DoorMainsRestoredEvent | DoorAcuOnlineEvent | DoorTamperRestoredEvent;

package/dist/events/door.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doorEventSchemaByKind = exports.sDoorTamperRestoredEvent = exports.sDoorAcuOnlineEvent = exports.sDoorMainsRestoredEvent = exports.sDoorAcuNotRespondingEvent = exports.sDoorMainsFailedEvent = exports.sDoorRelockEvent = exports.sDoorLeftOpenEvent = exports.sDoorTamperEvent = exports.sDoorForceEvent = exports.sDoorClosed = exports.sDoorOpened = exports.sDoorAccessEvent = void 0;
+const access_control_1 = require("../access-control");
+const zod_1 = require("zod");
+// EVENTS
+exports.sDoorAccessEvent = zod_1.z.object({
+    kind: zod_1.z.literal('door-access'),
+    personId: zod_1.z.string().optional(),
+    token: zod_1.z.string().nullable(),
+    tokenType: access_control_1.sCredentialType.nullable(),
+    allowed: zod_1.z.boolean(),
+    doorExit: zod_1.z.boolean(),
+    description: zod_1.z.string(),
+});
+exports.sDoorOpened = zod_1.z.object({
+    kind: zod_1.z.literal('door-opened'),
+});
+exports.sDoorClosed = zod_1.z.object({
+    kind: zod_1.z.literal('door-closed'),
+});
+exports.sDoorForceEvent = zod_1.z.object({
+    kind: zod_1.z.literal('door-force'),
+});
+exports.sDoorTamperEvent = zod_1.z.object({
+    kind: zod_1.z.literal('door-tamper'),
+});
+exports.sDoorLeftOpenEvent = zod_1.z.object({
+    kind: zod_1.z.literal('door-left-open'),
+});
+exports.sDoorRelockEvent = zod_1.z.object({
+    kind: zod_1.z.literal('door-relock'),
+});
+exports.sDoorMainsFailedEvent = zod_1.z.object({
+    kind: zod_1.z.literal('door-mains-failed'),
+});
+exports.sDoorAcuNotRespondingEvent = zod_1.z.object({
+    kind: zod_1.z.literal('door-acu-not-responding'),
+});
+exports.sDoorMainsRestoredEvent = zod_1.z.object({
+    kind: zod_1.z.literal('door-mains-restored'),
+});
+exports.sDoorAcuOnlineEvent = zod_1.z.object({
+    kind: zod_1.z.literal('door-acu-online'),
+});
+exports.sDoorTamperRestoredEvent = zod_1.z.object({
+    kind: zod_1.z.literal('door-tamper-restored'),
+});
+exports.doorEventSchemaByKind = {
+    'door-access': exports.sDoorAccessEvent,
+    'door-opened': exports.sDoorOpened,
+    'door-closed': exports.sDoorClosed,
+    'door-force': exports.sDoorForceEvent,
+    'door-tamper': exports.sDoorTamperEvent,
+    'door-left-open': exports.sDoorLeftOpenEvent,
+    'door-relock': exports.sDoorRelockEvent,
+    'door-mains-failed': exports.sDoorMainsFailedEvent,
+    'door-acu-not-responding': exports.sDoorAcuNotRespondingEvent,
+    'door-mains-restored': exports.sDoorMainsRestoredEvent,
+    'door-acu-online': exports.sDoorAcuOnlineEvent,
+    'door-tamper-restored': exports.sDoorTamperRestoredEvent,
+};

package/dist/events/index.d.ts

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

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./camera"), exports);
+__exportStar(require("./door"), exports);
+__exportStar(require("./io-board"), exports);
+__exportStar(require("./intercom-terminal"), exports);
+__exportStar(require("./panic-button"), exports);
+__exportStar(require("./server"), exports);
+__exportStar(require("./reader"), exports);
+__exportStar(require("./alarm"), exports);
+__exportStar(require("./presence-tracker"), exports);
+__exportStar(require("./display"), exports);
+__exportStar(require("./nvr-exporter"), exports);
+__exportStar(require("./all"), exports);

package/dist/events/intercom-terminal.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+export declare const sCallStateChanged: z.ZodObject<{
+    kind: z.ZodLiteral<"call-state-changed">;
+    userId: z.ZodOptional<z.ZodString>;
+    callId: z.ZodString;
+    state: z.ZodEnum<["connecting", "connected", "ringing", "terminated"]>;
+    peer: z.ZodOptional<z.ZodString>;
+    sipAccount: z.ZodOptional<z.ZodString>;
+    sipCallId: z.ZodOptional<z.ZodString>;
+    direction: z.ZodEnum<["incoming", "outgoing"]>;
+}, "strip", z.ZodTypeAny, {
+    state: "connected" | "connecting" | "ringing" | "terminated";
+    direction: "incoming" | "outgoing";
+    kind: "call-state-changed";
+    callId: string;
+    peer?: string | undefined;
+    userId?: string | undefined;
+    sipAccount?: string | undefined;
+    sipCallId?: string | undefined;
+}, {
+    state: "connected" | "connecting" | "ringing" | "terminated";
+    direction: "incoming" | "outgoing";
+    kind: "call-state-changed";
+    callId: string;
+    peer?: string | undefined;
+    userId?: string | undefined;
+    sipAccount?: string | undefined;
+    sipCallId?: string | undefined;
+}>;
+export declare const intercomTerminalEventSchemaByKind: {
+    'call-state-changed': z.ZodObject<{
+        kind: z.ZodLiteral<"call-state-changed">;
+        userId: z.ZodOptional<z.ZodString>;
+        callId: z.ZodString;
+        state: z.ZodEnum<["connecting", "connected", "ringing", "terminated"]>;
+        peer: z.ZodOptional<z.ZodString>;
+        sipAccount: z.ZodOptional<z.ZodString>;
+        sipCallId: z.ZodOptional<z.ZodString>;
+        direction: z.ZodEnum<["incoming", "outgoing"]>;
+    }, "strip", z.ZodTypeAny, {
+        state: "connected" | "connecting" | "ringing" | "terminated";
+        direction: "incoming" | "outgoing";
+        kind: "call-state-changed";
+        callId: string;
+        peer?: string | undefined;
+        userId?: string | undefined;
+        sipAccount?: string | undefined;
+        sipCallId?: string | undefined;
+    }, {
+        state: "connected" | "connecting" | "ringing" | "terminated";
+        direction: "incoming" | "outgoing";
+        kind: "call-state-changed";
+        callId: string;
+        peer?: string | undefined;
+        userId?: string | undefined;
+        sipAccount?: string | undefined;
+        sipCallId?: string | undefined;
+    }>;
+};
+export type CallStateChangedEvent = z.infer<typeof sCallStateChanged>;
+export type IntercomTerminalEvent = CallStateChangedEvent;

package/dist/events/intercom-terminal.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intercomTerminalEventSchemaByKind = exports.sCallStateChanged = void 0;
+const primitives_1 = require("../primitives");
+const zod_1 = require("zod");
+// EVENTS
+exports.sCallStateChanged = zod_1.z.object({
+    kind: zod_1.z.literal('call-state-changed'),
+    userId: zod_1.z.string().optional(),
+    callId: zod_1.z.string().nonempty(),
+    state: primitives_1.sCallState,
+    peer: zod_1.z.string().optional(),
+    sipAccount: zod_1.z.string().optional(),
+    sipCallId: zod_1.z.string().optional(),
+    direction: primitives_1.sCallDirection,
+});
+exports.intercomTerminalEventSchemaByKind = {
+    'call-state-changed': exports.sCallStateChanged,
+};

package/dist/events/io-board.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export declare const sIoBoardInputChangedEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"io-board-input-changed">;
+    inputName: z.ZodString;
+    value: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    value: boolean;
+    kind: "io-board-input-changed";
+    inputName: string;
+}, {
+    value: boolean;
+    kind: "io-board-input-changed";
+    inputName: string;
+}>;
+export declare const ioBoardEventSchemaByKind: {
+    readonly 'io-board-input-changed': z.ZodObject<{
+        kind: z.ZodLiteral<"io-board-input-changed">;
+        inputName: z.ZodString;
+        value: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        value: boolean;
+        kind: "io-board-input-changed";
+        inputName: string;
+    }, {
+        value: boolean;
+        kind: "io-board-input-changed";
+        inputName: string;
+    }>;
+};
+export type IoBoardInputChangedEvent = z.infer<typeof sIoBoardInputChangedEvent>;
+export type IoBoardEvent = IoBoardInputChangedEvent;

package/dist/events/io-board.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ioBoardEventSchemaByKind = exports.sIoBoardInputChangedEvent = void 0;
+const zod_1 = require("zod");
+// EVENTS
+exports.sIoBoardInputChangedEvent = zod_1.z.object({
+    kind: zod_1.z.literal('io-board-input-changed'),
+    inputName: zod_1.z.string().nonempty(),
+    value: zod_1.z.boolean(),
+});
+exports.ioBoardEventSchemaByKind = {
+    'io-board-input-changed': exports.sIoBoardInputChangedEvent,
+};

package/dist/events/nvr-exporter.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+export declare const sExportStarted: z.ZodObject<{
+    kind: z.ZodLiteral<"nvr-export-started">;
+    exportId: z.ZodString;
+    requestId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "nvr-export-started";
+    requestId: string;
+    exportId: string;
+}, {
+    kind: "nvr-export-started";
+    requestId: string;
+    exportId: string;
+}>;
+export type ExportStarted = z.infer<typeof sExportStarted>;
+export declare const sExportDeleted: z.ZodObject<{
+    kind: z.ZodLiteral<"nvr-export-deleted">;
+    exportId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "nvr-export-deleted";
+    exportId: string;
+}, {
+    kind: "nvr-export-deleted";
+    exportId: string;
+}>;
+export type ExportDeleted = z.infer<typeof sExportDeleted>;
+export type NvrExporterEvent = ExportStarted | ExportDeleted;
+export declare const nvrExporterEventSchemasByKind: {
+    readonly 'nvr-export-started': z.ZodObject<{
+        kind: z.ZodLiteral<"nvr-export-started">;
+        exportId: z.ZodString;
+        requestId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "nvr-export-started";
+        requestId: string;
+        exportId: string;
+    }, {
+        kind: "nvr-export-started";
+        requestId: string;
+        exportId: string;
+    }>;
+    readonly 'nvr-export-deleted': z.ZodObject<{
+        kind: z.ZodLiteral<"nvr-export-deleted">;
+        exportId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "nvr-export-deleted";
+        exportId: string;
+    }, {
+        kind: "nvr-export-deleted";
+        exportId: string;
+    }>;
+};

package/dist/events/nvr-exporter.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nvrExporterEventSchemasByKind = exports.sExportDeleted = exports.sExportStarted = void 0;
+const zod_1 = require("zod");
+// EVENTS
+exports.sExportStarted = zod_1.z.object({
+    kind: zod_1.z.literal('nvr-export-started'),
+    exportId: zod_1.z
+        .string()
+        .nonempty()
+        .describe('The ID of the export, will be used to reference the export in future commands and queries'),
+    requestId: zod_1.z.string().nonempty(),
+});
+exports.sExportDeleted = zod_1.z.object({
+    kind: zod_1.z.literal('nvr-export-deleted'),
+    exportId: zod_1.z.string().nonempty(),
+});
+exports.nvrExporterEventSchemasByKind = {
+    'nvr-export-started': exports.sExportStarted,
+    'nvr-export-deleted': exports.sExportDeleted,
+};

package/dist/events/panic-button.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const sPanicButtonPressedEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"panic-button-pressed">;
+}, "strip", z.ZodTypeAny, {
+    kind: "panic-button-pressed";
+}, {
+    kind: "panic-button-pressed";
+}>;
+export declare const panicButtonEventSchemaByKind: {
+    readonly 'panic-button-pressed': z.ZodObject<{
+        kind: z.ZodLiteral<"panic-button-pressed">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "panic-button-pressed";
+    }, {
+        kind: "panic-button-pressed";
+    }>;
+};
+export type PanicButtonPressedEvent = z.infer<typeof sPanicButtonPressedEvent>;
+export type PanicButtonEvent = PanicButtonPressedEvent;

package/dist/events/panic-button.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.panicButtonEventSchemaByKind = exports.sPanicButtonPressedEvent = void 0;
+const zod_1 = require("zod");
+// EVENTS
+exports.sPanicButtonPressedEvent = zod_1.z.object({
+    kind: zod_1.z.literal('panic-button-pressed'),
+});
+exports.panicButtonEventSchemaByKind = {
+    'panic-button-pressed': exports.sPanicButtonPressedEvent,
+};