@camstack/types 0.1.39 → 0.1.41

package/dist/capabilities/alarm-panel.cap.d.ts

@@ -0,0 +1,154 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Alarm-panel cap. Models HA `alarm_control_panel.*` on
+ * `DeviceType.AlarmPanel`. State follows HA's canonical lifecycle
+ * across disarmed / armed_(home|away|night|vacation|custom_bypass) /
+ * arming / pending / triggered / disarming.
+ *
+ * Many panels require a PIN code on arm / disarm — the optional
+ * `code` field on the methods passes it through to the upstream
+ * service; it's NEVER persisted in the runtime slice or any event
+ * payload. The presence of a required code is signalled by
+ * `DeviceFeature.AlarmPinRequired` so the UI gates a code-entry
+ * field without a slice fetch.
+ *
+ * `availableModes` mirrors HA's `supported_features`-derived arm
+ * mode list — the UI renders only the buttons the panel accepts.
+ */
+export declare const AlarmStateSchema: z.ZodEnum<{
+    pending: "pending";
+    disarmed: "disarmed";
+    armed_home: "armed_home";
+    armed_away: "armed_away";
+    armed_night: "armed_night";
+    armed_vacation: "armed_vacation";
+    armed_custom_bypass: "armed_custom_bypass";
+    arming: "arming";
+    disarming: "disarming";
+    triggered: "triggered";
+}>;
+export type AlarmState = z.infer<typeof AlarmStateSchema>;
+export declare const AlarmArmModeSchema: z.ZodEnum<{
+    home: "home";
+    away: "away";
+    night: "night";
+    vacation: "vacation";
+    custom_bypass: "custom_bypass";
+}>;
+export type AlarmArmMode = z.infer<typeof AlarmArmModeSchema>;
+export declare const AlarmPanelStatusSchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        pending: "pending";
+        disarmed: "disarmed";
+        armed_home: "armed_home";
+        armed_away: "armed_away";
+        armed_night: "armed_night";
+        armed_vacation: "armed_vacation";
+        armed_custom_bypass: "armed_custom_bypass";
+        arming: "arming";
+        disarming: "disarming";
+        triggered: "triggered";
+    }>;
+    availableModes: z.ZodArray<z.ZodEnum<{
+        home: "home";
+        away: "away";
+        night: "night";
+        vacation: "vacation";
+        custom_bypass: "custom_bypass";
+    }>>;
+    requiresCode: z.ZodBoolean;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type AlarmPanelStatus = z.infer<typeof AlarmPanelStatusSchema>;
+export declare const alarmPanelCapability: {
+    readonly name: "alarm-panel";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.AlarmPanel];
+    readonly methods: {
+        readonly arm: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            mode: z.ZodEnum<{
+                home: "home";
+                away: "away";
+                night: "night";
+                vacation: "vacation";
+                custom_bypass: "custom_bypass";
+            }>;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly disarm: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /**
+         * Force the panel into the `triggered` state — used by HA
+         * automations to surface external sensor events through the panel
+         * (e.g. a Reolink camera intrusion event firing the security
+         * system). Provider rejects when the panel hardware doesn't
+         * support a software-initiated trigger.
+         */
+        readonly trigger: 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<{
+                pending: "pending";
+                disarmed: "disarmed";
+                armed_home: "armed_home";
+                armed_away: "armed_away";
+                armed_night: "armed_night";
+                armed_vacation: "armed_vacation";
+                armed_custom_bypass: "armed_custom_bypass";
+                arming: "arming";
+                disarming: "disarming";
+                triggered: "triggered";
+            }>;
+            availableModes: z.ZodArray<z.ZodEnum<{
+                home: "home";
+                away: "away";
+                night: "night";
+                vacation: "vacation";
+                custom_bypass: "custom_bypass";
+            }>>;
+            requiresCode: z.ZodBoolean;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — mirrored by the kernel. UI panel reads the
+     * full slice; renders an arm button per `availableModes` entry and
+     * a PIN field iff `requiresCode === true`.
+     */
+    readonly runtimeState: z.ZodObject<{
+        state: z.ZodEnum<{
+            pending: "pending";
+            disarmed: "disarmed";
+            armed_home: "armed_home";
+            armed_away: "armed_away";
+            armed_night: "armed_night";
+            armed_vacation: "armed_vacation";
+            armed_custom_bypass: "armed_custom_bypass";
+            arming: "arming";
+            disarming: "disarming";
+            triggered: "triggered";
+        }>;
+        availableModes: z.ZodArray<z.ZodEnum<{
+            home: "home";
+            away: "away";
+            night: "night";
+            vacation: "vacation";
+            custom_bypass: "custom_bypass";
+        }>>;
+        requiresCode: z.ZodBoolean;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IAlarmPanelProvider = InferProvider<typeof alarmPanelCapability>;
+//# sourceMappingURL=alarm-panel.cap.d.ts.map

package/dist/capabilities/alarm-panel.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alarm-panel.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/alarm-panel.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;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;EAW3B,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,eAAO,MAAM,kBAAkB;;;;;;EAM7B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;iBAWjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;QA0B7B;;;;;;WAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWL;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

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

@@ -16,8 +16,8 @@ export declare const AlertSeveritySchema: z.ZodEnum<{
 export declare const AlertStatusSchema: z.ZodEnum<{
     active: "active";
     failed: "failed";
-    "in-progress": "in-progress";
     completed: "completed";
+    "in-progress": "in-progress";
     dismissed: "dismissed";
 }>;
 export declare const AlertSourceSchema: z.ZodObject<{
@@ -38,8 +38,8 @@ export declare const AlertSchema: z.ZodObject<{
     status: z.ZodEnum<{
         active: "active";
         failed: "failed";
-        "in-progress": "in-progress";
         completed: "completed";
+        "in-progress": "in-progress";
         dismissed: "dismissed";
     }>;
     progress: z.ZodOptional<z.ZodNumber>;
@@ -74,8 +74,8 @@ export declare const alertsCapability: {
             status: z.ZodEnum<{
                 active: "active";
                 failed: "failed";
-                "in-progress": "in-progress";
                 completed: "completed";
+                "in-progress": "in-progress";
                 dismissed: "dismissed";
             }>;
             progress: z.ZodOptional<z.ZodNumber>;
@@ -104,8 +104,8 @@ export declare const alertsCapability: {
                 status: z.ZodOptional<z.ZodEnum<{
                     active: "active";
                     failed: "failed";
-                    "in-progress": "in-progress";
                     completed: "completed";
+                    "in-progress": "in-progress";
                     dismissed: "dismissed";
                 }>>;
                 progress: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
@@ -136,8 +136,8 @@ export declare const alertsCapability: {
             status: z.ZodEnum<{
                 active: "active";
                 failed: "failed";
-                "in-progress": "in-progress";
                 completed: "completed";
+                "in-progress": "in-progress";
                 dismissed: "dismissed";
             }>;
             progress: z.ZodOptional<z.ZodNumber>;

package/dist/capabilities/ambient-light-sensor.cap.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Ambient illuminance reading in lux. Drives Home Assistant `sensor`
+ * entries with `device_class: illuminance`.
+ */
+export declare const AmbientLightSensorStatusSchema: z.ZodObject<{
+    lux: z.ZodNumber;
+    lastFetchedAt: z.ZodNumber;
+    unit: z.ZodOptional<z.ZodString>;
+    precision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type AmbientLightSensorStatus = z.infer<typeof AmbientLightSensorStatusSchema>;
+export declare const ambientLightSensorCapability: {
+    readonly name: "ambient-light-sensor";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Sensor];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            lux: 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<{
+        lux: z.ZodNumber;
+        lastFetchedAt: z.ZodNumber;
+        unit: z.ZodOptional<z.ZodString>;
+        precision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+};
+export type IAmbientLightSensorProvider = InferProvider<typeof ambientLightSensorCapability>;
+//# sourceMappingURL=ambient-light-sensor.cap.d.ts.map

package/dist/capabilities/ambient-light-sensor.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambient-light-sensor.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/ambient-light-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;;;GAGG;AACH,eAAO,MAAM,8BAA8B;;;;;iBAczC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;CAYA,CAAA;AAEzC,MAAM,MAAM,2BAA2B,GAAG,aAAa,CAAC,OAAO,4BAA4B,CAAC,CAAA"}

package/dist/capabilities/audio-analyzer.cap.d.ts

@@ -85,7 +85,7 @@ export declare const audioAnalyzerCapability: {
     readonly methods: {
         readonly analyseChunk: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             chunk: z.ZodObject<{
-                data: z.ZodCustom<Float32Array<ArrayBuffer>, Float32Array<ArrayBuffer>>;
+                data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
                 sampleRate: z.ZodNumber;
                 channels: z.ZodNumber;
                 timestamp: z.ZodNumber;
@@ -111,7 +111,7 @@ export declare const audioAnalyzerCapability: {
             timestamp: z.ZodNumber;
         }, z.core.$strip>>, "mutation">;
         readonly classify: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            data: z.ZodCustom<Float32Array<ArrayBuffer>, Float32Array<ArrayBuffer>>;
+            data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
             sampleRate: z.ZodNumber;
             channels: z.ZodNumber;
             timestamp: z.ZodNumber;

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

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Automation-control cap. Models HA `automation.*` entities on
+ * `DeviceType.Automation`. An automation is a trigger+condition+
+ * action rule that can be enabled / disabled and manually fired
+ * via the `trigger` method.
+ *
+ * `trigger` accepts an optional `skipCondition` flag — when true,
+ * the automation's action block runs WITHOUT evaluating its
+ * condition block. Pair with `DeviceFeature.AutomationSkipCondition`
+ * to gate the UI checkbox for the manual-trigger dialog.
+ */
+export declare const AutomationControlStatusSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    isRunning: z.ZodBoolean;
+    lastTriggeredAt: z.ZodNumber;
+    lastError: z.ZodNullable<z.ZodString>;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type AutomationControlStatus = z.infer<typeof AutomationControlStatusSchema>;
+export declare const automationControlCapability: {
+    readonly name: "automation-control";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Automation];
+    readonly methods: {
+        readonly enable: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly disable: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly trigger: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            skipCondition: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            isRunning: z.ZodBoolean;
+            lastTriggeredAt: z.ZodNumber;
+            lastError: z.ZodNullable<z.ZodString>;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — mirrored by the kernel. UI automation tile
+     * reads `enabled` (toggle) + `isRunning` (spinner) + `lastError`
+     * (badge) directly.
+     */
+    readonly runtimeState: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        isRunning: z.ZodBoolean;
+        lastTriggeredAt: z.ZodNumber;
+        lastError: z.ZodNullable<z.ZodString>;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IAutomationControlProvider = InferProvider<typeof automationControlCapability>;
+//# sourceMappingURL=automation-control.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"automation-control.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/automation-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,6BAA6B;;;;;;iBAaxC,CAAA;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEnF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiCtC;;;;OAIG;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,0BAA0B,GAAG,aAAa,CAAC,OAAO,2BAA2B,CAAC,CAAA"}

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

@@ -17,14 +17,40 @@ export declare const BatteryStatusSchema: z.ZodObject<{
     }>;
     sleeping: z.ZodBoolean;
     lastUpdated: z.ZodNumber;
+    binary: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type BatteryStatus = z.infer<typeof BatteryStatusSchema>;
 export declare const batteryCapability: {
     readonly name: "battery";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch];
-    readonly methods: {};
+    readonly methods: {
+        /**
+         * Explicitly wake the camera from low-power sleep ahead of a
+         * streaming session start. Consumers that initiate a stream
+         * against a sleeping battery cam (HomeKit Secure Video, Alexa
+         * RTCSession, snapshot wrappers) call this with a short timeout
+         * before establishing the media pipeline — the broker's own
+         * passive wake-on-dial works but adds 5–7 seconds to first-frame,
+         * during which the consumer renders a black screen. Pre-waking
+         * compresses that gap.
+         *
+         * Returns `awoke: true` when the firmware acknowledged the wake
+         * before `timeoutMs`. Returns `awoke: false` when it timed out OR
+         * the cap surface is unavailable (no Baichuan / firmware
+         * channel); the caller should still attempt the stream — the
+         * passive broker wake remains as fallback.
+         */
+        readonly wakeForStream: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            awoke: z.ZodBoolean;
+            durationMs: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+    };
     readonly events: {
         /**
          * Emitted whenever the cached status changes (firmware push OR
@@ -44,6 +70,7 @@ export declare const batteryCapability: {
                     }>;
                     sleeping: z.ZodBoolean;
                     lastUpdated: z.ZodNumber;
+                    binary: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strip>;
             }, z.core.$strip>;
         };
@@ -58,6 +85,7 @@ export declare const batteryCapability: {
             }>;
             sleeping: z.ZodBoolean;
             lastUpdated: z.ZodNumber;
+            binary: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>;
         readonly kind: "push";
     };
@@ -79,6 +107,7 @@ export declare const batteryCapability: {
         }>;
         sleeping: z.ZodBoolean;
         lastUpdated: z.ZodNumber;
+        binary: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;
 };
 export type IBatteryProvider = InferProvider<typeof batteryCapability>;

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

@@ -1 +1 @@
-{"version":3,"file":"battery.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/battery.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;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;iBAkB9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,iBAAiB;;;;;;;QAO1B;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUL;;;;;;;;OAQG;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC,OAAO,iBAAiB,CAAC,CAAA"}
+{"version":3,"file":"battery.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/battery.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;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;iBA0B9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,iBAAiB;;;;;;;QAO1B;;;;;;;;;;;;;;;WAeG;;;;;;;;;;QAeH;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUL;;;;;;;;OAQG;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Generic boolean sensor — last-resort fallback when no domain-
+ * specific binary cap fits (Home Assistant `binary_sensor` without a
+ * known `device_class`, or a domain we haven't typed yet). Pure
+ * pass-through: just the bool + timestamp. Push-driven.
+ *
+ * Prefer the typed alternatives (`contact`, `flood`, `smoke`,
+ * `carbon-monoxide`, `gas`, `tamper`, `vibration`, `connectivity`,
+ * `motion`) when the semantics match — export adapters render those
+ * with the right HomeKit / Alexa display category.
+ */
+export declare const BinaryStatusSchema: z.ZodObject<{
+    on: z.ZodBoolean;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type BinaryStatus = z.infer<typeof BinaryStatusSchema>;
+export declare const binaryCapability: {
+    readonly name: "binary";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Sensor];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            on: z.ZodBoolean;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    readonly runtimeState: z.ZodObject<{
+        on: z.ZodBoolean;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IBinaryProvider = InferProvider<typeof binaryCapability>;
+//# sourceMappingURL=binary.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"binary.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/binary.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;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB;;;iBAI7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;CAYY,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

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

@@ -4,8 +4,8 @@ import { DeviceType } from '../device/device-type.js';
 /**
  * Dimmable-light brightness control. Co-exists with `switch` on the
  * same device — the switch toggles on/off, this cap sets the level
- * applied when the light is on. Modeled after Scrypted's `Brightness`
- * interface so drivers can map their per-vendor dim controls cleanly.
+ * applied when the light is on. Drivers map their per-vendor dim
+ * controls to this single-method surface.
  *
  * The cap is intentionally minimal: a single `setBrightness({deviceId,
  * percentage})` mutation plus the auto-injected `getStatus`. Drivers
@@ -21,6 +21,7 @@ export type BrightnessStatus = z.infer<typeof BrightnessStatusSchema>;
 export declare const brightnessCapability: {
     readonly name: "brightness";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Light];
     readonly methods: {

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

@@ -1 +1 @@
-{"version":3,"file":"brightness.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/brightness.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,sBAAsB;;;iBAKjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;QAgB7B;;;;WAIG;;;;;;;;;;;;;;;;IAWL;;;;OAIG;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,OAAO,oBAAoB,CAAC,CAAA"}
+{"version":3,"file":"brightness.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/brightness.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,sBAAsB;;;iBAKjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;QAiB7B;;;;WAIG;;;;;;;;;;;;;;;;IAWL;;;;OAIG;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,OAAO,oBAAoB,CAAC,CAAA"}