@awarevue/api-types 1.0.1

package/dist/device/camera.js

@@ -0,0 +1,120 @@
+"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 = exports.sCameraPresetInfo = exports.isPtzParams = exports.sCameraSpecs = exports.sStreamInfo = exports.sWebRtcPlaybackSource = exports.CAMERA = void 0;
+const zod_1 = require("zod");
+exports.CAMERA = 'camera';
+// SPECS
+exports.sWebRtcPlaybackSource = zod_1.z
+    .object({
+    kind: zod_1.z.string(),
+})
+    .and(zod_1.z.record(zod_1.z.unknown()));
+exports.sStreamInfo = zod_1.z.object({
+    id: zod_1.z.string().nonempty(),
+    displayName: zod_1.z.string().nonempty(),
+    externalPlayerUrl: zod_1.z.string().nullable(),
+});
+exports.sCameraSpecs = zod_1.z.object({
+    lensType: zod_1.z.enum(['flat', 'fisheye']),
+    mountPoint: zod_1.z.enum(['wall', 'ceiling', 'floor']),
+    ptzCapable: zod_1.z.boolean(),
+    ptzPanSpeed: zod_1.z.number(),
+    ptzTiltSpeed: zod_1.z.number(),
+    ptzZoomSpeed: zod_1.z.number(),
+    recordingCapable: zod_1.z.boolean(),
+    webrtcPlaybackSource: exports.sWebRtcPlaybackSource.nullable(),
+    streams: zod_1.z.array(exports.sStreamInfo),
+    defaultStreamId: zod_1.z.string().nonempty(),
+});
+const isPtzParams = (params) => typeof params.pan === 'number' &&
+    typeof params.tilt === 'number' &&
+    typeof params.zoom === 'number';
+exports.isPtzParams = isPtzParams;
+// COMMANDS
+exports.sCameraPresetInfo = zod_1.z.object({
+    name: zod_1.z.string().nonempty(),
+    isDefault: zod_1.z.boolean(),
+    values: zod_1.z.unknown(),
+});
+// EVENTS
+exports.sCameraPtzPresetSaved = zod_1.z.object({
+    kind: zod_1.z.literal('ptz-preset-saved'),
+    presetId: zod_1.z.string().nonempty(),
+    presetInfo: exports.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/device/device-gateway.d.ts

@@ -0,0 +1,3 @@
+export declare const DEVICE_GATEWAY = "device-gateway";
+export type DeviceGatewayCommand = never;
+export type DeviceGatewayEvent = never;

package/dist/device/device-gateway.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEVICE_GATEWAY = void 0;
+exports.DEVICE_GATEWAY = 'device-gateway';

package/dist/device/door.d.ts

@@ -0,0 +1,217 @@
+import { z } from 'zod';
+export declare const DOOR: "door";
+export declare const sDoorSpecs: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type DoorSpecs = z.infer<typeof sDoorSpecs>;
+export interface DoorUnlockCommand {
+    command: 'door.unlock';
+    params: object;
+}
+export interface DoorLockCommand {
+    command: 'door.lock';
+    params: object;
+}
+export interface DoorReleaseCommand {
+    command: 'door.release';
+    params: object;
+}
+export interface DoorAlarmAckCommand {
+    command: 'door.alarm-ack';
+    params: object;
+}
+export type DoorCommand = DoorUnlockCommand | DoorLockCommand | DoorReleaseCommand | DoorAlarmAckCommand;
+export interface DoorStateDto {
+    locked: boolean;
+    open: boolean;
+    alarmMode: boolean;
+    lastAlarmTimestamp: number;
+    connected: boolean;
+}
+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", "login-password"]>>;
+    allowed: z.ZodBoolean;
+    doorExit: z.ZodBoolean;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    kind: "door-access";
+    token: string | null;
+    tokenType: "card" | "pin" | "login-password" | null;
+    allowed: boolean;
+    doorExit: boolean;
+    personId?: string | undefined;
+}, {
+    description: string;
+    kind: "door-access";
+    token: string | null;
+    tokenType: "card" | "pin" | "login-password" | null;
+    allowed: boolean;
+    doorExit: boolean;
+    personId?: string | undefined;
+}>;
+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", "login-password"]>>;
+        allowed: z.ZodBoolean;
+        doorExit: z.ZodBoolean;
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        kind: "door-access";
+        token: string | null;
+        tokenType: "card" | "pin" | "login-password" | null;
+        allowed: boolean;
+        doorExit: boolean;
+        personId?: string | undefined;
+    }, {
+        description: string;
+        kind: "door-access";
+        token: string | null;
+        tokenType: "card" | "pin" | "login-password" | null;
+        allowed: boolean;
+        doorExit: boolean;
+        personId?: string | undefined;
+    }>;
+    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 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 | DoorForceEvent | DoorTamperEvent | DoorLeftOpenEvent | DoorRelockEvent | DoorMainsFailedEvent | DoorAcuNotRespondingEvent | DoorMainsRestoredEvent | DoorAcuOnlineEvent | DoorTamperRestoredEvent;

package/dist/device/door.js

@@ -0,0 +1,57 @@
+"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.sDoorAccessEvent = exports.sDoorSpecs = exports.DOOR = void 0;
+const access_control_1 = require("../access-control");
+const zod_1 = require("zod");
+exports.DOOR = 'door';
+// SPECS
+exports.sDoorSpecs = zod_1.z.object({});
+// 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.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-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/device/index.d.ts

@@ -0,0 +1,15 @@
+export * from './camera';
+export * from './door';
+export * from './any-device';
+export * from './reader/index';
+export * from './io-board';
+export * from './camera-lift';
+export * from './motion-sensor';
+export * from './intercom-operator';
+export * from './intercom-terminal';
+export * from './panic-button';
+export * from './pbx';
+export * from './server';
+export * from './alarm';
+export * from './device-gateway';
+export * from './presence-tracker';

package/dist/device/index.js

@@ -0,0 +1,31 @@
+"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("./any-device"), exports);
+__exportStar(require("./reader/index"), exports);
+__exportStar(require("./io-board"), exports);
+__exportStar(require("./camera-lift"), exports);
+__exportStar(require("./motion-sensor"), exports);
+__exportStar(require("./intercom-operator"), exports);
+__exportStar(require("./intercom-terminal"), exports);
+__exportStar(require("./panic-button"), exports);
+__exportStar(require("./pbx"), exports);
+__exportStar(require("./server"), exports);
+__exportStar(require("./alarm"), exports);
+__exportStar(require("./device-gateway"), exports);
+__exportStar(require("./presence-tracker"), exports);

package/dist/device/intercom-operator.d.ts

@@ -0,0 +1,13 @@
+export declare const INTERCOM_OPERATOR: "intercom-operator";
+export interface IntercomOperatorStateDto {
+    ringing: string[];
+    terminalByCalls: {
+        [callId: string]: string;
+    };
+    sdpByCalls: {
+        [callId: string]: string;
+    };
+    answererByCalls: {
+        [callId: string]: string;
+    };
+}

package/dist/device/intercom-operator.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTERCOM_OPERATOR = void 0;
+exports.INTERCOM_OPERATOR = 'intercom-operator';
+// EVENTS