@camstack/types 0.1.39 → 0.1.41

package/dist/capabilities/device-ops.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"device-ops.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/device-ops.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAqClG,eAAO,MAAM,mBAAmB;;;;;QAK5B;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAMH;;;WAGG;;;;;;;QAMH;;;;WAIG;;;;;QAUH;;;;WAIG;;;;QAOH;;;;;;;;;;;;;WAaG;;;;;CAMkC,CAAA;AAEzC,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,mBAAmB,CAAC,CAAA"}
+{"version":3,"file":"device-ops.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/device-ops.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAsClG,eAAO,MAAM,oBAAoB;;;iBAK/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,mBAAmB;;;;;;QAY5B;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAMH;;;WAGG;;;;;;;QAMH;;;;WAIG;;;;;QAUH;;;;;WAKG;;;;;;QAWH;;;;WAIG;;;;QAOH;;;;;;;;;;;;;WAaG;;;;QAMH;;;;;;WAMG;;;;;;;;CAOkC,CAAA;AAEzC,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/capabilities/device-provider.cap.d.ts

@@ -22,6 +22,12 @@ declare const DiscoveryCandidateSchema: z.ZodObject<{
     type: z.ZodEnum<typeof DeviceType>;
     suggestedName: z.ZodString;
     prefilledConfig: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    sourceInfo: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        system: z.ZodString;
+        uniqueId: z.ZodOptional<z.ZodString>;
+        raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * Flat device summary returned by `createDevice` / `adoptDiscoveredDevice`.
@@ -38,6 +44,12 @@ declare const DeviceSummarySchema: z.ZodObject<{
     online: z.ZodBoolean;
     features: z.ZodArray<z.ZodString>;
     config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    sourceInfo: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        system: z.ZodString;
+        uniqueId: z.ZodOptional<z.ZodString>;
+        raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * Result of a live field test (e.g. probing an RTSP URL during device
@@ -76,6 +88,12 @@ export declare const deviceProviderCapability: {
             type: z.ZodEnum<typeof DeviceType>;
             suggestedName: z.ZodString;
             prefilledConfig: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            sourceInfo: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                system: z.ZodString;
+                uniqueId: z.ZodOptional<z.ZodString>;
+                raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>, "mutation">;
         readonly adoptDiscoveredDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             candidate: z.ZodObject<{
@@ -83,6 +101,12 @@ export declare const deviceProviderCapability: {
                 type: z.ZodEnum<typeof DeviceType>;
                 suggestedName: z.ZodString;
                 prefilledConfig: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                sourceInfo: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodString;
+                    system: z.ZodString;
+                    uniqueId: z.ZodOptional<z.ZodString>;
+                    raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>;
             }, z.core.$strip>;
         }, z.core.$strip>, z.ZodObject<{
             id: z.ZodNumber;
@@ -94,6 +118,12 @@ export declare const deviceProviderCapability: {
             online: z.ZodBoolean;
             features: z.ZodArray<z.ZodString>;
             config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            sourceInfo: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                system: z.ZodString;
+                uniqueId: z.ZodOptional<z.ZodString>;
+                raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>, "mutation">;
         readonly supportsManualCreation: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
         /**
@@ -118,6 +148,12 @@ export declare const deviceProviderCapability: {
             online: z.ZodBoolean;
             features: z.ZodArray<z.ZodString>;
             config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            sourceInfo: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                system: z.ZodString;
+                uniqueId: z.ZodOptional<z.ZodString>;
+                raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>, "mutation">;
         /**
          * Test a single field in the creation form before the device has

package/dist/capabilities/device-provider.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"device-provider.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/device-provider.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,QAAA,MAAM,oBAAoB;;;;iBAIxB,CAAA;AAEF,QAAA,MAAM,sBAAsB;;;;;iBAK1B,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,wBAAwB;;;;;iBAK5B,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,mBAAmB;;;;;;;;;;iBAUvB,CAAA;AAEF;;;;;GAKG;AACH,QAAA,MAAM,sBAAsB;;;;;;;iBAI1B,CAAA;AAYF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA8BjC;;;;;WAKG;;;;;;;;;;;;;;;;;;QAaH;;;;;;;;;;;WAWG;;;;;;;;;;;;;;;CAYkC,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE5E,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,wBAAwB,EACxB,mBAAmB,EACnB,sBAAsB,GACvB,CAAA"}
+{"version":3,"file":"device-provider.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/device-provider.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;AAGrD,QAAA,MAAM,oBAAoB;;;;iBAIxB,CAAA;AAEF,QAAA,MAAM,sBAAsB;;;;;iBAK1B,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,wBAAwB;;;;;;;;;;;iBAY5B,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAevB,CAAA;AAEF;;;;;GAKG;AACH,QAAA,MAAM,sBAAsB;;;;;;;iBAI1B,CAAA;AAYF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA8BjC;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;QAaH;;;;;;;;;;;WAWG;;;;;;;;;;;;;;;CAYkC,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE5E,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,wBAAwB,EACxB,mBAAmB,EACnB,sBAAsB,GACvB,CAAA"}

package/dist/capabilities/device-status.cap.d.ts

@@ -23,6 +23,7 @@ export type DeviceStatus = z.infer<typeof DeviceStatusSchema>;
 export declare const deviceStatusCapability: {
     readonly name: "device-status";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly methods: {};
     readonly events: {

package/dist/capabilities/device-status.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"device-status.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/device-status.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAE1F;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB;;;iBAY7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,sBAAsB;;;;;;QAM/B;yCACiC;;;;;;;;;;;;;;;;;;;;;;CAWI,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA"}
+{"version":3,"file":"device-status.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/device-status.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAE1F;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB;;;iBAY7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,sBAAsB;;;;;;;QAO/B;yCACiC;;;;;;;;;;;;;;;;;;;;;;CAWI,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

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

@@ -24,6 +24,7 @@ export type DoorbellPressEvent = z.infer<typeof DoorbellPressEventSchema>;
 export declare const doorbellCapability: {
     readonly name: "doorbell";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Button];
     readonly methods: {};

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

@@ -1 +1 @@
-{"version":3,"file":"doorbell.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/doorbell.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB;;;iBAK/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,wBAAwB;;;iBAGnC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,eAAO,MAAM,kBAAkB;;;;;;;QAO3B;;;;WAIG;;;;;;;;;;;;;;;IAOL;;;;;OAKG;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,OAAO,kBAAkB,CAAC,CAAA"}
+{"version":3,"file":"doorbell.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/doorbell.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB;;;iBAK/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,wBAAwB;;;iBAGnC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,eAAO,MAAM,kBAAkB;;;;;;;;QAQ3B;;;;WAIG;;;;;;;;;;;;;;;IAOL;;;;;OAKG;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/capabilities/enum-sensor.cap.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Enum-state sensor — a string value picked from a finite option set.
+ * Drives HA `sensor` entries with `state_class: enum` (HVAC action
+ * states, weather conditions, contact-source channels, mode strings).
+ * The option set is stable across observations; it is persisted in the
+ * device config blob (via the control slice at adoption) and is NOT
+ * stored in `sourceInfo`.
+ */
+/** Locale-render shape for an ISO `value` carried by a `DateTimeSensor`-role
+ *  enum sensor: `date` (date-only), `time` (time-only), `datetime` (both). */
+export declare const EnumSensorDateTimeFormatSchema: z.ZodEnum<{
+    date: "date";
+    datetime: "datetime";
+    time: "time";
+}>;
+export type EnumSensorDateTimeFormat = z.infer<typeof EnumSensorDateTimeFormatSchema>;
+export declare const EnumSensorStatusSchema: z.ZodObject<{
+    value: z.ZodString;
+    format: z.ZodOptional<z.ZodEnum<{
+        date: "date";
+        datetime: "datetime";
+        time: "time";
+    }>>;
+    lastFetchedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type EnumSensorStatus = z.infer<typeof EnumSensorStatusSchema>;
+export declare const enumSensorCapability: {
+    readonly name: "enum-sensor";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Sensor];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            value: z.ZodString;
+            format: z.ZodOptional<z.ZodEnum<{
+                date: "date";
+                datetime: "datetime";
+                time: "time";
+            }>>;
+            lastFetchedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    readonly runtimeState: z.ZodObject<{
+        value: z.ZodString;
+        format: z.ZodOptional<z.ZodEnum<{
+            date: "date";
+            datetime: "datetime";
+            time: "time";
+        }>>;
+        lastFetchedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IEnumSensorProvider = InferProvider<typeof enumSensorCapability>;
+//# sourceMappingURL=enum-sensor.cap.d.ts.map

package/dist/capabilities/enum-sensor.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum-sensor.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/enum-sensor.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;GAOG;AACH;8EAC8E;AAC9E,eAAO,MAAM,8BAA8B;;;;EAAuC,CAAA;AAElF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF,eAAO,MAAM,sBAAsB;;;;;;;;iBAWjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYQ,CAAA;AAEzC,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/capabilities/event-emitter.cap.d.ts

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Generic stateless event emitter. Installed on a `DeviceType.EventEmitter`
+ * device. Carries the device's EXACT declared event vocabulary verbatim
+ * (NO normalization). Two shapes:
+ *  - structured source (HA `event.*` entity) → `eventTypes` is the fixed
+ *    declared vocabulary (e.g. ['press_short','press_long',...]).
+ *  - generic/legacy source (HA bus events, e.g. zha_event) → `eventTypes`
+ *    is [] (open) and `lastEvent.data` carries the complex payload.
+ * `seq` is monotonic so two identical events still produce distinct slice writes.
+ */
+export declare const EventFireSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    eventType: z.ZodString;
+    data: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    timestamp: z.ZodNumber;
+    seq: z.ZodNumber;
+}, z.core.$strip>;
+export type EventFire = z.infer<typeof EventFireSchema>;
+export declare const EventEmitterStatusSchema: z.ZodObject<{
+    eventTypes: z.ZodArray<z.ZodString>;
+    lastEvent: z.ZodNullable<z.ZodObject<{
+        deviceId: z.ZodNumber;
+        eventType: z.ZodString;
+        data: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        timestamp: z.ZodNumber;
+        seq: z.ZodNumber;
+    }, z.core.$strip>>;
+    eventCountSinceStart: z.ZodNumber;
+}, z.core.$strip>;
+export type EventEmitterStatus = z.infer<typeof EventEmitterStatusSchema>;
+export declare const eventEmitterCapability: {
+    readonly name: "event-emitter";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.EventEmitter];
+    readonly methods: {};
+    readonly events: {
+        readonly onEvent: {
+            readonly data: z.ZodObject<{
+                deviceId: z.ZodNumber;
+                eventType: z.ZodString;
+                data: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                timestamp: z.ZodNumber;
+                seq: z.ZodNumber;
+            }, z.core.$strip>;
+        };
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            eventTypes: z.ZodArray<z.ZodString>;
+            lastEvent: z.ZodNullable<z.ZodObject<{
+                deviceId: z.ZodNumber;
+                eventType: z.ZodString;
+                data: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                timestamp: z.ZodNumber;
+                seq: z.ZodNumber;
+            }, z.core.$strip>>;
+            eventCountSinceStart: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    readonly runtimeState: z.ZodObject<{
+        eventTypes: z.ZodArray<z.ZodString>;
+        lastEvent: z.ZodNullable<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            eventType: z.ZodString;
+            data: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            timestamp: z.ZodNumber;
+            seq: z.ZodNumber;
+        }, z.core.$strip>>;
+        eventCountSinceStart: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IEventEmitterProvider = InferProvider<typeof eventEmitterCapability>;
+//# sourceMappingURL=event-emitter.cap.d.ts.map

package/dist/capabilities/event-emitter.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-emitter.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/event-emitter.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;;;;;;iBAM1B,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD,eAAO,MAAM,wBAAwB;;;;;;;;;;iBAInC,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUM,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

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

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Fan-control cap. Models HA `fan.*` entity-specific surfaces:
+ * speed percentage, preset modes, ceiling-fan direction, and
+ * oscillation. The on/off state lives on the existing `switch` cap
+ * (Fan devices register `switch + fan-control`, mirroring the
+ * Light pattern of `switch + brightness + color`).
+ *
+ * `availablePresets` mirrors HA's `preset_modes` attribute so the
+ * UI renders a closed-list picker without a separate `getOptions`
+ * round-trip. `direction` and `oscillating` are nullable — most
+ * fans don't expose them.
+ *
+ * Sub-surface gating paired with `DeviceFeature` flags:
+ *   - `FanSpeed` — speed-percentage slider
+ *   - `FanPreset` — preset selector
+ *   - `FanDirection` — direction toggle (ceiling fans)
+ *   - `FanOscillating` — oscillation toggle
+ */
+export declare const FanDirectionSchema: z.ZodEnum<{
+    reverse: "reverse";
+    forward: "forward";
+}>;
+export type FanDirection = z.infer<typeof FanDirectionSchema>;
+export declare const FanControlStatusSchema: z.ZodObject<{
+    percentage: z.ZodNullable<z.ZodNumber>;
+    percentageStep: z.ZodOptional<z.ZodNumber>;
+    preset: z.ZodString;
+    availablePresets: z.ZodArray<z.ZodString>;
+    direction: z.ZodNullable<z.ZodEnum<{
+        reverse: "reverse";
+        forward: "forward";
+    }>>;
+    oscillating: z.ZodNullable<z.ZodBoolean>;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type FanControlStatus = z.infer<typeof FanControlStatusSchema>;
+export declare const fanControlCapability: {
+    readonly name: "fan-control";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Fan];
+    readonly methods: {
+        readonly setPercentage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            percentage: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly setPreset: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            preset: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly setDirection: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            direction: z.ZodEnum<{
+                reverse: "reverse";
+                forward: "forward";
+            }>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly setOscillating: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            oscillating: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            percentage: z.ZodNullable<z.ZodNumber>;
+            percentageStep: z.ZodOptional<z.ZodNumber>;
+            preset: z.ZodString;
+            availablePresets: z.ZodArray<z.ZodString>;
+            direction: z.ZodNullable<z.ZodEnum<{
+                reverse: "reverse";
+                forward: "forward";
+            }>>;
+            oscillating: z.ZodNullable<z.ZodBoolean>;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — mirrored by the kernel. UI fan speed
+     * sliders read `percentage` for live updates.
+     */
+    readonly runtimeState: z.ZodObject<{
+        percentage: z.ZodNullable<z.ZodNumber>;
+        percentageStep: z.ZodOptional<z.ZodNumber>;
+        preset: z.ZodString;
+        availablePresets: z.ZodArray<z.ZodString>;
+        direction: z.ZodNullable<z.ZodEnum<{
+            reverse: "reverse";
+            forward: "forward";
+        }>>;
+        oscillating: z.ZodNullable<z.ZodBoolean>;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IFanControlProvider = InferProvider<typeof fanControlCapability>;
+//# sourceMappingURL=fan-control.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fan-control.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/fan-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;;;;;;;;;;;;;;;;;GAiBG;AAEH,eAAO,MAAM,kBAAkB;;;EAAiC,CAAA;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,sBAAsB;;;;;;;;;;;iBAoBjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4C/B;;;OAGG;;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/capabilities/feature-probe.cap.d.ts

@@ -36,6 +36,7 @@ export type FeatureProbeStatus = z.infer<typeof FeatureProbeStatusSchema>;
 export declare const featureProbeCapability: {
     readonly name: "feature-probe";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly methods: {};
     readonly events: {

package/dist/capabilities/feature-probe.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-probe.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/feature-probe.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAE1F;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,wBAAwB;;;;;;;iBAgCnC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,eAAO,MAAM,sBAAsB;;;;;;QAM/B;mEAC2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWtB,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA"}
+{"version":3,"file":"feature-probe.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/feature-probe.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAE1F;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,wBAAwB;;;;;;;iBAgCnC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,eAAO,MAAM,sBAAsB;;;;;;;QAO/B;mEAC2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWtB,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

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

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Water leak / moisture sensor. Boolean "is liquid currently
+ * detected" with the timestamp of the last transition. Drives Home
+ * Assistant `binary_sensor` entries with `device_class: moisture`,
+ * and any future native flood sensor.
+ *
+ * Push-driven from the upstream source.
+ */
+export declare const FloodStatusSchema: z.ZodObject<{
+    flooded: z.ZodBoolean;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type FloodStatus = z.infer<typeof FloodStatusSchema>;
+export declare const floodCapability: {
+    readonly name: "flood";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Sensor];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            flooded: z.ZodBoolean;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    readonly runtimeState: z.ZodObject<{
+        flooded: z.ZodBoolean;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IFloodProvider = InferProvider<typeof floodCapability>;
+//# sourceMappingURL=flood.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flood.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/flood.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;iBAK5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;CAYa,CAAA;AAEzC,MAAM,MAAM,cAAc,GAAG,aAAa,CAAC,OAAO,eAAe,CAAC,CAAA"}

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

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Combustible-gas (LPG / methane / hydrogen) alarm sensor. Drives
+ * Home Assistant `binary_sensor` entries with `device_class: gas`.
+ * Push-driven.
+ */
+export declare const GasStatusSchema: z.ZodObject<{
+    detected: z.ZodBoolean;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type GasStatus = z.infer<typeof GasStatusSchema>;
+export declare const gasCapability: {
+    readonly name: "gas";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Sensor];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            detected: z.ZodBoolean;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    readonly runtimeState: z.ZodObject<{
+        detected: z.ZodBoolean;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IGasProvider = InferProvider<typeof gasCapability>;
+//# sourceMappingURL=gas.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gas.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/gas.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;iBAI1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;CAYe,CAAA;AAEzC,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC,OAAO,aAAa,CAAC,CAAA"}

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

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Humidifier / dehumidifier cap. Models HA `humidifier.*` entities —
+ * an on/off actuator with an optional target-humidity setpoint and an
+ * optional vendor mode (`auto` / `normal` / `baby` / …).
+ *
+ * A climate-family sibling: the slice carries the on/off state, the
+ * current + target relative humidity (0..100), the active mode and its
+ * available set, plus HA's free-form `action` readout
+ * (`humidifying` / `drying` / `idle` / `off`). `minHumidity` /
+ * `maxHumidity` mirror HA's `min_humidity` / `max_humidity` attributes
+ * (null → the UI falls back to a 0..100 range).
+ *
+ * Providers populate only what the hardware reports — `mode` and the
+ * humidity fields stay null when the device has no such surface.
+ */
+export declare const HumidifierStatusSchema: z.ZodObject<{
+    on: z.ZodBoolean;
+    currentHumidity: z.ZodNullable<z.ZodNumber>;
+    targetHumidity: z.ZodNullable<z.ZodNumber>;
+    mode: z.ZodNullable<z.ZodString>;
+    availableModes: z.ZodArray<z.ZodString>;
+    action: z.ZodNullable<z.ZodString>;
+    minHumidity: z.ZodNullable<z.ZodNumber>;
+    maxHumidity: z.ZodNullable<z.ZodNumber>;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type HumidifierStatus = z.infer<typeof HumidifierStatusSchema>;
+export declare const humidifierCapability: {
+    readonly name: "humidifier";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Humidifier];
+    readonly methods: {
+        readonly setOn: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            on: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly setTargetHumidity: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            humidity: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly setMode: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            mode: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            on: z.ZodBoolean;
+            currentHumidity: z.ZodNullable<z.ZodNumber>;
+            targetHumidity: z.ZodNullable<z.ZodNumber>;
+            mode: z.ZodNullable<z.ZodString>;
+            availableModes: z.ZodArray<z.ZodString>;
+            action: z.ZodNullable<z.ZodString>;
+            minHumidity: z.ZodNullable<z.ZodNumber>;
+            maxHumidity: 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 humidity / mode changes.
+     */
+    readonly runtimeState: z.ZodObject<{
+        on: z.ZodBoolean;
+        currentHumidity: z.ZodNullable<z.ZodNumber>;
+        targetHumidity: z.ZodNullable<z.ZodNumber>;
+        mode: z.ZodNullable<z.ZodString>;
+        availableModes: z.ZodArray<z.ZodString>;
+        action: z.ZodNullable<z.ZodString>;
+        minHumidity: z.ZodNullable<z.ZodNumber>;
+        maxHumidity: z.ZodNullable<z.ZodNumber>;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IHumidifierProvider = InferProvider<typeof humidifierCapability>;
+//# sourceMappingURL=humidifier.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"humidifier.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/humidifier.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;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;iBAqBjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoC/B;;;OAGG;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/capabilities/humidity-sensor.cap.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Single-metric humidity reading. Drives Home Assistant `sensor`
+ * entries with `device_class: humidity`.
+ *
+ * Unit normalisation: percent. The canonical display unit (`%`) is a
+ * descriptor constant in the UI (ROLE_DESCRIPTOR), not stored in
+ * `sourceInfo`.
+ */
+export declare const HumiditySensorStatusSchema: z.ZodObject<{
+    percent: z.ZodNumber;
+    lastFetchedAt: z.ZodNumber;
+    unit: z.ZodOptional<z.ZodString>;
+    precision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type HumiditySensorStatus = z.infer<typeof HumiditySensorStatusSchema>;
+export declare const humiditySensorCapability: {
+    readonly name: "humidity-sensor";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Sensor, DeviceType.Thermostat];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            percent: z.ZodNumber;
+            lastFetchedAt: z.ZodNumber;
+            unit: z.ZodOptional<z.ZodString>;
+            precision: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    readonly runtimeState: z.ZodObject<{
+        percent: z.ZodNumber;
+        lastFetchedAt: z.ZodNumber;
+        unit: z.ZodOptional<z.ZodString>;
+        precision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+};
+export type IHumiditySensorProvider = InferProvider<typeof humiditySensorCapability>;
+//# sourceMappingURL=humidity-sensor.cap.d.ts.map

package/dist/capabilities/humidity-sensor.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"humidity-sensor.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/humidity-sensor.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B;;;;;iBAcrC,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;CAYI,CAAA;AAEzC,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC,OAAO,wBAAwB,CAAC,CAAA"}

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

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Image display cap. Models HA `image.*` entities — a single still image
+ * exposed by an integration (a snapshot, a chart, a generated picture).
+ *
+ * Read-only: there are no setters. The provider resolves the HA
+ * `entity_picture` (a relative, signed-token path) into an ABSOLUTE URL
+ * the browser loads directly — the token stays in the query string so no
+ * auth header is required. The slice carries that URL plus the upstream
+ * last-updated timestamp; the image changes when the entity state (a
+ * timestamp) changes.
+ */
+export declare const ImageStatusSchema: z.ZodObject<{
+    url: z.ZodNullable<z.ZodString>;
+    lastUpdated: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type ImageStatus = z.infer<typeof ImageStatusSchema>;
+export declare const imageCapability: {
+    readonly name: "image";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Image];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            url: z.ZodNullable<z.ZodString>;
+            lastUpdated: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — mirrored by the kernel. The UI reads `url`
+     * directly and renders the still image.
+     */
+    readonly runtimeState: z.ZodObject<{
+        url: z.ZodNullable<z.ZodString>;
+        lastUpdated: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+};
+export type IImageProvider = InferProvider<typeof imageCapability>;
+//# sourceMappingURL=image.cap.d.ts.map