@camstack/types 0.1.39 → 0.1.41

package/dist/capabilities/lock-control.cap.d.ts

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Smart-lock cap. Models HA `lock.*` entities — anything with a
+ * locked / unlocked binary state plus the four transient lifecycle
+ * states (`locking` / `unlocking`) and the `jammed` failure state
+ * that low-end deadbolts surface when the motor can't reach the
+ * target position.
+ *
+ * Some HA locks require a PIN code on every lock/unlock operation
+ * (workplace keypad locks, hospitality). The optional `code` field
+ * on the methods passes it through to the upstream service — the
+ * code is NEVER persisted in the runtime slice or any event payload.
+ * Locks that REQUIRE a code set `DeviceFeature.LockPinRequired` so
+ * the UI gates a code-entry field without a slice fetch.
+ *
+ * Locks that support a latch-release ("open door") action advertise
+ * `DeviceFeature.LockOpen`. The `open` method triggers the latch
+ * without a full lock/unlock cycle. Only available when the lock
+ * reports `LockEntityFeature.OPEN` (bit value 1) in HA
+ * `supported_features`.
+ */
+export declare const LockStateSchema: z.ZodEnum<{
+    locked: "locked";
+    unlocked: "unlocked";
+    locking: "locking";
+    unlocking: "unlocking";
+    jammed: "jammed";
+}>;
+export type LockState = z.infer<typeof LockStateSchema>;
+export declare const LockControlStatusSchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        locked: "locked";
+        unlocked: "unlocked";
+        locking: "locking";
+        unlocking: "unlocking";
+        jammed: "jammed";
+    }>;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type LockControlStatus = z.infer<typeof LockControlStatusSchema>;
+export declare const lockControlCapability: {
+    readonly name: "lock-control";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Lock];
+    readonly methods: {
+        readonly lock: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly unlock: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly open: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            state: z.ZodEnum<{
+                locked: "locked";
+                unlocked: "unlocked";
+                locking: "locking";
+                unlocking: "unlocking";
+                jammed: "jammed";
+            }>;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — mirrored by the kernel. UI lock buttons
+     * read `state` and disable themselves during `locking`/`unlocking`
+     * transitions.
+     */
+    readonly runtimeState: z.ZodObject<{
+        state: z.ZodEnum<{
+            locked: "locked";
+            unlocked: "unlocked";
+            locking: "locking";
+            unlocking: "unlocking";
+            jammed: "jammed";
+        }>;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type ILockControlProvider = InferProvider<typeof lockControlCapability>;
+//# sourceMappingURL=lock-control.cap.d.ts.map

package/dist/capabilities/lock-control.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-control.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/lock-control.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,eAAO,MAAM,eAAe;;;;;;EAM1B,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD,eAAO,MAAM,uBAAuB;;;;;;;;;iBAMlC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqChC;;;;OAIG;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

package/dist/capabilities/mask-shape.d.ts

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+/**
+ * Shared geometry vocabulary for on-frame shape caps — privacy-mask,
+ * motion-zones, and the detection zones/lines editor all speak this one
+ * language so a single drawing-plane editor and the providers stay
+ * decoupled from each cap's storage.
+ *
+ * All coordinates are normalized 0..1 of the camera frame (top-left
+ * origin). Each cap composes the SUBSET of shape kinds it supports and
+ * advertises it via `supportedShapes` in its `getOptions`.
+ */
+/** A normalized 0..1 point (top-left origin). */
+export declare const MaskPointSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strip>;
+/** Axis-aligned rectangle (normalized 0..1). */
+export declare const MaskRectShapeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"rect">;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+/** Free polygon — an ordered list of normalized vertices (≥3). */
+export declare const MaskPolygonShapeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"polygon">;
+    points: z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Boolean cell grid — row-major, length === gridWidth*gridHeight. */
+export declare const MaskGridShapeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"grid">;
+    gridWidth: z.ZodNumber;
+    gridHeight: z.ZodNumber;
+    cells: z.ZodArray<z.ZodBoolean>;
+}, z.core.$strip>;
+/** Directed line / tripwire — an ordered list of normalized points (≥2). */
+export declare const MaskLineShapeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"line">;
+    points: z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** The full shape vocabulary. Caps compose the subset they support. */
+export declare const MaskShapeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"rect">;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"polygon">;
+    points: z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"grid">;
+    gridWidth: z.ZodNumber;
+    gridHeight: z.ZodNumber;
+    cells: z.ZodArray<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"line">;
+    points: z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "kind">;
+/** Every shape-kind discriminant, for `supportedShapes` advertisement. */
+export declare const MaskShapeKindSchema: z.ZodEnum<{
+    polygon: "polygon";
+    rect: "rect";
+    grid: "grid";
+    line: "line";
+}>;
+/** Polygon vertex bounds when a cap supports 'polygon' (e.g. Hikvision {min:4,max:4}). */
+export declare const MaskPolygonVerticesSchema: z.ZodObject<{
+    min: z.ZodNumber;
+    max: z.ZodNumber;
+}, z.core.$strip>;
+/** Grid dimensions when a cap supports 'grid'. */
+export declare const MaskGridDimsSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+export type MaskPoint = z.infer<typeof MaskPointSchema>;
+export type MaskRectShape = z.infer<typeof MaskRectShapeSchema>;
+export type MaskPolygonShape = z.infer<typeof MaskPolygonShapeSchema>;
+export type MaskGridShape = z.infer<typeof MaskGridShapeSchema>;
+export type MaskLineShape = z.infer<typeof MaskLineShapeSchema>;
+export type MaskShape = z.infer<typeof MaskShapeSchema>;
+export type MaskShapeKind = z.infer<typeof MaskShapeKindSchema>;
+export type MaskPolygonVertices = z.infer<typeof MaskPolygonVerticesSchema>;
+export type MaskGridDims = z.infer<typeof MaskGridDimsSchema>;
+//# sourceMappingURL=mask-shape.d.ts.map

package/dist/capabilities/mask-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mask-shape.d.ts","sourceRoot":"","sources":["../../src/capabilities/mask-shape.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;GASG;AAEH,iDAAiD;AACjD,eAAO,MAAM,eAAe;;;iBAG1B,CAAA;AAEF,gDAAgD;AAChD,eAAO,MAAM,mBAAmB;;;;;;iBAM9B,CAAA;AAEF,kEAAkE;AAClE,eAAO,MAAM,sBAAsB;;;;;;iBAGjC,CAAA;AAEF,sEAAsE;AACtE,eAAO,MAAM,mBAAmB;;;;;iBAK9B,CAAA;AAEF,4EAA4E;AAC5E,eAAO,MAAM,mBAAmB;;;;;;iBAG9B,CAAA;AAEF,uEAAuE;AACvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;2BAK1B,CAAA;AAEF,0EAA0E;AAC1E,eAAO,MAAM,mBAAmB;;;;;EAA8C,CAAA;AAE9E,0FAA0F;AAC1F,eAAO,MAAM,yBAAyB;;;iBAGpC,CAAA;AAEF,kDAAkD;AAClD,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AACvD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AACvD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAC3E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/capabilities/media-player.cap.d.ts

@@ -0,0 +1,201 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Media-player cap. Models HA `media_player.*` (Sonos, Chromecast,
+ * Apple TV, Spotify, Roku, generic OTT receivers, …) on
+ * `DeviceType.MediaPlayer`. Disjoint from the camera streaming
+ * surface — those use `DeviceType.Camera` + the broker pipeline.
+ *
+ * The cap declares a wide method surface; not every backend supports
+ * every method. Drivers signal sub-capability via the
+ * `DeviceFeature.MediaPlayerXxx` flags (paired one-to-one with the
+ * corresponding method) so the UI gates buttons without a slice
+ * fetch — same pattern as `PanTiltZoom` for cameras.
+ */
+export declare const MediaPlayerStateSchema: z.ZodEnum<{
+    off: "off";
+    idle: "idle";
+    playing: "playing";
+    paused: "paused";
+    on: "on";
+    buffering: "buffering";
+    standby: "standby";
+}>;
+export type MediaPlayerState = z.infer<typeof MediaPlayerStateSchema>;
+export declare const MediaPlayerRepeatSchema: z.ZodEnum<{
+    off: "off";
+    all: "all";
+    one: "one";
+}>;
+export type MediaPlayerRepeat = z.infer<typeof MediaPlayerRepeatSchema>;
+declare const MediaInfoSchema: z.ZodObject<{
+    type: z.ZodString;
+    title: z.ZodString;
+    artist: z.ZodOptional<z.ZodString>;
+    album: z.ZodOptional<z.ZodString>;
+    imageUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MediaInfo = z.infer<typeof MediaInfoSchema>;
+export declare const MediaPlayerStatusSchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        off: "off";
+        idle: "idle";
+        playing: "playing";
+        paused: "paused";
+        on: "on";
+        buffering: "buffering";
+        standby: "standby";
+    }>;
+    volumeLevel: z.ZodNullable<z.ZodNumber>;
+    isMuted: z.ZodNullable<z.ZodBoolean>;
+    source: z.ZodString;
+    availableSources: z.ZodArray<z.ZodString>;
+    currentMedia: z.ZodNullable<z.ZodObject<{
+        type: z.ZodString;
+        title: z.ZodString;
+        artist: z.ZodOptional<z.ZodString>;
+        album: z.ZodOptional<z.ZodString>;
+        imageUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    positionMs: z.ZodNullable<z.ZodNumber>;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    shuffle: z.ZodNullable<z.ZodBoolean>;
+    repeat: z.ZodNullable<z.ZodEnum<{
+        off: "off";
+        all: "all";
+        one: "one";
+    }>>;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type MediaPlayerStatus = z.infer<typeof MediaPlayerStatusSchema>;
+export declare const mediaPlayerCapability: {
+    readonly name: "media-player";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.MediaPlayer];
+    readonly methods: {
+        readonly play: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly pause: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly stop: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly next: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly previous: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly seek: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            positionMs: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly setVolume: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            volumeLevel: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly setMute: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            muted: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly setShuffle: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            shuffle: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly setRepeat: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            repeat: z.ZodEnum<{
+                off: "off";
+                all: "all";
+                one: "one";
+            }>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly selectSource: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            source: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly playMedia: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            mediaId: z.ZodString;
+            mediaType: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            state: z.ZodEnum<{
+                off: "off";
+                idle: "idle";
+                playing: "playing";
+                paused: "paused";
+                on: "on";
+                buffering: "buffering";
+                standby: "standby";
+            }>;
+            volumeLevel: z.ZodNullable<z.ZodNumber>;
+            isMuted: z.ZodNullable<z.ZodBoolean>;
+            source: z.ZodString;
+            availableSources: z.ZodArray<z.ZodString>;
+            currentMedia: z.ZodNullable<z.ZodObject<{
+                type: z.ZodString;
+                title: z.ZodString;
+                artist: z.ZodOptional<z.ZodString>;
+                album: z.ZodOptional<z.ZodString>;
+                imageUrl: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            positionMs: z.ZodNullable<z.ZodNumber>;
+            durationMs: z.ZodNullable<z.ZodNumber>;
+            shuffle: z.ZodNullable<z.ZodBoolean>;
+            repeat: z.ZodNullable<z.ZodEnum<{
+                off: "off";
+                all: "all";
+                one: "one";
+            }>>;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — mirrored by the kernel. UI players read the
+     * full slice for live now-playing, volume, and progress updates
+     * without polling.
+     */
+    readonly runtimeState: z.ZodObject<{
+        state: z.ZodEnum<{
+            off: "off";
+            idle: "idle";
+            playing: "playing";
+            paused: "paused";
+            on: "on";
+            buffering: "buffering";
+            standby: "standby";
+        }>;
+        volumeLevel: z.ZodNullable<z.ZodNumber>;
+        isMuted: z.ZodNullable<z.ZodBoolean>;
+        source: z.ZodString;
+        availableSources: z.ZodArray<z.ZodString>;
+        currentMedia: z.ZodNullable<z.ZodObject<{
+            type: z.ZodString;
+            title: z.ZodString;
+            artist: z.ZodOptional<z.ZodString>;
+            album: z.ZodOptional<z.ZodString>;
+            imageUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        positionMs: z.ZodNullable<z.ZodNumber>;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        shuffle: z.ZodNullable<z.ZodBoolean>;
+        repeat: z.ZodNullable<z.ZodEnum<{
+            off: "off";
+            all: "all";
+            one: "one";
+        }>>;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IMediaPlayerProvider = InferProvider<typeof mediaPlayerCapability>;
+export {};
+//# sourceMappingURL=media-player.cap.d.ts.map

package/dist/capabilities/media-player.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-player.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/media-player.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;EAQjC,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,uBAAuB;;;;EAAgC,CAAA;AACpE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,QAAA,MAAM,eAAe;;;;;;iBAYnB,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BlC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiGhC;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

package/dist/capabilities/mesh-network.cap.d.ts

@@ -34,8 +34,8 @@ declare const MeshEndpointSchema: z.ZodObject<{
     hostname: z.ZodString;
     port: z.ZodNumber;
     protocol: z.ZodEnum<{
-        http: "http";
         https: "https";
+        http: "http";
     }>;
 }, z.core.$strip>;
 export type MeshEndpoint = z.infer<typeof MeshEndpointSchema>;
@@ -80,8 +80,8 @@ export declare const MeshStatusSchema: z.ZodObject<{
         hostname: z.ZodString;
         port: z.ZodNumber;
         protocol: z.ZodEnum<{
-            http: "http";
             https: "https";
+            http: "http";
         }>;
     }, z.core.$strip>>>;
     error: z.ZodOptional<z.ZodString>;
@@ -123,8 +123,8 @@ export declare const meshNetworkCapability: {
                 hostname: z.ZodString;
                 port: z.ZodNumber;
                 protocol: z.ZodEnum<{
-                    http: "http";
                     https: "https";
+                    http: "http";
                 }>;
             }, z.core.$strip>>>;
             error: z.ZodOptional<z.ZodString>;

package/dist/capabilities/motion-trigger.cap.d.ts

@@ -44,6 +44,7 @@ export type MotionTriggerRuntimeState = z.infer<typeof MotionTriggerRuntimeState
 export declare const motionTriggerCapability: {
     readonly name: "motion-trigger";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Light, DeviceType.Siren, DeviceType.Switch];
     readonly methods: {

package/dist/capabilities/motion-trigger.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"motion-trigger.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/motion-trigger.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,yBAAyB;;;iBAIpC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,+BAA+B;;;;iBAG1C,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAEvF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BK,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}
+{"version":3,"file":"motion-trigger.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/motion-trigger.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,yBAAyB;;;iBAIpC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,+BAA+B;;;;iBAG1C,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAEvF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BK,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

package/dist/capabilities/motion-zones.cap.d.ts

@@ -1,19 +1,54 @@
 import { z } from 'zod';
 import { type InferNativeProvider } from './capability-definition.js';
 import { DeviceType } from '../device/device-type.js';
-/** Current on-camera motion-detection grid + master state. `cells` is
- *  row-major, length === gridWidth*gridHeight; true = cell triggers motion. */
+/**
+ * Motion-zones share the same MaskShape vocabulary as privacy-mask — the
+ * on-camera motion-detection mask is a single `grid` region (a row-major
+ * boolean cell lattice the camera's onboard VMD evaluates). Composing it as
+ * a region keeps one drawing-plane model across all geometry caps.
+ */
+/** A motion-zone region — exactly one boolean cell grid today. */
+export declare const MotionZoneRegionSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    enabled: z.ZodBoolean;
+    shape: z.ZodObject<{
+        kind: z.ZodLiteral<"grid">;
+        gridWidth: z.ZodNumber;
+        gridHeight: z.ZodNumber;
+        cells: z.ZodArray<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** Current on-camera motion-detection state — master enable + sensitivity +
+ *  the grid region(s). */
 export declare const MotionZoneStatusSchema: z.ZodObject<{
     enabled: z.ZodBoolean;
     sensitivity: z.ZodNumber;
-    cells: z.ZodArray<z.ZodBoolean>;
+    regions: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        enabled: z.ZodBoolean;
+        shape: z.ZodObject<{
+            kind: z.ZodLiteral<"grid">;
+            gridWidth: z.ZodNumber;
+            gridHeight: z.ZodNumber;
+            cells: z.ZodArray<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
     lastFetchedAt: z.ZodNumber;
 }, z.core.$strip>;
-/** Per-camera availability — the grid dimensions are fixed per camera
- *  model; the UI sizes its editor from these. */
+/** Per-camera availability — grid dims are fixed per camera model; the UI
+ *  sizes its editor from `grid`. */
 export declare const MotionZoneOptionsSchema: z.ZodObject<{
-    gridWidth: z.ZodNumber;
-    gridHeight: z.ZodNumber;
+    maxRegions: z.ZodNumber;
+    supportedShapes: z.ZodArray<z.ZodEnum<{
+        polygon: "polygon";
+        rect: "rect";
+        grid: "grid";
+        line: "line";
+    }>>;
+    grid: z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>;
     sensitivity: z.ZodObject<{
         min: z.ZodNumber;
         max: z.ZodNumber;
@@ -24,14 +59,25 @@ export declare const MotionZoneOptionsSchema: z.ZodObject<{
 export declare const MotionZonePatchSchema: z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
     sensitivity: z.ZodOptional<z.ZodNumber>;
-    cells: z.ZodOptional<z.ZodArray<z.ZodBoolean>>;
+    regions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        enabled: z.ZodBoolean;
+        shape: z.ZodObject<{
+            kind: z.ZodLiteral<"grid">;
+            gridWidth: z.ZodNumber;
+            gridHeight: z.ZodNumber;
+            cells: z.ZodArray<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
+export type MotionZoneRegion = z.infer<typeof MotionZoneRegionSchema>;
 export type MotionZoneStatus = z.infer<typeof MotionZoneStatusSchema>;
 export type MotionZoneOptions = z.infer<typeof MotionZoneOptionsSchema>;
 export type MotionZonePatch = z.infer<typeof MotionZonePatchSchema>;
 export declare const motionZonesCapability: {
     readonly name: "motion-zones";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Camera];
     readonly deviceConfig: {
@@ -46,8 +92,17 @@ export declare const motionZonesCapability: {
         readonly getOptions: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
         }, z.core.$strip>, z.ZodObject<{
-            gridWidth: z.ZodNumber;
-            gridHeight: z.ZodNumber;
+            maxRegions: z.ZodNumber;
+            supportedShapes: z.ZodArray<z.ZodEnum<{
+                polygon: "polygon";
+                rect: "rect";
+                grid: "grid";
+                line: "line";
+            }>>;
+            grid: z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>;
             sensitivity: z.ZodObject<{
                 min: z.ZodNumber;
                 max: z.ZodNumber;
@@ -59,7 +114,16 @@ export declare const motionZonesCapability: {
             patch: z.ZodObject<{
                 enabled: z.ZodOptional<z.ZodBoolean>;
                 sensitivity: z.ZodOptional<z.ZodNumber>;
-                cells: z.ZodOptional<z.ZodArray<z.ZodBoolean>>;
+                regions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodNumber;
+                    enabled: z.ZodBoolean;
+                    shape: z.ZodObject<{
+                        kind: z.ZodLiteral<"grid">;
+                        gridWidth: z.ZodNumber;
+                        gridHeight: z.ZodNumber;
+                        cells: z.ZodArray<z.ZodBoolean>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>>;
             }, z.core.$strip>;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
     };
@@ -67,7 +131,16 @@ export declare const motionZonesCapability: {
         readonly schema: z.ZodObject<{
             enabled: z.ZodBoolean;
             sensitivity: z.ZodNumber;
-            cells: z.ZodArray<z.ZodBoolean>;
+            regions: z.ZodArray<z.ZodObject<{
+                id: z.ZodNumber;
+                enabled: z.ZodBoolean;
+                shape: z.ZodObject<{
+                    kind: z.ZodLiteral<"grid">;
+                    gridWidth: z.ZodNumber;
+                    gridHeight: z.ZodNumber;
+                    cells: z.ZodArray<z.ZodBoolean>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
             lastFetchedAt: z.ZodNumber;
         }, z.core.$strip>;
         readonly kind: "poll";
@@ -75,7 +148,16 @@ export declare const motionZonesCapability: {
     readonly runtimeState: z.ZodObject<{
         enabled: z.ZodBoolean;
         sensitivity: z.ZodNumber;
-        cells: z.ZodArray<z.ZodBoolean>;
+        regions: z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            enabled: z.ZodBoolean;
+            shape: z.ZodObject<{
+                kind: z.ZodLiteral<"grid">;
+                gridWidth: z.ZodNumber;
+                gridHeight: z.ZodNumber;
+                cells: z.ZodArray<z.ZodBoolean>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
 };

package/dist/capabilities/motion-zones.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"motion-zones.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/motion-zones.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AACxG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;+EAC+E;AAC/E,eAAO,MAAM,sBAAsB;;;;;iBAMjC,CAAA;AAEF;iDACiD;AACjD,eAAO,MAAM,uBAAuB;;;;;;;;iBAIlC,CAAA;AAEF,6CAA6C;AAC7C,eAAO,MAAM,qBAAqB;;;;iBAIhC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACvE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBO,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,CAAC,OAAO,qBAAqB,CAAC,CAAA"}
+{"version":3,"file":"motion-zones.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/motion-zones.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AACxG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAGrD;;;;;GAKG;AAEH,kEAAkE;AAClE,eAAO,MAAM,sBAAsB;;;;;;;;;iBAIjC,CAAA;AAEF;0BAC0B;AAC1B,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;iBAMjC,CAAA;AAEF;oCACoC;AACpC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;iBAKlC,CAAA;AAEF,6CAA6C;AAC7C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;iBAIhC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACvE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBO,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

package/dist/capabilities/mqtt-broker.cap.d.ts

@@ -10,10 +10,10 @@ import { type InferProvider } from './capability-definition.js';
  * - `tls-error` — TLS handshake failed (cert / SNI / cipher)
  */
 declare const BrokerStatusSchema: z.ZodEnum<{
+    unreachable: "unreachable";
     connected: "connected";
     disconnected: "disconnected";
     "auth-failed": "auth-failed";
-    unreachable: "unreachable";
     "tls-error": "tls-error";
 }>;
 declare const BrokerInfoSchema: z.ZodObject<{
@@ -25,10 +25,10 @@ declare const BrokerInfoSchema: z.ZodObject<{
         embedded: "embedded";
     }>;
     status: z.ZodEnum<{
+        unreachable: "unreachable";
         connected: "connected";
         disconnected: "disconnected";
         "auth-failed": "auth-failed";
-        unreachable: "unreachable";
         "tls-error": "tls-error";
     }>;
     latencyMs: z.ZodNullable<z.ZodNumber>;
@@ -90,10 +90,10 @@ export declare const mqttBrokerCapability: {
                 embedded: "embedded";
             }>;
             status: z.ZodEnum<{
+                unreachable: "unreachable";
                 connected: "connected";
                 disconnected: "disconnected";
                 "auth-failed": "auth-failed";
-                unreachable: "unreachable";
                 "tls-error": "tls-error";
             }>;
             latencyMs: z.ZodNullable<z.ZodNumber>;