@awarevue/api-types 2.0.21 → 2.0.23

package/dist/{device → objects/device}/server.d.ts

@@ -1,5 +1,5 @@
+import { AccessControlCapabilityReport } from '../../objects';
 import { ModuleConfig, ModuleConfigMetadata } from '../module-config';
-import { AccessControlCapabilityReport } from '../agent-communication';
 export declare const SERVER = "server";
 export type AccessControlProviderState = AccessControlCapabilityReport & {
     syncInProgress: boolean;

package/dist/objects/device/server.js

@@ -0,0 +1 @@
+export const SERVER = 'server';

package/dist/objects/device/system.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const SYSTEM = 'system';
+// SPECS
+export const sSystemDeviceSpecs = z.object({});
+// STATE
+export const sSystemDeviceStateDto = z.record(z.unknown());

package/dist/objects/device-group.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const sDeviceGroup: z.ZodObject<{
+    id: z.ZodString;
+    code: z.ZodNullable<z.ZodString>;
+    displayName: z.ZodString;
+    createdOn: z.ZodString;
+    lastModifiedOn: z.ZodString;
+    devices: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    code: string | null;
+    id: string;
+    displayName: string;
+    createdOn: string;
+    lastModifiedOn: string;
+    devices: string[];
+}, {
+    code: string | null;
+    id: string;
+    displayName: string;
+    createdOn: string;
+    lastModifiedOn: string;
+    devices: string[];
+}>;
+export type DeviceGroupDto = z.infer<typeof sDeviceGroup>;

package/dist/objects/device-group.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export const sDeviceGroup = z.object({
+    id: z.string(),
+    code: z.string().nullable(),
+    displayName: z.string(),
+    createdOn: z.string(),
+    lastModifiedOn: z.string(),
+    devices: z.array(z.string().nonempty()),
+});

package/dist/objects/index.d.ts

@@ -0,0 +1,27 @@
+export * from './access-rule';
+export * from './agreement';
+export * from './all';
+export * from './custom-field';
+export * from './token-conversion';
+export * from './api-key';
+export * from './automation-rule';
+export * from './device-group';
+export * from './layout';
+export * from './person';
+export * from './role';
+export * from './user';
+export * from './view';
+export * from './zone';
+export * from './bookmark';
+export * from './macro';
+export * from './person-presence';
+export * from './person-type';
+export * from './schedule';
+export * from './security-level';
+export * from './notification';
+export * from './credential';
+export * from './template';
+export * from './person-agreement';
+export * from './agent-metadata';
+export * from './world-object';
+export * from './device';

package/dist/objects/index.js

@@ -0,0 +1,27 @@
+export * from './access-rule';
+export * from './agreement';
+export * from './all';
+export * from './custom-field';
+export * from './token-conversion';
+export * from './api-key';
+export * from './automation-rule';
+export * from './device-group';
+export * from './layout';
+export * from './person';
+export * from './role';
+export * from './user';
+export * from './view';
+export * from './zone';
+export * from './bookmark';
+export * from './macro';
+export * from './person-presence';
+export * from './person-type';
+export * from './schedule';
+export * from './security-level';
+export * from './notification';
+export * from './credential';
+export * from './template';
+export * from './person-agreement';
+export * from './agent-metadata';
+export * from './world-object';
+export * from './device';

package/dist/objects/layout.d.ts

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+export declare const sLayoutDeviceDto: z.ZodObject<{
+    deviceId: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    scale: z.ZodNumber;
+    rotation: z.ZodNumber;
+    fov: z.ZodNumber;
+    far: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    scale: number;
+    x: number;
+    y: number;
+    deviceId: string;
+    rotation: number;
+    fov: number;
+    far: number;
+}, {
+    scale: number;
+    x: number;
+    y: number;
+    deviceId: string;
+    rotation: number;
+    fov: number;
+    far: number;
+}>;
+export type LayoutDeviceDto = z.infer<typeof sLayoutDeviceDto>;
+export declare const sLayoutDto: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    thumbnailUrl: z.ZodString;
+    imageUrl: z.ZodString;
+    order: z.ZodNumber;
+    isDefault: z.ZodBoolean;
+    devices: z.ZodArray<z.ZodObject<{
+        deviceId: z.ZodString;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        scale: z.ZodNumber;
+        rotation: z.ZodNumber;
+        fov: z.ZodNumber;
+        far: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        scale: number;
+        x: number;
+        y: number;
+        deviceId: string;
+        rotation: number;
+        fov: number;
+        far: number;
+    }, {
+        scale: number;
+        x: number;
+        y: number;
+        deviceId: string;
+        rotation: number;
+        fov: number;
+        far: number;
+    }>, "many">;
+    colorize: z.ZodBoolean;
+    createdOn: z.ZodString;
+    lastModifiedOn: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    order: number;
+    createdOn: string;
+    lastModifiedOn: string;
+    thumbnailUrl: string;
+    imageUrl: string;
+    isDefault: boolean;
+    devices: {
+        scale: number;
+        x: number;
+        y: number;
+        deviceId: string;
+        rotation: number;
+        fov: number;
+        far: number;
+    }[];
+    colorize: boolean;
+}, {
+    name: string;
+    id: string;
+    order: number;
+    createdOn: string;
+    lastModifiedOn: string;
+    thumbnailUrl: string;
+    imageUrl: string;
+    isDefault: boolean;
+    devices: {
+        scale: number;
+        x: number;
+        y: number;
+        deviceId: string;
+        rotation: number;
+        fov: number;
+        far: number;
+    }[];
+    colorize: boolean;
+}>;
+export type LayoutDto = z.infer<typeof sLayoutDto>;

