@awarevue/api-types 1.0.1

package/dist/messages/device-communication.d.ts

@@ -0,0 +1,121 @@
+import z from 'zod';
+import { CommandRun } from '../device-command';
+import { DeviceEvent } from '../device-event';
+import { WebSocketMessage } from './web-socket';
+export type CommandRunPayload = CommandRun;
+export declare const sCommandSuccess: z.ZodObject<{
+    timestamp: z.ZodNumber;
+    requestId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    timestamp: number;
+    requestId: string;
+}, {
+    timestamp: number;
+    requestId: string;
+}>;
+export type CommandSuccessPayload = z.infer<typeof sCommandSuccess>;
+export declare const sCommandError: z.ZodObject<{
+    timestamp: z.ZodNumber;
+    requestId: z.ZodString;
+    error: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    error: {};
+    timestamp: number;
+    requestId: string;
+}, {
+    error: {};
+    timestamp: number;
+    requestId: string;
+}>;
+export type CommandErrorPayload = z.infer<typeof sCommandError>;
+export declare const sStateUpdate: z.ZodObject<{
+    timestamp: z.ZodNumber;
+    deviceId: z.ZodString;
+    state: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    state: {};
+    deviceId: string;
+    timestamp: number;
+}, {
+    state: {};
+    deviceId: string;
+    timestamp: number;
+}>;
+export type StateUpdatePayload = z.infer<typeof sStateUpdate>;
+export declare const sStateUnavailable: z.ZodObject<{
+    timestamp: z.ZodNumber;
+    deviceId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    deviceId: string;
+    timestamp: number;
+}, {
+    deviceId: string;
+    timestamp: number;
+}>;
+export type StateUnavailablePayload = z.infer<typeof sStateUnavailable>;
+export declare const sStateUpdateError: z.ZodObject<{
+    timestamp: z.ZodNumber;
+    deviceId: z.ZodString;
+    error: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    error: {};
+    deviceId: string;
+    timestamp: number;
+}, {
+    error: {};
+    deviceId: string;
+    timestamp: number;
+}>;
+export type StateUpdateErrorPayload = z.infer<typeof sStateUpdateError>;
+export declare const sStateSubscribe: z.ZodObject<{
+    timestamp: z.ZodNumber;
+    requestId: z.ZodString;
+    deviceId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    deviceId: string;
+    timestamp: number;
+    requestId: string;
+}, {
+    deviceId: string;
+    timestamp: number;
+    requestId: string;
+}>;
+export type StateSubscribePayload = z.infer<typeof sStateSubscribe>;
+export declare const sStateUnsubscribe: z.ZodObject<{
+    timestamp: z.ZodNumber;
+    requestId: z.ZodString;
+    deviceId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    deviceId: string;
+    timestamp: number;
+    requestId: string;
+}, {
+    deviceId: string;
+    timestamp: number;
+    requestId: string;
+}>;
+export type StateUnsubscribePayload = z.infer<typeof sStateUnsubscribe>;
+export type DeviceEventPayload = DeviceEvent;
+interface DeviceMessageMap {
+    'command-run': CommandRunPayload;
+    'command-success': CommandSuccessPayload;
+    'command-error': CommandErrorPayload;
+    'state-update': StateUpdatePayload;
+    'state-unavailable': StateUnavailablePayload;
+    'state-update-error': StateUpdateErrorPayload;
+    'state-subscribe': StateSubscribePayload;
+    'state-unsubscribe': StateUnsubscribePayload;
+    'device-event': DeviceEventPayload;
+}
+export type DeviceWsMessage = {
+    [K in keyof DeviceMessageMap]: {
+        event: K;
+        data: DeviceMessageMap[K];
+    };
+}[keyof DeviceMessageMap];
+export declare const isDeviceMessage: (message: WebSocketMessage) => message is DeviceWsMessage;
+export declare const isDeviceEventMessage: (message: DeviceWsMessage) => message is {
+    event: "device-event";
+    data: DeviceEventPayload;
+};
+export {};

