@awarevue/api-types 1.0.1

package/dist/api/media.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sGetLatestFrameRequest = exports.sMediaSearchQueryDto = exports.sGetExportLinkResponse = exports.sGetObjectThumbnailRequest = exports.sGetObjectSnapshotRequest = exports.sGetScenePreviewClipRequest = exports.sGetPreviewImageRequest = exports.sGetRecordingsResponse = exports.sGetRecordingsRequest = exports.sRecordingSequence = void 0;
+const zod_1 = require("zod");
+const query_1 = require("./query");
+exports.sRecordingSequence = zod_1.z.object({
+    start: zod_1.z.number().nonnegative(),
+    end: zod_1.z.number().nonnegative(),
+    motion: zod_1.z.number().optional(),
+    objects: zod_1.z.number().optional(),
+});
+exports.sGetRecordingsRequest = zod_1.z.object({
+    deviceId: zod_1.z.string().nonempty(),
+    timeFrom: zod_1.z.number().nonnegative(),
+    timeTo: zod_1.z.number().nonnegative(),
+});
+exports.sGetRecordingsResponse = (0, query_1.sPaginatedQueryResponseOf)(exports.sRecordingSequence);
+exports.sGetPreviewImageRequest = zod_1.z.object({
+    deviceId: zod_1.z.string().nonempty(),
+    time: zod_1.z.number().nonnegative(),
+    height: zod_1.z.number().nonnegative(),
+});
+exports.sGetScenePreviewClipRequest = zod_1.z.object({
+    deviceId: zod_1.z.string().nonempty(),
+    providerAssignedRef: zod_1.z.string().nonempty(),
+});
+exports.sGetObjectSnapshotRequest = zod_1.z.object({
+    deviceId: zod_1.z.string().nonempty(),
+    providerAssignedRef: zod_1.z.string().nonempty(),
+    crop: zod_1.z.boolean(),
+    boxes: zod_1.z.boolean(),
+    height: zod_1.z.number().nonnegative().optional(),
+    quality: zod_1.z.number().nonnegative().optional(),
+});
+exports.sGetObjectThumbnailRequest = zod_1.z.object({
+    deviceId: zod_1.z.string().nonempty(),
+    providerAssignedRef: zod_1.z.string().nonempty(),
+});
+exports.sGetExportLinkResponse = zod_1.z.object({
+    relativeUrl: zod_1.z.string().nonempty(),
+});
+const sSortOptions = zod_1.z.union([zod_1.z.literal('time_asc'), zod_1.z.literal('time_desc')]);
+exports.sMediaSearchQueryDto = zod_1.z
+    .object({
+    limit: zod_1.z.number().nonnegative(),
+    q: zod_1.z.string(),
+    deviceId: zod_1.z.array(zod_1.z.string().nonempty()),
+    similarTo: zod_1.z.string().optional(),
+    label: zod_1.z.array(zod_1.z.string().nonempty()),
+    timeFrom: zod_1.z.number().nonnegative(),
+    timeTo: zod_1.z.number().nonnegative(),
+    sortBy: sSortOptions,
+})
+    .partial();
+exports.sGetLatestFrameRequest = zod_1.z.object({
+    deviceId: zod_1.z.string().nonempty(),
+    width: zod_1.z.number().nonnegative(),
+    height: zod_1.z.number().nonnegative(),
+});

package/dist/api/query.d.ts

@@ -0,0 +1,33 @@
+import { z, ZodTypeAny } from 'zod';
+export type PaginatedQueryRequest<TCriteria> = Partial<TCriteria> & {
+    q?: string;
+    offset?: number;
+    limit?: number;
+};
+export interface PaginatedQueryResponse<T> {
+    items: T[];
+    total: number;
+}
+export declare const sPaginatedQueryRequestOf: <T extends z.AnyZodObject>(criteriaSchema: T) => z.ZodObject<z.objectUtil.extendShape<{
+    q: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, T["shape"]>, T["_def"]["unknownKeys"], T["_def"]["catchall"], z.objectOutputType<z.objectUtil.extendShape<{
+    q: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, T["shape"]>, T["_def"]["catchall"], T["_def"]["unknownKeys"]>, z.objectInputType<z.objectUtil.extendShape<{
+    q: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, T["shape"]>, T["_def"]["catchall"], T["_def"]["unknownKeys"]>>;
+export declare const sPaginatedQueryResponseOf: <T extends ZodTypeAny>(itemSchema: T) => z.ZodObject<{
+    items: z.ZodArray<T, "many">;
+    total: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    total: number;
+    items: T["_output"][];
+}, {
+    total: number;
+    items: T["_input"][];
+}>;

package/dist/api/query.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sPaginatedQueryResponseOf = exports.sPaginatedQueryRequestOf = void 0;
+const zod_1 = require("zod");
+const sPaginatedQueryRequestOf = (criteriaSchema) => zod_1.z
+    .object({
+    q: zod_1.z.string().optional().describe('Not supported yet'),
+    offset: zod_1.z
+        .number()
+        .optional()
+        .describe('Offset of the first item to return'),
+    limit: zod_1.z
+        .number()
+        .optional()
+        .describe('Maximum number of items to return'),
+})
+    .merge(criteriaSchema);
+exports.sPaginatedQueryRequestOf = sPaginatedQueryRequestOf;
+const sPaginatedQueryResponseOf = (itemSchema) => zod_1.z.object({
+    items: zod_1.z.array(itemSchema).describe('Array of items matching the query'),
+    total: zod_1.z
+        .number()
+        .describe('Total number of items matching the query (only one page is shown at a time)'),
+});
+exports.sPaginatedQueryResponseOf = sPaginatedQueryResponseOf;
+// example usage:
+// import { sPaginatedQueryRequestOf, sPaginatedQueryResponseOf } from 'aware-api-types';
+// import { z } from 'zod';
+// const sUserCriteria = z.object({
+//     name: z.string().optional(),
+//     email: z.string().optional(),
+// });
+// const sUser = z.object({
+//     id: z.string(),
+//     name: z.string(),
+//     email: z.string(),
+// });
+// const sPaginatedUserQueryRequest = sPaginatedQueryRequestOf(sUserCriteria);
+// const sPaginatedUserQueryResponse = sPaginatedQueryResponseOf(sUser);
+// type Request = z.infer<typeof sPaginatedUserQueryRequest>;
+// type Response = z.infer<typeof sPaginatedUserQueryResponse>;

package/dist/app.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const sAppInfo: z.ZodObject<{
+    version: z.ZodString;
+    releaseDate: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    releaseDate: string;
+}, {
+    version: string;
+    releaseDate: string;
+}>;
+export type AppInfo = z.infer<typeof sAppInfo>;

package/dist/app.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sAppInfo = void 0;
+const zod_1 = require("zod");
+exports.sAppInfo = zod_1.z.object({
+    version: zod_1.z.string(),
+    releaseDate: zod_1.z.string(),
+});

package/dist/automation.d.ts

@@ -0,0 +1,334 @@
+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;
+}, "strip", z.ZodTypeAny, {
+    code: string | null;
+    body: {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    };
+    displayName: string;
+    enabled: boolean;
+    description?: string | undefined;
+}, {
+    code: string | null;
+    body: {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    };
+    displayName: string;
+    enabled: boolean;
+    description?: string | undefined;
+}>;
+export declare const sAddAutomationRuleRequest: 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;
+}, "strip", z.ZodTypeAny, {
+    code: string | null;
+    body: {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    };
+    displayName: string;
+    enabled: boolean;
+    description?: string | undefined;
+}, {
+    code: string | null;
+    body: {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    };
+    displayName: string;
+    enabled: boolean;
+    description?: string | undefined;
+}>;
+export declare const sUpdateAutomationRule: z.ZodObject<{
+    displayName: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    body: z.ZodOptional<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.ZodOptional<z.ZodBoolean>;
+} & {
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    code?: string | null | undefined;
+    body?: {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    } | undefined;
+    description?: string | undefined;
+    displayName?: string | undefined;
+    enabled?: boolean | undefined;
+}, {
+    id: string;
+    code?: string | null | undefined;
+    body?: {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    } | undefined;
+    description?: string | undefined;
+    displayName?: string | undefined;
+    enabled?: boolean | undefined;
+}>;
+export declare const sAutomationRuleDto: z.ZodObject<{
+    displayName: z.ZodString;
+    description: z.ZodOptional<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;
+} & {
+    id: z.ZodString;
+    code: z.ZodNullable<z.ZodString>;
+    createdOn: z.ZodString;
+    lastModifiedOn: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    code: string | null;
+    id: string;
+    body: {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    };
+    displayName: string;
+    enabled: boolean;
+    createdOn: string;
+    lastModifiedOn: string;
+    description?: string | undefined;
+}, {
+    code: string | null;
+    id: string;
+    body: {
+        onEvent: string;
+        commands: {
+            target: string;
+            params: Record<string, unknown>;
+            command: string;
+        }[];
+        runIf?: string | undefined;
+    };
+    displayName: string;
+    enabled: boolean;
+    createdOn: string;
+    lastModifiedOn: string;
+    description?: string | undefined;
+}>;
+export type AutomationRuleBody = z.infer<typeof sAutomationRuleBody>;
+export type AutomationRuleProps = z.infer<typeof sAutomationRuleProps>;
+export type AutomationRuleDto = z.infer<typeof sAutomationRuleDto>;
+export type AddAutomationRuleRequest = z.infer<typeof sAddAutomationRuleRequest>;
+export type UpdateAutomationRuleRequest = z.infer<typeof sUpdateAutomationRule>;

package/dist/automation.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sAutomationRuleDto = exports.sUpdateAutomationRule = exports.sAddAutomationRuleRequest = exports.sAutomationRuleProps = exports.sAutomationRuleBody = exports.sAutomationRuleCommand = void 0;
+const zod_1 = require("zod");
+exports.sAutomationRuleCommand = zod_1.z.object({
+    command: zod_1.z.string().nonempty().describe('The command to be executed'),
+    target: zod_1.z.string().nonempty().describe('The target of the command'),
+    params: zod_1.z
+        .record(zod_1.z.unknown())
+        .describe('The parameters of the command depending on what it is'),
+});
+exports.sAutomationRuleBody = zod_1.z.object({
+    onEvent: zod_1.z
+        .string()
+        .nonempty()
+        .describe('The event that triggers the automation rule'),
+    runIf: zod_1.z
+        .string()
+        .optional()
+        .describe('The condition under which the automation rule should run'),
+    commands: zod_1.z
+        .array(exports.sAutomationRuleCommand)
+        .describe('The commands to be executed by the automation rule'),
+});
+exports.sAutomationRuleProps = zod_1.z.object({
+    displayName: zod_1.z
+        .string()
+        .nonempty()
+        .describe('The name of the automation rule'),
+    description: zod_1.z
+        .string()
+        .optional()
+        .describe('A description of the automation rule'),
+    code: zod_1.z.string().nullable().describe('The code of the automation rule'),
+    body: exports.sAutomationRuleBody.describe('The body of the automation rule'),
+    enabled: zod_1.z.boolean().describe('Whether the automation rule is enabled'),
+});
+exports.sAddAutomationRuleRequest = exports.sAutomationRuleProps;
+exports.sUpdateAutomationRule = exports.sAutomationRuleProps.partial().merge(zod_1.z.object({
+    id: zod_1.z.string().describe('The ID of the automation rule'),
+}));
+exports.sAutomationRuleDto = exports.sAutomationRuleProps.merge(zod_1.z.object({
+    id: zod_1.z.string().describe('The ID of the automation rule'),
+    code: zod_1.z.string().nullable().describe('The code of the automation rule'),
+    createdOn: zod_1.z.string().describe('The date the automation rule was created'),
+    lastModifiedOn: zod_1.z
+        .string()
+        .describe('The date the automation rule was last modified'),
+}));

package/dist/aware-config.d.ts

@@ -0,0 +1,3 @@
+export interface AwareConfigDto {
+    defaultLayoutId: string | null;
+}

package/dist/aware-config.js

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

package/dist/custom-field.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+export declare const CustomFieldTypeEnum: z.ZodEnum<["string", "number", "boolean", "date"]>;
+export declare const CustomFieldExtendsTypeEnum: z.ZodEnum<["person"]>;
+export declare const sCustomFieldDto: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<["string", "number", "boolean", "date"]>;
+    extendsType: z.ZodEnum<["person"]>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "string" | "number" | "boolean" | "date";
+    id: string;
+    extendsType: "person";
+}, {
+    name: string;
+    type: "string" | "number" | "boolean" | "date";
+    id: string;
+    extendsType: "person";
+}>;
+export declare const sAddCustomFieldRequest: z.ZodObject<Omit<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<["string", "number", "boolean", "date"]>;
+    extendsType: z.ZodEnum<["person"]>;
+}, "id">, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "string" | "number" | "boolean" | "date";
+    extendsType: "person";
+}, {
+    name: string;
+    type: "string" | "number" | "boolean" | "date";
+    extendsType: "person";
+}>;
+export declare const sUpdateCustomFieldRequest: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["string", "number", "boolean", "date"]>>;
+    extendsType: z.ZodOptional<z.ZodEnum<["person"]>>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    type?: "string" | "number" | "boolean" | "date" | undefined;
+    extendsType?: "person" | undefined;
+}, {
+    name?: string | undefined;
+    type?: "string" | "number" | "boolean" | "date" | undefined;
+    extendsType?: "person" | undefined;
+}>;
+export type CustomFieldDto = z.infer<typeof sCustomFieldDto>;
+export type AddCustomFieldRequest = z.infer<typeof sAddCustomFieldRequest>;
+export type UpdateCustomFieldRequest = z.infer<typeof sUpdateCustomFieldRequest>;
+export type CustomFieldRequestQueryParams = {
+    extendsType: CustomFieldDto['extendsType'];
+};

package/dist/custom-field.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sUpdateCustomFieldRequest = exports.sAddCustomFieldRequest = exports.sCustomFieldDto = exports.CustomFieldExtendsTypeEnum = exports.CustomFieldTypeEnum = void 0;
+const zod_1 = require("zod");
+exports.CustomFieldTypeEnum = zod_1.z.enum([
+    'string',
+    'number',
+    'boolean',
+    'date',
+]);
+exports.CustomFieldExtendsTypeEnum = zod_1.z.enum(['person']);
+exports.sCustomFieldDto = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    name: zod_1.z.string().min(1).max(64),
+    type: exports.CustomFieldTypeEnum,
+    extendsType: exports.CustomFieldExtendsTypeEnum,
+});
+exports.sAddCustomFieldRequest = exports.sCustomFieldDto.omit({ id: true });
+exports.sUpdateCustomFieldRequest = exports.sAddCustomFieldRequest.partial();