package/dist/objects/layout.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export const sLayoutDeviceDto = z.object({
+    deviceId: z.string(),
+    x: z.number(),
+    y: z.number(),
+    scale: z.number(),
+    rotation: z.number(),
+    fov: z.number(),
+    far: z.number(),
+});
+export const sLayoutDto = z.object({
+    id: z.string(),
+    name: z.string(),
+    thumbnailUrl: z.string(),
+    imageUrl: z.string(),
+    order: z.number(),
+    isDefault: z.boolean(),
+    devices: z.array(sLayoutDeviceDto),
+    colorize: z.boolean(),
+    createdOn: z.string(),
+    lastModifiedOn: z.string(),
+});

package/dist/objects/macro.d.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+export declare const sMacroItemDto: z.ZodObject<{
+    id: z.ZodNullable<z.ZodString>;
+    stepId: z.ZodString;
+    deviceId: z.ZodString;
+    command: z.ZodString;
+    params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    id: string | null;
+    params: Record<string, unknown>;
+    deviceId: string;
+    command: string;
+    stepId: string;
+}, {
+    id: string | null;
+    params: Record<string, unknown>;
+    deviceId: string;
+    command: string;
+    stepId: string;
+}>;
+export declare const sMacroDto: z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    code: z.ZodNullable<z.ZodString>;
+    module: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdOn: z.ZodString;
+    lastModifiedOn: z.ZodString;
+    createdBy: z.ZodNullable<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodNullable<z.ZodString>;
+        stepId: z.ZodString;
+        deviceId: z.ZodString;
+        command: z.ZodString;
+        params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        id: string | null;
+        params: Record<string, unknown>;
+        deviceId: string;
+        command: string;
+        stepId: string;
+    }, {
+        id: string | null;
+        params: Record<string, unknown>;
+        deviceId: string;
+        command: string;
+        stepId: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    code: string | null;
+    id: string;
+    module: string | null;
+    metadata: Record<string, unknown>;
+    items: {
+        id: string | null;
+        params: Record<string, unknown>;
+        deviceId: string;
+        command: string;
+        stepId: string;
+    }[];
+    displayName: string;
+    createdOn: string;
+    lastModifiedOn: string;
+    createdBy: string | null;
+}, {
+    code: string | null;
+    id: string;
+    module: string | null;
+    metadata: Record<string, unknown>;
+    items: {
+        id: string | null;
+        params: Record<string, unknown>;
+        deviceId: string;
+        command: string;
+        stepId: string;
+    }[];
+    displayName: string;
+    createdOn: string;
+    lastModifiedOn: string;
+    createdBy: string | null;
+}>;
+export type MacroItemDto = z.infer<typeof sMacroItemDto>;
+export type MacroDto = z.infer<typeof sMacroDto>;

package/dist/objects/macro.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export const sMacroItemDto = z.object({
+    id: z.string().nullable(),
+    stepId: z.string().nonempty(),
+    deviceId: z.string().uuid().nonempty(),
+    command: z.string().nonempty(),
+    params: z.record(z.unknown()),
+});
+export const sMacroDto = z.object({
+    id: z.string().nonempty(),
+    displayName: z.string().nonempty(),
+    code: z.string().nullable().describe('The code of the macro rule'),
+    module: z
+        .string()
+        .nullable()
+        .describe('The module the macro rule belongs to'),
+    metadata: z.record(z.unknown()),
+    createdOn: z.string(),
+    lastModifiedOn: z.string(),
+    createdBy: z.string().nullable(),
+    items: z.array(sMacroItemDto),
+});

package/dist/{module-config.d.ts → objects/module-config.d.ts}

@@ -1,16 +1,11 @@
 import { JSONSchema4 } from 'json-schema';
-import { UiHint } from './agent-communication';
+import { UiHint } from './agent-metadata';
 export interface ModuleConfig {
     app: {
         modules: string[];
     };
     [moduleName: string]: Record<string, unknown>;
 }
-export interface SaveProviderConfigRq {
-    provider: string;
-    enabled: boolean;
-    config: Record<string, unknown>;
-}
 export interface ModuleConfigMetadata {
     allModules: string[];
     moduleTitles: Record<string, string>;
@@ -18,15 +13,3 @@ export interface ModuleConfigMetadata {
     moduleSchemas: Record<string, JSONSchema4>;
     moduleUiHints: Record<string, UiHint[]>;
 }
-export interface ConfigIssue {
-    paths: string[];
-    message: string;
-    provider: string;
-}
-export interface ModuleConfigSpecs {
-    provider: string;
-    title: string;
-    schema: JSONSchema4;
-    default: Record<string, unknown>;
-    uiHints?: UiHint[];
-}

package/dist/objects/module-config.js

@@ -0,0 +1 @@
+export {};

package/dist/{notifications.d.ts → objects/notification.d.ts}

@@ -31,23 +31,3 @@ export declare const sNotificationDto: z.ZodObject<{
     acknowledgedOn: number | null;
 }>;
 export type NotificationDto = z.infer<typeof sNotificationDto>;
-export declare const sNotificationSearchParams: z.ZodObject<{
-    deviceId: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    severity: z.ZodOptional<z.ZodArray<z.ZodEnum<["info", "warning", "critical"]>, "many">>;
-    acknowledged: z.ZodOptional<z.ZodBoolean>;
-    timeFrom: z.ZodOptional<z.ZodNumber>;
-    timeTo: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    deviceId?: string[] | undefined;
-    timeFrom?: number | undefined;
-    timeTo?: number | undefined;
-    severity?: ("info" | "warning" | "critical")[] | undefined;
-    acknowledged?: boolean | undefined;
-}, {
-    deviceId?: string[] | undefined;
-    timeFrom?: number | undefined;
-    timeTo?: number | undefined;
-    severity?: ("info" | "warning" | "critical")[] | undefined;
-    acknowledged?: boolean | undefined;
-}>;
-export type NotificationSearchParams = z.infer<typeof sNotificationSearchParams>;

package/dist/objects/notification.js

@@ -0,0 +1,13 @@
+import { sDeviceId, sNotificationSeverity } from '../primitives';
+import { z } from 'zod';
+export const sNotificationDto = z.object({
+    id: z.string().nonempty(),
+    source: sDeviceId,
+    message: z.string().nonempty(),
+    severity: sNotificationSeverity,
+    metadata: z.record(z.unknown()),
+    notificationRef: z.string().nonempty().nullable(),
+    createdOn: z.number().int().nonnegative(),
+    acknowledgedBy: z.string().nonempty().nullable(),
+    acknowledgedOn: z.number().int().nonnegative().nullable(),
+});

package/dist/{access-control → objects}/person-agreement.d.ts

@@ -1,4 +1,4 @@
-import z from 'zod';
+import { z } from 'zod';
 export declare const sPersonAgeementDto: z.ZodObject<{
     personId: z.ZodString;
     agreementId: z.ZodString;
@@ -19,17 +19,3 @@ export declare const sPersonAgeementDto: z.ZodObject<{
     agreementImage: string;
 }>;
 export type PersonAgreementDto = z.infer<typeof sPersonAgeementDto>;
-export declare const sCreatePersonAgreementRequest: z.ZodObject<{
-    personId: z.ZodString;
-    agreementId: z.ZodString;
-    agreementImage: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    personId: string;
-    agreementId: string;
-    agreementImage: string;
-}, {
-    personId: string;
-    agreementId: string;
-    agreementImage: string;
-}>;
-export type CreatePersonAgreementRequest = z.infer<typeof sCreatePersonAgreementRequest>;

package/dist/objects/person-agreement.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export const sPersonAgeementDto = z.object({
+    personId: z.string(),
+    agreementId: z.string(),
+    agreementImage: z.string(),
+    createdOn: z.string().date(),
+    lastModifiedOn: z.string().date(),
+});

package/dist/{access-control → objects}/person-presence.d.ts

@@ -163,6 +163,7 @@ export declare const sPersonPresenceActionDto: z.ZodObject<{
     checkCompleted: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
     id: string;
+    timestamp: number;
     person: string | {
         type: string;
         id: string;
@@ -176,12 +177,12 @@ export declare const sPersonPresenceActionDto: z.ZodObject<{
         displayName: string;
         isGlobal: boolean;
     };
-    timestamp: number;
     checkInOrOut: boolean;
     isLeave: boolean;
     checkCompleted: boolean;
 }, {
     id: string;
+    timestamp: number;
     person: string | {
         type: string;
         id: string;
@@ -195,80 +196,8 @@ export declare const sPersonPresenceActionDto: z.ZodObject<{
         displayName: string;
         isGlobal: boolean;
     };
-    timestamp: number;
     checkInOrOut: boolean;
     isLeave: boolean;
     checkCompleted: boolean;
 }>;
 export type PersonPresenceActionDto = z.infer<typeof sPersonPresenceActionDto>;
-export declare const sPersonPresenceQuery: z.ZodObject<{
-    persons: z.ZodArray<z.ZodString, "many">;
-    zones: z.ZodArray<z.ZodString, "many">;
-    online: z.ZodBoolean;
-}, "strip", z.ZodTypeAny, {
-    online: boolean;
-    persons: string[];
-    zones: string[];
-}, {
-    online: boolean;
-    persons: string[];
-    zones: string[];
-}>;
-export type PersonPresenceQuery = z.infer<typeof sPersonPresenceQuery>;
-export declare const sPersonTogglePresence: z.ZodUnion<[z.ZodObject<{
-    personId: z.ZodString;
-    zoneId: z.ZodString;
-    credentialToken: z.ZodUndefined;
-}, "strip", z.ZodTypeAny, {
-    personId: string;
-    zoneId: string;
-    credentialToken?: undefined;
-}, {
-    personId: string;
-    zoneId: string;
-    credentialToken?: undefined;
-}>, z.ZodObject<{
-    credentialToken: z.ZodString;
-    zoneId: z.ZodString;
-    personId: z.ZodUndefined;
-}, "strip", z.ZodTypeAny, {
-    zoneId: string;
-    credentialToken: string;
-    personId?: undefined;
-}, {
-    zoneId: string;
-    credentialToken: string;
-    personId?: undefined;
-}>]>;
-export declare const sPersonCheckIn: z.ZodObject<{
-    personId: z.ZodString;
-    zoneId: z.ZodString;
-    checkCompleted: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    personId: string;
-    zoneId: string;
-    checkCompleted?: boolean | undefined;
-}, {
-    personId: string;
-    zoneId: string;
-    checkCompleted?: boolean | undefined;
-}>;
-export declare const sPersonCheckOut: z.ZodObject<{
-    personId: z.ZodString;
-    zoneId: z.ZodString;
-    leave: z.ZodNullable<z.ZodBoolean>;
-    checkCompleted: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    personId: string;
-    zoneId: string;
-    leave: boolean | null;
-    checkCompleted?: boolean | undefined;
-}, {
-    personId: string;
-    zoneId: string;
-    leave: boolean | null;
-    checkCompleted?: boolean | undefined;
-}>;
-export type PresenceToggleRequest = z.infer<typeof sPersonTogglePresence>;
-export type PresenceCheckInRequest = z.infer<typeof sPersonCheckIn>;
-export type PresenceCheckOutRequest = z.infer<typeof sPersonCheckOut>;

package/dist/objects/person-presence.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+export const sPresencePersonDto = z.object({
+    id: z.string(),
+    firstName: z.string(),
+    lastName: z.string(),
+    avatarId: z.string().nullable(),
+    type: z.string().min(1).max(16),
+    position: z.string().max(128).nullable(),
+});
+export const sPresenceZoneDto = z.object({
+    id: z.string(),
+    displayName: z.string(),
+    isGlobal: z
+        .boolean()
+        .describe('Whether the zone is the designated global zone'),
+});
+export const sPersonPresenceDto = z.object({
+    id: z.string(),
+    person: sPresencePersonDto,
+    zone: z.union([sPresenceZoneDto, z.string()]),
+    online: z.boolean().nullable(),
+    onLeave: z.boolean(),
+    lastCheckInOn: z.number().nullable(),
+    lastCheckOutOn: z.number().nullable(),
+    securityChecked: z.boolean(),
+});
+export const sPersonPresenceActionDto = z.object({
+    id: z.string(),
+    person: z.union([sPresencePersonDto, z.string()]),
+    zone: z.union([sPresenceZoneDto, z.string()]),
+    timestamp: z.number(),
+    checkInOrOut: z.boolean(),
+    isLeave: z.boolean(),
+    checkCompleted: z.boolean(),
+});

package/dist/objects/person-type.d.ts

@@ -0,0 +1,33 @@
+import z from 'zod';
+export declare const sPersonTypeDto: z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    accessControlUser: z.ZodBoolean;
+    systemUser: z.ZodBoolean;
+    agreements: z.ZodArray<z.ZodString, "many">;
+    securityCheck: z.ZodBoolean;
+    inOnCreation: z.ZodBoolean;
+    createdOn: z.ZodString;
+    lastModifiedOn: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    displayName: string;
+    createdOn: string;
+    lastModifiedOn: string;
+    agreements: string[];
+    accessControlUser: boolean;
+    systemUser: boolean;
+    securityCheck: boolean;
+    inOnCreation: boolean;
+}, {
+    id: string;
+    displayName: string;
+    createdOn: string;
+    lastModifiedOn: string;
+    agreements: string[];
+    accessControlUser: boolean;
+    systemUser: boolean;
+    securityCheck: boolean;
+    inOnCreation: boolean;
+}>;
+export type PersonTypeDto = z.infer<typeof sPersonTypeDto>;

package/dist/objects/person-type.js

@@ -0,0 +1,16 @@
+import z from 'zod';
+export const sPersonTypeDto = z.object({
+    id: z
+        .string()
+        .min(1)
+        .max(16)
+        .regex(/^[a-z-]+$/, 'Type must contain only lowercase letters (a-z) and hyphens'),
+    displayName: z.string().min(1).max(64),
+    accessControlUser: z.boolean(),
+    systemUser: z.boolean(),
+    agreements: z.array(z.string().uuid()),
+    securityCheck: z.boolean(),
+    inOnCreation: z.boolean(),
+    createdOn: z.string().date(),
+    lastModifiedOn: z.string().date(),
+});