package/dist/messages/device-communication.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDeviceEventMessage = exports.isDeviceMessage = exports.sStateUnsubscribe = exports.sStateSubscribe = exports.sStateUpdateError = exports.sStateUnavailable = exports.sStateUpdate = exports.sCommandError = exports.sCommandSuccess = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.sCommandSuccess = zod_1.default.object({
+    timestamp: zod_1.default.number(),
+    requestId: zod_1.default.string(),
+});
+exports.sCommandError = zod_1.default.object({
+    timestamp: zod_1.default.number(),
+    requestId: zod_1.default.string(),
+    error: zod_1.default.object({}),
+});
+exports.sStateUpdate = zod_1.default.object({
+    timestamp: zod_1.default.number(),
+    deviceId: zod_1.default.string(),
+    state: zod_1.default.object({}),
+});
+exports.sStateUnavailable = zod_1.default.object({
+    timestamp: zod_1.default.number(),
+    deviceId: zod_1.default.string(),
+});
+exports.sStateUpdateError = zod_1.default.object({
+    timestamp: zod_1.default.number(),
+    deviceId: zod_1.default.string(),
+    error: zod_1.default.object({}),
+});
+exports.sStateSubscribe = zod_1.default.object({
+    timestamp: zod_1.default.number(),
+    requestId: zod_1.default.string(),
+    deviceId: zod_1.default.string(),
+});
+exports.sStateUnsubscribe = zod_1.default.object({
+    timestamp: zod_1.default.number(),
+    requestId: zod_1.default.string(),
+    deviceId: zod_1.default.string(),
+});
+const validators = {
+    'command-run': zod_1.default.object({}),
+    'command-success': exports.sCommandSuccess,
+    'command-error': exports.sCommandError,
+    'state-update': exports.sStateUpdate,
+    'state-unavailable': exports.sStateUnavailable,
+    'state-update-error': exports.sStateUpdateError,
+    'state-subscribe': exports.sStateSubscribe,
+    'state-unsubscribe': exports.sStateUnsubscribe,
+    'device-event': zod_1.default.object({}),
+};
+const isDeviceMessage = (message) => {
+    const validator = validators[message.event];
+    if (!validator) {
+        return false;
+    }
+    return validator.safeParse(message.data).success;
+};
+exports.isDeviceMessage = isDeviceMessage;
+const isDeviceEventMessage = (message) => {
+    return message.event === 'device-event';
+};
+exports.isDeviceEventMessage = isDeviceEventMessage;

package/dist/messages/index.d.ts

@@ -0,0 +1,5 @@
+export * from './device-communication';
+export * from './web-socket';
+export * from './progress';
+export * from './web-rtc-signaling';
+export * from './provider-api';

package/dist/messages/index.js

@@ -0,0 +1,21 @@
+"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("./device-communication"), exports);
+__exportStar(require("./web-socket"), exports);
+__exportStar(require("./progress"), exports);
+__exportStar(require("./web-rtc-signaling"), exports);
+__exportStar(require("./provider-api"), exports);

package/dist/messages/progress.d.ts

