@awarevue/api-types 2.0.12 → 2.0.14

package/dist/alarm-automation.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { DeviceEvent } from './device-event';
+import { DeviceEvent } from './events';
 import { DeviceType } from './device';
 import { AutomationRuleBody } from './automation';
 export declare const sAlarmBehavior: z.ZodEnum<["ignore", "trigger-always", "trigger-when-armed"]>;

package/dist/api/alarm.d.ts

@@ -1,4 +1,4 @@
-import { DeviceEvent } from '../device-event';
+import { DeviceEvent } from '../events';
 export interface AlarmSearchQueryDto {
     deviceId?: string[];
     kind?: string[];

package/dist/api/media.d.ts

@@ -103,11 +103,11 @@ export declare const sGetScenePreviewClipRequest: z.ZodObject<{
     deviceId: z.ZodString;
     providerAssignedRef: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    providerAssignedRef: string;
     deviceId: string;
-}, {
     providerAssignedRef: string;
+}, {
     deviceId: string;
+    providerAssignedRef: string;
 }>;
 export declare const sGetObjectSnapshotRequest: z.ZodObject<{
     deviceId: z.ZodString;
@@ -117,15 +117,15 @@ export declare const sGetObjectSnapshotRequest: z.ZodObject<{
     height: z.ZodOptional<z.ZodNumber>;
     quality: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    providerAssignedRef: string;
     deviceId: string;
+    providerAssignedRef: string;
     crop: boolean;
     boxes: boolean;
     height?: number | undefined;
     quality?: number | undefined;
 }, {
-    providerAssignedRef: string;
     deviceId: string;
+    providerAssignedRef: string;
     crop: boolean;
     boxes: boolean;
     height?: number | undefined;
@@ -135,11 +135,11 @@ export declare const sGetObjectThumbnailRequest: z.ZodObject<{
     deviceId: z.ZodString;
     providerAssignedRef: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    providerAssignedRef: string;
     deviceId: string;
-}, {
     providerAssignedRef: string;
+}, {
     deviceId: string;
+    providerAssignedRef: string;
 }>;
 export declare const sSortOptions: z.ZodUnion<[z.ZodLiteral<"time_asc">, z.ZodLiteral<"time_desc">]>;
 export declare const sMediaSearchQueryDto: z.ZodObject<{
@@ -155,18 +155,18 @@ export declare const sMediaSearchQueryDto: z.ZodObject<{
     label?: string[] | undefined;
     q?: string | undefined;
     deviceId?: string[] | undefined;
-    limit?: number | undefined;
     timeFrom?: number | undefined;
     timeTo?: number | undefined;
+    limit?: number | undefined;
     similarTo?: string | undefined;
     sortBy?: "time_asc" | "time_desc" | undefined;
 }, {
     label?: string[] | undefined;
     q?: string | undefined;
     deviceId?: string[] | undefined;
-    limit?: number | undefined;
     timeFrom?: number | undefined;
     timeTo?: number | undefined;
+    limit?: number | undefined;
     similarTo?: string | undefined;
     sortBy?: "time_asc" | "time_desc" | undefined;
 }>;

package/dist/bookmarks.d.ts

@@ -114,14 +114,14 @@ export declare const sBookmarkSearchCriteria: z.ZodObject<{
     timeTo: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     deviceId: string[];
+    createdBy: string[];
     timeFrom: number;
     timeTo: number;
-    createdBy: string[];
 }, {
     deviceId: string[];
+    createdBy: string[];
     timeFrom: number;
     timeTo: number;
-    createdBy: string[];
 }>;
 export type BookmarkProps = z.infer<typeof sBookmarkProps>;
 export type CreateBookmarkRq = z.infer<typeof sCreateBookmarkRq>;

package/dist/cast.d.ts

@@ -3,10 +3,10 @@ export declare const sCastCamerasRequest: z.ZodArray<z.ZodObject<{
     cameraId: z.ZodString;
     streamId: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    streamId: string;
     cameraId: string;
-}, {
     streamId: string;
+}, {
     cameraId: string;
+    streamId: string;
 }>, "many">;
 export type CastCamerasRequest = z.infer<typeof sCastCamerasRequest>;

package/dist/commands/alarm.d.ts

@@ -0,0 +1,312 @@
+import { z } from 'zod';
+export declare const sArmCommand: z.ZodObject<{
+    command: z.ZodLiteral<"alarm.arm">;
+    params: z.ZodObject<{
+        deviceId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        deviceId: string;
+    }, {
+        deviceId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        deviceId: string;
+    };
+    command: "alarm.arm";
+}, {
+    params: {
+        deviceId: string;
+    };
+    command: "alarm.arm";
+}>;
+export type ArmCommand = z.infer<typeof sArmCommand>;
+export declare const sDisarmCommand: z.ZodObject<{
+    command: z.ZodLiteral<"alarm.disarm">;
+    params: z.ZodObject<{
+        deviceId: z.ZodString;
+        duration: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        deviceId: string;
+        duration?: number | undefined;
+    }, {
+        deviceId: string;
+        duration?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        deviceId: string;
+        duration?: number | undefined;
+    };
+    command: "alarm.disarm";
+}, {
+    params: {
+        deviceId: string;
+        duration?: number | undefined;
+    };
+    command: "alarm.disarm";
+}>;
+export type DisarmCommand = z.infer<typeof sDisarmCommand>;
+export declare const sBypassCommand: z.ZodObject<{
+    command: z.ZodLiteral<"alarm.bypass">;
+    params: z.ZodObject<{
+        deviceId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        deviceId: string;
+    }, {
+        deviceId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        deviceId: string;
+    };
+    command: "alarm.bypass";
+}, {
+    params: {
+        deviceId: string;
+    };
+    command: "alarm.bypass";
+}>;
+export type BypassCommand = z.infer<typeof sBypassCommand>;
+export declare const sUnbypassCommand: z.ZodObject<{
+    command: z.ZodLiteral<"alarm.unbypass">;
+    params: z.ZodObject<{
+        deviceId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        deviceId: string;
+    }, {
+        deviceId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        deviceId: string;
+    };
+    command: "alarm.unbypass";
+}, {
+    params: {
+        deviceId: string;
+    };
+    command: "alarm.unbypass";
+}>;
+export type UnbypassCommand = z.infer<typeof sUnbypassCommand>;
+export declare const sArmAllCommand: z.ZodObject<{
+    command: z.ZodLiteral<"alarm.arm-all">;
+    params: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    params: {};
+    command: "alarm.arm-all";
+}, {
+    params: {};
+    command: "alarm.arm-all";
+}>;
+export type ArmAllCommand = z.infer<typeof sArmAllCommand>;
+export declare const sDisarmAllCommand: z.ZodObject<{
+    command: z.ZodLiteral<"alarm.disarm-all">;
+    params: z.ZodObject<{
+        duration: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        duration?: number | undefined;
+    }, {
+        duration?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        duration?: number | undefined;
+    };
+    command: "alarm.disarm-all";
+}, {
+    params: {
+        duration?: number | undefined;
+    };
+    command: "alarm.disarm-all";
+}>;
+export type DisarmAllCommand = z.infer<typeof sDisarmAllCommand>;
+export declare const sAcknowledgeCommand: z.ZodObject<{
+    command: z.ZodLiteral<"alarm.acknowledge">;
+    params: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    params: {};
+    command: "alarm.acknowledge";
+}, {
+    params: {};
+    command: "alarm.acknowledge";
+}>;
+export type AcknowledgeCommand = z.infer<typeof sAcknowledgeCommand>;
+export declare const sSetTriggerCommand: z.ZodObject<{
+    command: z.ZodLiteral<"alarm.set-trigger">;
+    params: z.ZodObject<{
+        event: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        onlyIfArmed: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        event: Record<string, unknown>;
+        onlyIfArmed: boolean;
+    }, {
+        event: Record<string, unknown>;
+        onlyIfArmed: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        event: Record<string, unknown>;
+        onlyIfArmed: boolean;
+    };
+    command: "alarm.set-trigger";
+}, {
+    params: {
+        event: Record<string, unknown>;
+        onlyIfArmed: boolean;
+    };
+    command: "alarm.set-trigger";
+}>;
+export type SetTriggerCommand = z.infer<typeof sSetTriggerCommand>;
+export type AlarmCommand = ArmCommand | DisarmCommand | ArmAllCommand | DisarmAllCommand | AcknowledgeCommand | SetTriggerCommand | BypassCommand | UnbypassCommand;
+export declare const alarmCommandSchemas: {
+    readonly 'alarm.arm': z.ZodObject<{
+        command: z.ZodLiteral<"alarm.arm">;
+        params: z.ZodObject<{
+            deviceId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            deviceId: string;
+        }, {
+            deviceId: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        params: {
+            deviceId: string;
+        };
+        command: "alarm.arm";
+    }, {
+        params: {
+            deviceId: string;
+        };
+        command: "alarm.arm";
+    }>;
+    readonly 'alarm.disarm': z.ZodObject<{
+        command: z.ZodLiteral<"alarm.disarm">;
+        params: z.ZodObject<{
+            deviceId: z.ZodString;
+            duration: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            deviceId: string;
+            duration?: number | undefined;
+        }, {
+            deviceId: string;
+            duration?: number | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        params: {
+            deviceId: string;
+            duration?: number | undefined;
+        };
+        command: "alarm.disarm";
+    }, {
+        params: {
+            deviceId: string;
+            duration?: number | undefined;
+        };
+        command: "alarm.disarm";
+    }>;
+    readonly 'alarm.arm-all': z.ZodObject<{
+        command: z.ZodLiteral<"alarm.arm-all">;
+        params: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    }, "strip", z.ZodTypeAny, {
+        params: {};
+        command: "alarm.arm-all";
+    }, {
+        params: {};
+        command: "alarm.arm-all";
+    }>;
+    readonly 'alarm.disarm-all': z.ZodObject<{
+        command: z.ZodLiteral<"alarm.disarm-all">;
+        params: z.ZodObject<{
+            duration: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            duration?: number | undefined;
+        }, {
+            duration?: number | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        params: {
+            duration?: number | undefined;
+        };
+        command: "alarm.disarm-all";
+    }, {
+        params: {
+            duration?: number | undefined;
+        };
+        command: "alarm.disarm-all";
+    }>;
+    readonly 'alarm.acknowledge': z.ZodObject<{
+        command: z.ZodLiteral<"alarm.acknowledge">;
+        params: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    }, "strip", z.ZodTypeAny, {
+        params: {};
+        command: "alarm.acknowledge";
+    }, {
+        params: {};
+        command: "alarm.acknowledge";
+    }>;
+    readonly 'alarm.set-trigger': z.ZodObject<{
+        command: z.ZodLiteral<"alarm.set-trigger">;
+        params: z.ZodObject<{
+            event: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            onlyIfArmed: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            event: Record<string, unknown>;
+            onlyIfArmed: boolean;
+        }, {
+            event: Record<string, unknown>;
+            onlyIfArmed: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        params: {
+            event: Record<string, unknown>;
+            onlyIfArmed: boolean;
+        };
+        command: "alarm.set-trigger";
+    }, {
+        params: {
+            event: Record<string, unknown>;
+            onlyIfArmed: boolean;
+        };
+        command: "alarm.set-trigger";
+    }>;
+    readonly 'alarm.bypass': z.ZodObject<{
+        command: z.ZodLiteral<"alarm.bypass">;
+        params: z.ZodObject<{
+            deviceId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            deviceId: string;
+        }, {
+            deviceId: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        params: {
+            deviceId: string;
+        };
+        command: "alarm.bypass";
+    }, {
+        params: {
+            deviceId: string;
+        };
+        command: "alarm.bypass";
+    }>;
+    readonly 'alarm.unbypass': z.ZodObject<{
+        command: z.ZodLiteral<"alarm.unbypass">;
+        params: z.ZodObject<{
+            deviceId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            deviceId: string;
+        }, {
+            deviceId: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        params: {
+            deviceId: string;
+        };
+        command: "alarm.unbypass";
+    }, {
+        params: {
+            deviceId: string;
+        };
+        command: "alarm.unbypass";
+    }>;
+};

package/dist/commands/alarm.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alarmCommandSchemas = exports.sSetTriggerCommand = exports.sAcknowledgeCommand = exports.sDisarmAllCommand = exports.sArmAllCommand = exports.sUnbypassCommand = exports.sBypassCommand = exports.sDisarmCommand = exports.sArmCommand = void 0;
+const primitives_1 = require("../primitives");
+const zod_1 = require("zod");
+// COMMANDS
+exports.sArmCommand = zod_1.z.object({
+    command: zod_1.z.literal('alarm.arm'),
+    params: zod_1.z.object({
+        deviceId: primitives_1.sDeviceId,
+    }),
+});
+exports.sDisarmCommand = zod_1.z.object({
+    command: zod_1.z.literal('alarm.disarm'),
+    params: zod_1.z.object({
+        deviceId: primitives_1.sDeviceId,
+        duration: primitives_1.sDuration.optional().describe('Duration in milliseconds'),
+    }),
+});
+exports.sBypassCommand = zod_1.z.object({
+    command: zod_1.z.literal('alarm.bypass'),
+    params: zod_1.z.object({
+        deviceId: primitives_1.sDeviceId,
+    }),
+});
+exports.sUnbypassCommand = zod_1.z.object({
+    command: zod_1.z.literal('alarm.unbypass'),
+    params: zod_1.z.object({
+        deviceId: primitives_1.sDeviceId,
+    }),
+});
+exports.sArmAllCommand = zod_1.z.object({
+    command: zod_1.z.literal('alarm.arm-all'),
+    params: zod_1.z.object({}),
+});
+exports.sDisarmAllCommand = zod_1.z.object({
+    command: zod_1.z.literal('alarm.disarm-all'),
+    params: zod_1.z.object({
+        duration: primitives_1.sDuration.optional().describe('Duration in milliseconds'),
+    }),
+});
+exports.sAcknowledgeCommand = zod_1.z.object({
+    command: zod_1.z.literal('alarm.acknowledge'),
+    params: zod_1.z.object({}),
+});
+exports.sSetTriggerCommand = zod_1.z.object({
+    command: zod_1.z.literal('alarm.set-trigger'),
+    params: zod_1.z.object({
+        event: primitives_1.sDeviceEvent,
+        onlyIfArmed: zod_1.z.boolean().describe('Set only if the device is armed'),
+    }),
+});
+exports.alarmCommandSchemas = {
+    'alarm.arm': exports.sArmCommand,
+    'alarm.disarm': exports.sDisarmCommand,
+    'alarm.arm-all': exports.sArmAllCommand,
+    'alarm.disarm-all': exports.sDisarmAllCommand,
+    'alarm.acknowledge': exports.sAcknowledgeCommand,
+    'alarm.set-trigger': exports.sSetTriggerCommand,
+    'alarm.bypass': exports.sBypassCommand,
+    'alarm.unbypass': exports.sUnbypassCommand,
+};

package/dist/{device-command.d.ts → commands/all.d.ts}

@@ -1,18 +1,16 @@
-import { AlarmCommand } from './device/alarm';
-import { CameraCommand } from './device/camera';
-import { CameraLiftCommand } from './device/camera-lift';
-import { DeviceGatewayCommand } from './device/device-gateway';
-import { DisplayCommand } from './device/display';
-import { DoorCommand } from './device/door';
-import { IntercomTerminalCommand } from './device/intercom-terminal';
-import { IoBoardCommand } from './device/io-board';
-import { NvrExporterCommand } from './device/nvr-exporter';
-import { PbxCommand } from './device/pbx';
-import { PresenceTrackerCommand } from './device/presence-tracker';
-import { ReaderCommand } from './device/reader/index';
-import { ServerCommand } from './device/server';
-import { PermissionId } from './permissions';
-export type AnyDeviceCommand = ServerCommand | DeviceGatewayCommand | CameraCommand | DoorCommand | ReaderCommand | IoBoardCommand | CameraLiftCommand | AlarmCommand | IntercomTerminalCommand | PbxCommand | PresenceTrackerCommand | DisplayCommand | NvrExporterCommand;
+import { AlarmCommand } from './alarm';
+import { CameraCommand } from './camera';
+import { CameraLiftCommand } from './camera-lift';
+import { DisplayCommand } from './display';
+import { DoorCommand } from './door';
+import { IntercomTerminalCommand } from './intercom-terminal';
+import { IoBoardCommand } from './io-board';
+import { NvrExporterCommand } from './nvr-exporter';
+import { PbxCommand } from './pbx';
+import { PresenceTrackerCommand } from './presence-tracker';
+import { ServerCommand } from './server';
+import { PermissionId } from '../permissions';
+export type AnyDeviceCommand = ServerCommand | CameraCommand | DoorCommand | IoBoardCommand | CameraLiftCommand | AlarmCommand | IntercomTerminalCommand | PbxCommand | PresenceTrackerCommand | DisplayCommand | NvrExporterCommand;
 export type CommandRun<TCommand extends AnyDeviceCommand = AnyDeviceCommand> = {
     timestamp: number;
     requestId: string;
@@ -24,7 +22,7 @@ export declare const commandSchemas: {
         command: import("zod").ZodLiteral<"nvr-exporter.start-export">;
         params: import("zod").ZodObject<{
             requestId: import("zod").ZodString;
-            device: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodIntersection<import("zod").ZodObject<{
+            device: import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodIntersection<import("zod").ZodObject<{
                 name: import("zod").ZodString;
                 foreignRef: import("zod").ZodString;
                 provider: import("zod").ZodString;
@@ -276,14 +274,14 @@ export declare const commandSchemas: {
                 type: "system";
             }, {
                 type: "system";
-            }>]>>]>;
+            }>]>>]>, import("zod").ZodTuple<[import("zod").ZodString, import("zod").ZodString], null>]>;
             timeFrom: import("zod").ZodNumber;
             timeTo: import("zod").ZodNumber;
             name: import("zod").ZodString;
         }, "strip", import("zod").ZodTypeAny, {
             name: string;
             requestId: string;
-            device: string | ({
+            device: string | [string, string] | ({
                 name: string;
                 foreignRef: string;
                 provider: string;
@@ -368,7 +366,7 @@ export declare const commandSchemas: {
         }, {
             name: string;
             requestId: string;
-            device: string | ({
+            device: string | [string, string] | ({
                 name: string;
                 foreignRef: string;
                 provider: string;
@@ -455,7 +453,7 @@ export declare const commandSchemas: {
         params: {
             name: string;
             requestId: string;
-            device: string | ({
+            device: string | [string, string] | ({
                 name: string;
                 foreignRef: string;
                 provider: string;
@@ -543,7 +541,7 @@ export declare const commandSchemas: {
         params: {
             name: string;
             requestId: string;
-            device: string | ({
+            device: string | [string, string] | ({
                 name: string;
                 foreignRef: string;
                 provider: string;
@@ -1158,22 +1156,22 @@ export declare const commandSchemas: {
             presetId: import("zod").ZodString;
             assignedRef: import("zod").ZodNullable<import("zod").ZodString>;
         }, "strip", import("zod").ZodTypeAny, {
-            presetId: string;
             assignedRef: string | null;
-        }, {
             presetId: string;
+        }, {
             assignedRef: string | null;
+            presetId: string;
         }>;
     }, "strip", import("zod").ZodTypeAny, {
         params: {
-            presetId: string;
             assignedRef: string | null;
+            presetId: string;
         };
         command: "camera.preset-delete";
     }, {
         params: {
-            presetId: string;
             assignedRef: string | null;
+            presetId: string;
         };
         command: "camera.preset-delete";
     }>;

package/dist/{device-command.js → commands/all.js}

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commandDescriptions = exports.commandSchemas = void 0;
-const alarm_1 = require("./device/alarm");
-const camera_1 = require("./device/camera");
-const camera_lift_1 = require("./device/camera-lift");
-const display_1 = require("./device/display");
-const door_1 = require("./device/door");
-const io_board_1 = require("./device/io-board");
-const nvr_exporter_1 = require("./device/nvr-exporter");
-const pbx_1 = require("./device/pbx");
-const presence_tracker_1 = require("./device/presence-tracker");
+const alarm_1 = require("./alarm");
+const camera_1 = require("./camera");
+const camera_lift_1 = require("./camera-lift");
+const display_1 = require("./display");
+const door_1 = require("./door");
+const io_board_1 = require("./io-board");
+const nvr_exporter_1 = require("./nvr-exporter");
+const pbx_1 = require("./pbx");
+const presence_tracker_1 = require("./presence-tracker");
 exports.commandSchemas = {
     ...alarm_1.alarmCommandSchemas,
     ...camera_1.cameraCommands,

package/dist/commands/camera-lift.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+export declare const sCameraLiftRaiseCommand: z.ZodObject<{
+    command: z.ZodLiteral<"camera-lift.raise">;
+    params: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    params: {};
+    command: "camera-lift.raise";
+}, {
+    params: {};
+    command: "camera-lift.raise";
+}>;
+export type CameraLiftRaiseCommand = z.infer<typeof sCameraLiftRaiseCommand>;
+export declare const sCameraLiftLowerCommand: z.ZodObject<{
+    command: z.ZodLiteral<"camera-lift.lower">;
+    params: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    params: {};
+    command: "camera-lift.lower";
+}, {
+    params: {};
+    command: "camera-lift.lower";
+}>;
+export type CameraLiftLowerCommand = z.infer<typeof sCameraLiftLowerCommand>;
+export type CameraLiftCommand = CameraLiftRaiseCommand | CameraLiftLowerCommand;
+export declare const cameraLiftCommands: {
+    readonly 'camera-lift.raise': z.ZodObject<{
+        command: z.ZodLiteral<"camera-lift.raise">;
+        params: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    }, "strip", z.ZodTypeAny, {
+        params: {};
+        command: "camera-lift.raise";
+    }, {
+        params: {};
+        command: "camera-lift.raise";
+    }>;
+    readonly 'camera-lift.lower': z.ZodObject<{
+        command: z.ZodLiteral<"camera-lift.lower">;
+        params: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    }, "strip", z.ZodTypeAny, {
+        params: {};
+        command: "camera-lift.lower";
+    }, {
+        params: {};
+        command: "camera-lift.lower";
+    }>;
+};

package/dist/commands/camera-lift.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cameraLiftCommands = exports.sCameraLiftLowerCommand = exports.sCameraLiftRaiseCommand = void 0;
+const zod_1 = require("zod");
+// COMMANDS
+exports.sCameraLiftRaiseCommand = zod_1.z.object({
+    command: zod_1.z.literal('camera-lift.raise'),
+    params: zod_1.z.object({}),
+});
+exports.sCameraLiftLowerCommand = zod_1.z.object({
+    command: zod_1.z.literal('camera-lift.lower'),
+    params: zod_1.z.object({}),
+});
+exports.cameraLiftCommands = {
+    'camera-lift.raise': exports.sCameraLiftRaiseCommand,
+    'camera-lift.lower': exports.sCameraLiftLowerCommand,
+};