@awarevue/api-types 2.0.22 → 2.0.24

package/dist/objects/agent-metadata.d.ts

@@ -0,0 +1,192 @@
+import { z } from 'zod';
+export declare const sUiOrderHint: z.ZodObject<{
+    kind: z.ZodLiteral<"order">;
+    path: z.ZodString;
+    fields: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    kind: "order";
+    fields: string[];
+}, {
+    path: string;
+    kind: "order";
+    fields: string[];
+}>;
+export declare const sUiWidgetHint: z.ZodObject<{
+    kind: z.ZodLiteral<"widget">;
+    path: z.ZodString;
+    spanColumns: z.ZodOptional<z.ZodNumber>;
+    password: z.ZodOptional<z.ZodBoolean>;
+    placeHolder: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    kind: "widget";
+    spanColumns?: number | undefined;
+    password?: boolean | undefined;
+    placeHolder?: string | undefined;
+}, {
+    path: string;
+    kind: "widget";
+    spanColumns?: number | undefined;
+    password?: boolean | undefined;
+    placeHolder?: string | undefined;
+}>;
+export declare const sUiHint: z.ZodUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"order">;
+    path: z.ZodString;
+    fields: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    kind: "order";
+    fields: string[];
+}, {
+    path: string;
+    kind: "order";
+    fields: string[];
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"widget">;
+    path: z.ZodString;
+    spanColumns: z.ZodOptional<z.ZodNumber>;
+    password: z.ZodOptional<z.ZodBoolean>;
+    placeHolder: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    kind: "widget";
+    spanColumns?: number | undefined;
+    password?: boolean | undefined;
+    placeHolder?: string | undefined;
+}, {
+    path: string;
+    kind: "widget";
+    spanColumns?: number | undefined;
+    password?: boolean | undefined;
+    placeHolder?: string | undefined;
+}>]>;
+export declare const sProviderSpecs: z.ZodObject<{
+    title: z.ZodString;
+    configSchema: z.ZodUnknown;
+    configDefault: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    configFormUiHints: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"order">;
+        path: z.ZodString;
+        fields: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        kind: "order";
+        fields: string[];
+    }, {
+        path: string;
+        kind: "order";
+        fields: string[];
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"widget">;
+        path: z.ZodString;
+        spanColumns: z.ZodOptional<z.ZodNumber>;
+        password: z.ZodOptional<z.ZodBoolean>;
+        placeHolder: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        kind: "widget";
+        spanColumns?: number | undefined;
+        password?: boolean | undefined;
+        placeHolder?: string | undefined;
+    }, {
+        path: string;
+        kind: "widget";
+        spanColumns?: number | undefined;
+        password?: boolean | undefined;
+        placeHolder?: string | undefined;
+    }>]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    configDefault: Record<string, unknown>;
+    configSchema?: unknown;
+    configFormUiHints?: ({
+        path: string;
+        kind: "order";
+        fields: string[];
+    } | {
+        path: string;
+        kind: "widget";
+        spanColumns?: number | undefined;
+        password?: boolean | undefined;
+        placeHolder?: string | undefined;
+    })[] | undefined;
+}, {
+    title: string;
+    configDefault: Record<string, unknown>;
+    configSchema?: unknown;
+    configFormUiHints?: ({
+        path: string;
+        kind: "order";
+        fields: string[];
+    } | {
+        path: string;
+        kind: "widget";
+        spanColumns?: number | undefined;
+        password?: boolean | undefined;
+        placeHolder?: string | undefined;
+    })[] | undefined;
+}>;
+export declare const sAccessObjectKind: z.ZodEnum<["accessRule", "schedule", "person", "device", "zone"]>;
+export declare const sTokenSpecs: z.ZodObject<{
+    type: z.ZodEnum<["card", "pin", "fingerprint"]>;
+    regex: z.ZodOptional<z.ZodString>;
+    formatDescription: z.ZodOptional<z.ZodString>;
+    maxPerPerson: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "card" | "pin" | "fingerprint";
+    regex?: string | undefined;
+    formatDescription?: string | undefined;
+    maxPerPerson?: number | undefined;
+}, {
+    type: "card" | "pin" | "fingerprint";
+    regex?: string | undefined;
+    formatDescription?: string | undefined;
+    maxPerPerson?: number | undefined;
+}>;
+export declare const sAccessControlCapabilityReport: z.ZodObject<{
+    tokens: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["card", "pin", "fingerprint"]>;
+        regex: z.ZodOptional<z.ZodString>;
+        formatDescription: z.ZodOptional<z.ZodString>;
+        maxPerPerson: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "card" | "pin" | "fingerprint";
+        regex?: string | undefined;
+        formatDescription?: string | undefined;
+        maxPerPerson?: number | undefined;
+    }, {
+        type: "card" | "pin" | "fingerprint";
+        regex?: string | undefined;
+        formatDescription?: string | undefined;
+        maxPerPerson?: number | undefined;
+    }>, "many">;
+    accessObjects: z.ZodArray<z.ZodEnum<["accessRule", "schedule", "person", "device", "zone"]>, "many">;
+    oneSchedulePerDoor: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    tokens: {
+        type: "card" | "pin" | "fingerprint";
+        regex?: string | undefined;
+        formatDescription?: string | undefined;
+        maxPerPerson?: number | undefined;
+    }[];
+    accessObjects: ("person" | "zone" | "schedule" | "device" | "accessRule")[];
+    oneSchedulePerDoor: boolean;
+}, {
+    tokens: {
+        type: "card" | "pin" | "fingerprint";
+        regex?: string | undefined;
+        formatDescription?: string | undefined;
+        maxPerPerson?: number | undefined;
+    }[];
+    accessObjects: ("person" | "zone" | "schedule" | "device" | "accessRule")[];
+    oneSchedulePerDoor: boolean;
+}>;
+export type AccessControlCapabilityReport = z.infer<typeof sAccessControlCapabilityReport>;
+export type AccessTokenSpecs = z.infer<typeof sTokenSpecs>;
+export type AccessObjectKind = z.infer<typeof sAccessObjectKind>;
+export type UiHint = z.infer<typeof sUiHint>;
+export type UiOrderHint = z.infer<typeof sUiOrderHint>;
+export type UiWidgetHint = z.infer<typeof sUiWidgetHint>;
+export type ProviderSpecs = z.infer<typeof sProviderSpecs>;

package/dist/objects/agent-metadata.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { sCredentialType } from './credential';
+export const sUiOrderHint = z.object({
+    kind: z.literal('order'),
+    path: z.string(),
+    fields: z.array(z.string().nonempty()),
+});
+export const sUiWidgetHint = z.object({
+    kind: z.literal('widget'),
+    path: z.string(),
+    spanColumns: z.number().optional(),
+    password: z.boolean().optional(),
+    placeHolder: z.string().optional(),
+});
+export const sUiHint = z.union([sUiOrderHint, sUiWidgetHint]);
+export const sProviderSpecs = z.object({
+    title: z
+        .string()
+        .nonempty()
+        .describe('a human-readable name for the provider'),
+    configSchema: z
+        .unknown()
+        .describe('a valid JSON schema that describes provider config data structure'), // We can use AJV to validate the definition of a JSON schema
+    configDefault: z
+        .record(z.unknown())
+        .describe('Default initialized values for configuration'),
+    configFormUiHints: z
+        .array(sUiHint)
+        .optional()
+        .describe('UI hints for configuration form visuals'),
+});
+export const sAccessObjectKind = z.enum([
+    'accessRule',
+    'schedule',
+    'person',
+    'device',
+    'zone',
+]);
+export const sTokenSpecs = z.object({
+    type: sCredentialType, // etc, those map to a AWARE-standardized set of token types
+    regex: z.string().optional(),
+    formatDescription: z.string().optional(),
+    maxPerPerson: z.number().optional(),
+});
+export const sAccessControlCapabilityReport = z.object({
+    tokens: z.array(sTokenSpecs),
+    accessObjects: z.array(sAccessObjectKind),
+    oneSchedulePerDoor: z.boolean(),
+});

package/dist/objects/agreement.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const sAgreementDto: z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    content: z.ZodString;
+    createdOn: z.ZodString;
+    lastModifiedOn: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    content: string;
+    displayName: string;
+    createdOn: string;
+    lastModifiedOn: string;
+}, {
+    id: string;
+    content: string;
+    displayName: string;
+    createdOn: string;
+    lastModifiedOn: string;
+}>;
+export type AgreementDto = z.infer<typeof sAgreementDto>;

package/dist/objects/agreement.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export const sAgreementDto = z.object({
+    id: z.string().uuid(),
+    displayName: z.string().min(1).max(64),
+    content: z.string().min(1),
+    createdOn: z.string().date(),
+    lastModifiedOn: z.string().date(),
+});

package/dist/{objects.d.ts → objects/all.d.ts}

@@ -1,15 +1,22 @@
 import { z } from 'zod';
-import { AccessRuleDto, ScheduleDto, PersonDto, ZoneDto, PersonPresenceDto, CreatePersonRequest, CreateScheduleRequest, CreateZoneRequest, CreateAccessRuleRequest, PersonTypeDto, AgreementDto } from './access-control';
-import { AutomationRuleDto, AutomationRuleProps } from './automation';
-import { BookmarkDto } from './bookmarks';
+import { LayoutDto } from './layout';
 import { DeviceDto } from './device';
+import { AccessRuleDto, AccessRuleProps } from './access-rule';
+import { AgreementDto } from './agreement';
+import { ApiKeyDto } from './api-key';
+import { AutomationRuleDto, AutomationRuleProps } from './automation-rule';
+import { BookmarkDto } from './bookmark';
 import { DeviceGroupDto } from './device-group';
-import { LayoutDto } from './layout';
-import { MacroDto } from './macros';
+import { MacroDto } from './macro';
+import { PersonDto, PersonProps } from './person';
+import { PersonPresenceDto } from './person-presence';
+import { PersonTypeDto } from './person-type';
+import { RoleDto } from './role';
+import { ScheduleDto, ScheduleProps } from './schedule';
 import { SecurityLevelDto } from './security-level';
-import { RoleDto, UserDto } from './user';
+import { UserDto } from './user';
 import { ViewDto } from './view';
-import { ApiKeyDto } from './api-keys';
+import { ZoneDto, ZoneProps } from './zone';
 export declare const sObjectKind: z.ZodEnum<["accessRule", "schedule", "person", "device", "zone", "personPresence", "deviceGroup", "view", "layout", "automationRule", "macro", "role", "user", "securityLevel", "bookmark", "personType", "agreement", "apiKey"]>;
 export type ObjectKind = z.infer<typeof sObjectKind>;
 export type ObjectKinds = {
@@ -34,10 +41,10 @@ export type ObjectKinds = {
 };
 export type ObjectDto = ObjectKinds;
 export type ObjectProps = {
-    person: CreatePersonRequest;
-    schedule: CreateScheduleRequest;
-    zone: CreateZoneRequest;
-    accessRule: CreateAccessRuleRequest;
+    person: PersonProps;
+    schedule: ScheduleProps;
+    zone: ZoneProps;
+    accessRule: AccessRuleProps;
     automationRule: AutomationRuleProps;
 };
 export declare const objectLabels: Record<string, string>;

package/dist/{objects.js → objects/all.js}

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.objectKinds = exports.objectLabels = exports.sObjectKind = void 0;
-const zod_1 = require("zod");
-exports.sObjectKind = zod_1.z.enum([
+import { z } from 'zod';
+export const sObjectKind = z.enum([
     'accessRule',
     'schedule',
     'person',
@@ -22,7 +19,7 @@ exports.sObjectKind = zod_1.z.enum([
     'agreement',
     'apiKey',
 ]);
-exports.objectLabels = {
+export const objectLabels = {
     accessRule: 'Access Rule',
     schedule: 'Schedule',
     person: 'Person',
@@ -42,4 +39,4 @@ exports.objectLabels = {
     agreement: 'Agreement',
     apiKey: 'API Key',
 };
-exports.objectKinds = exports.sObjectKind.options;
+export const objectKinds = sObjectKind.options;

package/dist/objects/api-key.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const sApiKeyDto: z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    prefix: z.ZodString;
+    createdOn: z.ZodString;
+    lastModifiedOn: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    prefix: string;
+    displayName: string;
+    createdOn: string;
+    lastModifiedOn: string;
+}, {
+    id: string;
+    prefix: string;
+    displayName: string;
+    createdOn: string;
+    lastModifiedOn: string;
+}>;
+export type ApiKeyDto = z.infer<typeof sApiKeyDto>;

package/dist/objects/api-key.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export const sApiKeyDto = z.object({
+    id: z.string().uuid(),
+    displayName: z.string().min(1).max(128),
+    prefix: z.string().min(8).max(16),
+    createdOn: z.string().datetime(),
+    lastModifiedOn: z.string().datetime(),
+});

package/dist/objects/automation-rule.d.ts

@@ -0,0 +1,218 @@
+import { z } from 'zod';
+export declare const sAutomationRuleCommand: z.ZodObject<{
+    command: z.ZodString;
+    target: z.ZodString;
+    params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    target: string;
+    params: Record<string, unknown>;
+    command: string;
+}, {
+    target: string;
+    params: Record<string, unknown>;
+    command: string;
+}>;
+export declare const sAutomationRuleBody: z.ZodObject<{
+    onEvent: z.ZodString;
+    runIf: z.ZodOptional<z.ZodString>;
+    commands: z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        target: z.ZodString;
+        params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        target: string;
+        params: Record<string, unknown>;
+        command: string;
+    }, {
+        target: string;
+        params: Record<string, unknown>;
+        command: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    onEvent: string;
+    commands: {
+        target: string;
+        params: Record<string, unknown>;
+        command: string;
+    }[];
+    runIf?: string | undefined;
+}, {
+    onEvent: string;
+    commands: {
+        target: string;
+        params: Record<string, unknown>;
+        command: string;
+    }[];
+    runIf?: string | undefined;
+}>;
+export declare const sAutomationRuleProps: z.ZodObject<{
+    displayName: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    code: z.ZodNullable<z.ZodString>;
+    body: z.ZodObject<{
+        onEvent: z.ZodString;
+        runIf: z.ZodOptional<z.ZodString>;
+        commands: z.ZodArray<z.ZodObject<{
+            command: z.ZodString;
+            target: z.ZodString;
+            params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }, {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    }, {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    }>;
+    enabled: z.ZodBoolean;
+    exclusivityGroup: z.ZodNullable<z.ZodString>;
+    score: z.ZodNullable<z.ZodNumber>;
+    module: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    code: string | null;
+    module: string | null;
+    body: {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    };
+    metadata: Record<string, unknown>;
+    displayName: string;
+    enabled: boolean;
+    exclusivityGroup: string | null;
+    score: number | null;
+    description?: string | undefined;
+}, {
+    code: string | null;
+    module: string | null;
+    body: {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    };
+    metadata: Record<string, unknown>;
+    displayName: string;
+    enabled: boolean;
+    exclusivityGroup: string | null;
+    score: number | null;
+    description?: string | undefined;
+}>;
+export declare const sAutomationRuleDto: z.ZodObject<{
+    displayName: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    code: z.ZodNullable<z.ZodString>;
+    body: z.ZodObject<{
+        onEvent: z.ZodString;
+        runIf: z.ZodOptional<z.ZodString>;
+        commands: z.ZodArray<z.ZodObject<{
+            command: z.ZodString;
+            target: z.ZodString;
+            params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }, {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    }, {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    }>;
+    enabled: z.ZodBoolean;
+    exclusivityGroup: z.ZodNullable<z.ZodString>;
+    score: z.ZodNullable<z.ZodNumber>;
+    module: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+} & {
+    id: z.ZodString;
+    createdOn: z.ZodString;
+    lastModifiedOn: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    code: string | null;
+    id: string;
+    module: string | null;
+    body: {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    };
+    metadata: Record<string, unknown>;
+    displayName: string;
+    createdOn: string;
+    lastModifiedOn: string;
+    enabled: boolean;
+    exclusivityGroup: string | null;
+    score: number | null;
+    description?: string | undefined;
+}, {
+    code: string | null;
+    id: string;
+    module: string | null;
+    body: {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    };
+    metadata: Record<string, unknown>;
+    displayName: string;
+    createdOn: string;
+    lastModifiedOn: string;
+    enabled: boolean;
+    exclusivityGroup: string | null;
+    score: number | null;
+    description?: string | undefined;
+}>;
+export type AutomationRuleBody = z.infer<typeof sAutomationRuleBody>;
+export type AutomationRuleProps = z.infer<typeof sAutomationRuleProps>;
+export type AutomationRuleDto = z.infer<typeof sAutomationRuleDto>;

package/dist/objects/automation-rule.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export const sAutomationRuleCommand = z.object({
+    command: z.string().nonempty().describe('The command to be executed'),
+    target: z.string().nonempty().describe('The target of the command'),
+    params: z
+        .record(z.unknown())
+        .describe('The parameters of the command depending on what it is'),
+});
+export const sAutomationRuleBody = z.object({
+    onEvent: z
+        .string()
+        .nonempty()
+        .describe('The event that triggers the automation rule'),
+    runIf: z
+        .string()
+        .optional()
+        .describe('The condition under which the automation rule should run'),
+    commands: z
+        .array(sAutomationRuleCommand)
+        .describe('The commands to be executed by the automation rule'),
+});
+export const sAutomationRuleProps = z.object({
+    displayName: z
+        .string()
+        .nonempty()
+        .describe('The name of the automation rule'),
+    description: z
+        .string()
+        .optional()
+        .describe('A description of the automation rule'),
+    code: z.string().nullable().describe('The code of the automation rule'),
+    body: sAutomationRuleBody.describe('The body of the automation rule'),
+    enabled: z.boolean().describe('Whether the automation rule is enabled'),
+    exclusivityGroup: z
+        .string()
+        .nullable()
+        .describe('The exclusivity group of the automation rule. Only one matching rule at max will run within one group based on the highest score'),
+    score: z.number().int().min(0).nullable(),
+    module: z
+        .string()
+        .nullable()
+        .describe('The module the automation rule belongs to'),
+    metadata: z.record(z.unknown()),
+});
+export const sAutomationRuleDto = sAutomationRuleProps.merge(z.object({
+    id: z.string().describe('The ID of the automation rule'),
+    createdOn: z.string().describe('The date the automation rule was created'),
+    lastModifiedOn: z
+        .string()
+        .describe('The date the automation rule was last modified'),
+}));