@@ -0,0 +1,118 @@
+import z from 'zod';
+import { WebSocketMessage } from './web-socket';
+export declare const sProgress: z.ZodObject<{
+    total: z.ZodOptional<z.ZodNumber>;
+    complete: z.ZodOptional<z.ZodNumber>;
+    failed: z.ZodDefault<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+}, "strip", z.ZodTypeAny, {
+    failed: {};
+    total?: number | undefined;
+    complete?: number | undefined;
+}, {
+    total?: number | undefined;
+    failed?: {} | undefined;
+    complete?: number | undefined;
+}>;
+export type ProgressReport = z.infer<typeof sProgress>;
+export declare const sProgressUpdate: z.ZodObject<{
+    timestamp: z.ZodNumber;
+    item: z.ZodString;
+    progress: z.ZodObject<{
+        total: z.ZodOptional<z.ZodNumber>;
+        complete: z.ZodOptional<z.ZodNumber>;
+        failed: z.ZodDefault<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+    }, "strip", z.ZodTypeAny, {
+        failed: {};
+        total?: number | undefined;
+        complete?: number | undefined;
+    }, {
+        total?: number | undefined;
+        failed?: {} | undefined;
+        complete?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    progress: {
+        failed: {};
+        total?: number | undefined;
+        complete?: number | undefined;
+    };
+    item: string;
+    timestamp: number;
+}, {
+    progress: {
+        total?: number | undefined;
+        failed?: {} | undefined;
+        complete?: number | undefined;
+    };
+    item: string;
+    timestamp: number;
+}>;
+export type ProgressUpdatePayload = z.infer<typeof sProgressUpdate>;
+export declare const sProgressUnavailable: z.ZodObject<{
+    timestamp: z.ZodNumber;
+    item: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    item: string;
+    timestamp: number;
+}, {
+    item: string;
+    timestamp: number;
+}>;
+export type ProgressUnavailablePayload = z.infer<typeof sProgressUnavailable>;
+export declare const sProgressUpdateError: z.ZodObject<{
+    timestamp: z.ZodNumber;
+    item: z.ZodString;
+    error: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    error: {};
+    item: string;
+    timestamp: number;
+}, {
+    error: {};
+    item: string;
+    timestamp: number;
+}>;
+export type ProgressUpdateErrorPayload = z.infer<typeof sProgressUpdateError>;
+export declare const sProgressSubscribe: z.ZodObject<{
+    timestamp: z.ZodNumber;
+    requestId: z.ZodString;
+    item: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    item: string;
+    timestamp: number;
+    requestId: string;
+}, {
+    item: string;
+    timestamp: number;
+    requestId: string;
+}>;
+export type ProgressSubscribePayload = z.infer<typeof sProgressSubscribe>;
+export declare const sProgressUnsubscribe: z.ZodObject<{
+    timestamp: z.ZodNumber;
+    requestId: z.ZodString;
+    item: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    item: string;
+    timestamp: number;
+    requestId: string;
+}, {
+    item: string;
+    timestamp: number;
+    requestId: string;
+}>;
+export type ProgressUnsubscribePayload = z.infer<typeof sProgressUnsubscribe>;
+interface ProgressMessageMap {
+    'progress-update': ProgressUpdatePayload;
+    'progress-unavailable': ProgressUnavailablePayload;
+    'progress-update-error': ProgressUpdateErrorPayload;
+    'progress-subscribe': ProgressSubscribePayload;
+    'progress-unsubscribe': ProgressUnsubscribePayload;
+}
+export type ProgressWsMessage = {
+    [K in keyof ProgressMessageMap]: {
+        event: K;
+        data: ProgressMessageMap[K];
+    };
+}[keyof ProgressMessageMap];
+export declare const isProgressMessage: (message: WebSocketMessage) => message is ProgressWsMessage;
+export {};

package/dist/messages/progress.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProgressMessage = exports.sProgressUnsubscribe = exports.sProgressSubscribe = exports.sProgressUpdateError = exports.sProgressUnavailable = exports.sProgressUpdate = exports.sProgress = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.sProgress = zod_1.default.object({
+    total: zod_1.default.number().optional(),
+    complete: zod_1.default.number().optional(),
+    failed: zod_1.default.object({}).default({}),
+});
+exports.sProgressUpdate = zod_1.default.object({
+    timestamp: zod_1.default.number(),
+    item: zod_1.default.string(),
+    progress: exports.sProgress,
+});
+exports.sProgressUnavailable = zod_1.default.object({
+    timestamp: zod_1.default.number(),
+    item: zod_1.default.string(),
+});
+exports.sProgressUpdateError = zod_1.default.object({
+    timestamp: zod_1.default.number(),
+    item: zod_1.default.string(),
+    error: zod_1.default.object({}),
+});
+exports.sProgressSubscribe = zod_1.default.object({
+    timestamp: zod_1.default.number(),
+    requestId: zod_1.default.string(),
+    item: zod_1.default.string(),
+});
+exports.sProgressUnsubscribe = zod_1.default.object({
+    timestamp: zod_1.default.number(),
+    requestId: zod_1.default.string(),
+    item: zod_1.default.string(),
+});
+const validators = {
+    'progress-update': exports.sProgressUpdate,
+    'progress-unavailable': exports.sProgressUnavailable,
+    'progress-update-error': exports.sProgressUpdateError,
+    'progress-subscribe': exports.sProgressSubscribe,
+    'progress-unsubscribe': exports.sProgressUnsubscribe,
+};
+const isProgressMessage = (message) => {
+    const validator = validators[message.event];
+    if (!validator) {
+        return false;
+    }
+    return validator.safeParse(message.data).success;
+};
+exports.isProgressMessage = isProgressMessage;

package/dist/messages/provider-api/index.d.ts

@@ -0,0 +1 @@
+export * from './sync-protocol';

package/dist/messages/provider-api/index.js

@@ -0,0 +1,17 @@
+"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("./sync-protocol"), exports);

package/dist/messages/provider-api/sync-protocol.d.ts

@@ -0,0 +1,83 @@
+import { DeviceDto, ObjectKinds } from '../../device';
+import { PersonDto, ScheduleDto, ZoneDto } from '../../access-control';
+export type SyncContext = {
+    objectVersion: number;
+    objectKind: keyof AccessObjects;
+    objectId: string;
+    originator: string;
+};
+export type AccessObjects = {
+    person: PersonDto;
+    device: DeviceDto;
+    schedule: ScheduleDto;
+    zone: ZoneDto;
+};
+export type MappedReference = {
+    kind: keyof ObjectKinds;
+    localId: string;
+    remoteId: string;
+    provider: string;
+};
+export interface SyncActionComplete {
+    kind: 'sync-action-complete';
+    provider: string;
+    actionId: string;
+    refs: MappedReference[];
+}
+export interface SyncActionFailed {
+    kind: 'sync-action-failed';
+    provider: string;
+    actionId: string;
+    code?: string;
+    errorMessage: string;
+}
+export type SyncMergeObject = {
+    [K in keyof AccessObjects]: {
+        objectKind: K;
+        data: AccessObjects[K];
+        syncContext: SyncContext;
+        kind: 'update-object';
+    };
+}[keyof AccessObjects];
+export type SyncDeleteObject = {
+    [K in keyof AccessObjects]: {
+        objectKind: K;
+        data: AccessObjects[K];
+        syncContext: SyncContext;
+        kind: 'delete-object';
+    };
+}[keyof AccessObjects];
+export interface SyncPersonAcl {
+    kind: 'person-acl-update';
+    syncContext: SyncContext;
+    person: string;
+    deviceSchedules: Record<string, string | null>;
+}
+export interface SyncDeviceAcl {
+    kind: 'device-acl-update';
+    syncContext: SyncContext;
+    device: string;
+    personSchedules: Record<string, string | null>;
+}
+export type SyncAction = {
+    id: string;
+    details: unknown;
+};
+export type CreateSyncBatch = {
+    kind: 'create-sync-batch';
+    provider: string;
+    syncContext: SyncContext;
+    actions: unknown[];
+};
+export interface SyncBatchDue {
+    kind: 'sync-batch-due';
+    provider: string;
+    actions: SyncAction[];
+}
+export interface SyncActionDue {
+    kind: 'sync-action-due';
+    provider: string;
+    id: string;
+    details: unknown;
+}
+export type SyncMessage = SyncActionComplete | SyncActionFailed | SyncMergeObject | SyncDeleteObject | SyncPersonAcl | SyncDeviceAcl | SyncBatchDue | SyncActionDue | CreateSyncBatch;

package/dist/messages/provider-api/sync-protocol.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });