@camstack/types 0.1.40 → 0.1.42

package/dist/capabilities/lawn-mower-control.cap.d.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Robotic lawn-mower cap. Models HA `lawn_mower.*` entities — anything
+ * with a mowing lifecycle plus a dock action.
+ *
+ * Activity follows HA's canonical lawn-mower lifecycle: `idle` /
+ * `mowing` / `paused` / `docked` / `error`. `batteryLevel` (0..100) is
+ * nullable — some mowers don't report a battery percentage.
+ *
+ * `startMowing` begins a mowing run, `pause` halts it in place, and
+ * `dock` sends the mower back to its charging station.
+ */
+export declare const LawnMowerActivitySchema: z.ZodEnum<{
+    error: "error";
+    idle: "idle";
+    paused: "paused";
+    mowing: "mowing";
+    docked: "docked";
+}>;
+export type LawnMowerActivity = z.infer<typeof LawnMowerActivitySchema>;
+export declare const LawnMowerControlStatusSchema: z.ZodObject<{
+    activity: z.ZodEnum<{
+        error: "error";
+        idle: "idle";
+        paused: "paused";
+        mowing: "mowing";
+        docked: "docked";
+    }>;
+    batteryLevel: z.ZodNullable<z.ZodNumber>;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type LawnMowerControlStatus = z.infer<typeof LawnMowerControlStatusSchema>;
+export declare const lawnMowerControlCapability: {
+    readonly name: "lawn-mower-control";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.LawnMower];
+    readonly methods: {
+        readonly startMowing: 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 dock: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            activity: z.ZodEnum<{
+                error: "error";
+                idle: "idle";
+                paused: "paused";
+                mowing: "mowing";
+                docked: "docked";
+            }>;
+            batteryLevel: z.ZodNullable<z.ZodNumber>;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — mirrored by the kernel. UI controls watch the
+     * slice for live activity + battery changes.
+     */
+    readonly runtimeState: z.ZodObject<{
+        activity: z.ZodEnum<{
+            error: "error";
+            idle: "idle";
+            paused: "paused";
+            mowing: "mowing";
+            docked: "docked";
+        }>;
+        batteryLevel: z.ZodNullable<z.ZodNumber>;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type ILawnMowerControlProvider = InferProvider<typeof lawnMowerControlCapability>;
+//# sourceMappingURL=lawn-mower-control.cap.d.ts.map

package/dist/capabilities/lawn-mower-control.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lawn-mower-control.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/lawn-mower-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;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,uBAAuB;;;;;;EAMlC,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,eAAO,MAAM,4BAA4B;;;;;;;;;;iBAQvC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEjF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2BrC;;;OAGG;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,yBAAyB,GAAG,aAAa,CAAC,OAAO,0BAA0B,CAAC,CAAA"}

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/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/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

@@ -77,6 +77,7 @@ 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: {

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;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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/native-object-detection.cap.d.ts

@@ -101,6 +101,7 @@ export type NativeObjectDetectionRuntimeState = z.infer<typeof NativeObjectDetec
 export declare const nativeObjectDetectionCapability: {
     readonly name: "native-object-detection";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Camera];
     readonly methods: {

package/dist/capabilities/native-object-detection.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"native-object-detection.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/native-object-detection.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;AACH,eAAO,MAAM,qBAAqB;;;;;;;EAEhC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAErE,eAAO,MAAM,qBAAqB;;;;;;;;;;;iBAKhC,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqB5C,CAAA;AAEF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAE3F,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGlD,CAAA;AAEF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uCAAuC,CAAC,CAAA;AAEvG,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBH,CAAA;AAEzC,MAAM,MAAM,8BAA8B,GAAG,aAAa,CAAC,OAAO,+BAA+B,CAAC,CAAA"}
+{"version":3,"file":"native-object-detection.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/native-object-detection.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;AACH,eAAO,MAAM,qBAAqB;;;;;;;EAEhC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAErE,eAAO,MAAM,qBAAqB;;;;;;;;;;;iBAKhC,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqB5C,CAAA;AAEF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAE3F,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGlD,CAAA;AAEF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uCAAuC,CAAC,CAAA;AAEvG,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBH,CAAA;AAEzC,MAAM,MAAM,8BAA8B,GAAG,aAAa,CAAC,OAAO,+BAA+B,CAAC,CAAA"}

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

@@ -25,6 +25,7 @@ declare const ClientNetworkStatsSchema: z.ZodObject<{
     rttMs: z.ZodNumber;
     jitterMs: z.ZodNumber;
     estimatedBandwidthKbps: z.ZodNumber;
+    packetLossPercent: z.ZodNumber;
     lastUpdated: z.ZodNumber;
 }, z.core.$strip>;
 declare const DeviceNetworkStatsSchema: z.ZodObject<{
@@ -40,6 +41,7 @@ declare const DeviceNetworkStatsSchema: z.ZodObject<{
         rttMs: z.ZodNumber;
         jitterMs: z.ZodNumber;
         estimatedBandwidthKbps: z.ZodNumber;
+        packetLossPercent: z.ZodNumber;
         lastUpdated: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>;
@@ -63,6 +65,7 @@ export declare const networkQualityCapability: {
                 rttMs: z.ZodNumber;
                 jitterMs: z.ZodNumber;
                 estimatedBandwidthKbps: z.ZodNumber;
+                packetLossPercent: z.ZodNumber;
                 lastUpdated: z.ZodNumber;
             }, z.core.$strip>>;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
@@ -79,6 +82,7 @@ export declare const networkQualityCapability: {
                 rttMs: z.ZodNumber;
                 jitterMs: z.ZodNumber;
                 estimatedBandwidthKbps: z.ZodNumber;
+                packetLossPercent: z.ZodNumber;
                 lastUpdated: z.ZodNumber;
             }, z.core.$strip>>;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
@@ -87,6 +91,7 @@ export declare const networkQualityCapability: {
             rttMs: z.ZodNumber;
             jitterMs: z.ZodNumber;
             estimatedBandwidthKbps: z.ZodNumber;
+            packetLossPercent: z.ZodNumber;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
     };
 };

package/dist/capabilities/network-quality.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network-quality.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/network-quality.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;;;;;;;;;;GAaG;AAEH,QAAA,MAAM,wBAAwB;;;;;;iBAM5B,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;iBAK5B,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;iBAI5B,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBI,CAAA;AAEzC,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEpF,OAAO,EACL,wBAAwB,EACxB,wBAAwB,EACxB,wBAAwB,GACzB,CAAA"}
+{"version":3,"file":"network-quality.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/network-quality.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;;;;;;;;;;GAaG;AAEH,QAAA,MAAM,wBAAwB;;;;;;iBAM5B,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;iBAM5B,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;iBAI5B,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBI,CAAA;AAEzC,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEpF,OAAO,EACL,wBAAwB,EACxB,wBAAwB,EACxB,wBAAwB,GACzB,CAAA"}

package/dist/capabilities/notifier.cap.d.ts

@@ -0,0 +1,173 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Notification delivery cap. Models HA `notify.<service>` plus future
+ * native targets (Telegram / Discord / ntfy / SMTP, …). Designed at
+ * the same structural level as a camera cap: rich multi-method
+ * surface, full status diagnostics, explicit `supports` matrix so
+ * the UI gates compose-form fields without probing the provider.
+ *
+ * One Notifier device per delivery endpoint — HA's `notify.mobile_app_*`
+ * (one per phone), `notify.telegram_*` (one per chat target), etc.
+ * The DeviceRole sub-role (MobilePushNotifier / MessagingNotifier /
+ * EmailNotifier / GenericNotifier) discriminates the rendering style
+ * of the compose form.
+ *
+ * Sub-feature support (image / priority / data / actions / multi-
+ * recipient) is signaled by:
+ *  - the device's `DeviceFeature` bits — fast scalar check for list
+ *    filters and grid icons (DeviceFeature.NotifierImage etc.); AND
+ *  - the slice's `supports` block — authoritative read after device
+ *    detail is opened.
+ */
+declare const NotifierPrioritySchema: z.ZodEnum<{
+    high: "high";
+    low: "low";
+    normal: "normal";
+    min: "min";
+}>;
+export type NotifierPriority = z.infer<typeof NotifierPrioritySchema>;
+declare const NotifierActionSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    uri: z.ZodOptional<z.ZodURL>;
+    destructive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type NotifierAction = z.infer<typeof NotifierActionSchema>;
+declare const NotifierSupportsSchema: z.ZodObject<{
+    image: z.ZodBoolean;
+    priority: z.ZodBoolean;
+    data: z.ZodBoolean;
+    actions: z.ZodBoolean;
+    recipients: z.ZodBoolean;
+}, z.core.$strip>;
+export type NotifierSupports = z.infer<typeof NotifierSupportsSchema>;
+export declare const NotifierStatusSchema: z.ZodObject<{
+    lastSentAt: z.ZodNumber;
+    lastError: z.ZodNullable<z.ZodString>;
+    queueDepth: z.ZodNumber;
+    supports: z.ZodObject<{
+        image: z.ZodBoolean;
+        priority: z.ZodBoolean;
+        data: z.ZodBoolean;
+        actions: z.ZodBoolean;
+        recipients: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type NotifierStatus = z.infer<typeof NotifierStatusSchema>;
+declare const NotifierSendInputSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    title: z.ZodOptional<z.ZodString>;
+    body: z.ZodString;
+    image: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        normal: "normal";
+        min: "min";
+    }>>;
+    channel: z.ZodOptional<z.ZodString>;
+    recipients: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        uri: z.ZodOptional<z.ZodURL>;
+        destructive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const NotifierSendResultSchema: z.ZodObject<{
+    notificationId: z.ZodString;
+    acceptedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type NotifierSendInput = z.infer<typeof NotifierSendInputSchema>;
+export type NotifierSendResult = z.infer<typeof NotifierSendResultSchema>;
+export declare const notifierCapability: {
+    readonly name: "notifier";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Notifier];
+    readonly methods: {
+        readonly send: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            title: z.ZodOptional<z.ZodString>;
+            body: z.ZodString;
+            image: z.ZodOptional<z.ZodString>;
+            priority: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                normal: "normal";
+                min: "min";
+            }>>;
+            channel: z.ZodOptional<z.ZodString>;
+            recipients: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                uri: z.ZodOptional<z.ZodURL>;
+                destructive: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            notificationId: z.ZodString;
+            acceptedAt: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+        readonly cancel: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            notificationId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly events: {
+        /**
+         * Emitted after every send attempt — success or failure. Subscribers
+         * (admin UI history pane, automation engines, retry workers) react
+         * without polling the provider's `lastSentAt`.
+         */
+        readonly onSent: {
+            readonly data: z.ZodObject<{
+                deviceId: z.ZodNumber;
+                notificationId: z.ZodString;
+                success: z.ZodBoolean;
+                error: z.ZodNullable<z.ZodString>;
+                acceptedAt: z.ZodNumber;
+            }, z.core.$strip>;
+        };
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            lastSentAt: z.ZodNumber;
+            lastError: z.ZodNullable<z.ZodString>;
+            queueDepth: z.ZodNumber;
+            supports: z.ZodObject<{
+                image: z.ZodBoolean;
+                priority: z.ZodBoolean;
+                data: z.ZodBoolean;
+                actions: z.ZodBoolean;
+                recipients: z.ZodBoolean;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        readonly kind: "command-driven";
+    };
+    /**
+     * Runtime-state slice — diagnostics + supports matrix. UI compose
+     * form reads `supports` to gate optional fields; history pane reads
+     * `lastSentAt` / `lastError` / `queueDepth`.
+     */
+    readonly runtimeState: z.ZodObject<{
+        lastSentAt: z.ZodNumber;
+        lastError: z.ZodNullable<z.ZodString>;
+        queueDepth: z.ZodNumber;
+        supports: z.ZodObject<{
+            image: z.ZodBoolean;
+            priority: z.ZodBoolean;
+            data: z.ZodBoolean;
+            actions: z.ZodBoolean;
+            recipients: z.ZodBoolean;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+};
+export type INotifierProvider = InferProvider<typeof notifierCapability>;
+export {};
+//# sourceMappingURL=notifier.cap.d.ts.map

package/dist/capabilities/notifier.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifier.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/notifier.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,QAAA,MAAM,sBAAsB;;;;;EAA2C,CAAA;AACvE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,QAAA,MAAM,oBAAoB;;;;;iBAUxB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,QAAA,MAAM,sBAAsB;;;;;;iBAa1B,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;;;iBAY/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;iBAqB3B,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;iBAK5B,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACvE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAsB3B;;;;WAIG;;;;;;;;;;;;;;;;;;;;;;;;;;IAaL;;;;OAIG;;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,OAAO,kBAAkB,CAAC,CAAA"}