@camstack/types 0.1.40 → 0.1.41

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

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

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

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Tamper / case-open detection sensor. Drives Home Assistant
+ * `binary_sensor` entries with `device_class: tamper`. Push-driven.
+ */
+export declare const TamperStatusSchema: z.ZodObject<{
+    tampered: z.ZodBoolean;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type TamperStatus = z.infer<typeof TamperStatusSchema>;
+export declare const tamperCapability: {
+    readonly name: "tamper";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Sensor];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            tampered: z.ZodBoolean;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    readonly runtimeState: z.ZodObject<{
+        tampered: z.ZodBoolean;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type ITamperProvider = InferProvider<typeof tamperCapability>;
+//# sourceMappingURL=tamper.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tamper.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/tamper.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,kBAAkB;;;iBAM7B,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/temperature-sensor.cap.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Single-metric temperature reading. Drives Home Assistant `sensor`
+ * entries with `device_class: temperature` and any future native
+ * thermometer.
+ *
+ * Unit normalisation: providers convert to Celsius before storing.
+ * The slice value is always Celsius so cross-cap aggregators
+ * (climate-control's `currentTemp`, energy analytics) can compose
+ * without per-source unit fixups. The canonical display unit (`°C`) is
+ * a descriptor constant in the UI (ROLE_DESCRIPTOR), not stored in
+ * `sourceInfo`.
+ *
+ * Status `lastFetchedAt` lets staleness-aware consumers detect a
+ * frozen feed (provider hung) distinct from a "temperature hasn't
+ * changed" steady state.
+ */
+export declare const TemperatureSensorStatusSchema: z.ZodObject<{
+    celsius: z.ZodNumber;
+    lastFetchedAt: z.ZodNumber;
+    unit: z.ZodOptional<z.ZodString>;
+    precision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type TemperatureSensorStatus = z.infer<typeof TemperatureSensorStatusSchema>;
+export declare const temperatureSensorCapability: {
+    readonly name: "temperature-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<{
+            celsius: 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<{
+        celsius: z.ZodNumber;
+        lastFetchedAt: z.ZodNumber;
+        unit: z.ZodOptional<z.ZodString>;
+        precision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+};
+export type ITemperatureSensorProvider = InferProvider<typeof temperatureSensorCapability>;
+//# sourceMappingURL=temperature-sensor.cap.d.ts.map

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

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

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

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Firmware/software update entity. Installed on a `DeviceType.Update` device.
+ * Surfaces current vs available version, whether an update is available, the
+ * update state, and an install action. Read-mostly and POLL-driven: backends
+ * such as the Homematic CCU do not broadcast firmware-descriptor changes, so
+ * the client re-queries `getStatus` (which reads the live descriptor) rather
+ * than relying on push delivery. `installUpdate` triggers the install
+ * (best-effort — providers throw if the backend rejects it).
+ */
+export declare const UpdateStatusSchema: z.ZodObject<{
+    currentVersion: z.ZodNullable<z.ZodString>;
+    availableVersion: z.ZodNullable<z.ZodString>;
+    updatable: z.ZodBoolean;
+    state: z.ZodNullable<z.ZodString>;
+    inProgress: z.ZodBoolean;
+}, z.core.$strip>;
+export type UpdateStatus = z.infer<typeof UpdateStatusSchema>;
+export declare const updateCapability: {
+    readonly name: "update";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Update];
+    readonly methods: {
+        readonly installUpdate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            currentVersion: z.ZodNullable<z.ZodString>;
+            availableVersion: z.ZodNullable<z.ZodString>;
+            updatable: z.ZodBoolean;
+            state: z.ZodNullable<z.ZodString>;
+            inProgress: z.ZodBoolean;
+        }, z.core.$strip>;
+        readonly kind: "poll";
+    };
+    readonly runtimeState: z.ZodObject<{
+        currentVersion: z.ZodNullable<z.ZodString>;
+        availableVersion: z.ZodNullable<z.ZodString>;
+        updatable: z.ZodBoolean;
+        state: z.ZodNullable<z.ZodString>;
+        inProgress: z.ZodBoolean;
+    }, z.core.$strip>;
+};
+export type IUpdateProvider = InferProvider<typeof updateCapability>;
+//# sourceMappingURL=update.cap.d.ts.map

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

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

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

@@ -0,0 +1,229 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Robot-vacuum cap. Models HA `vacuum.*` entities — anything with a
+ * cleaning lifecycle plus a return-to-base / locate surface and an
+ * optional fan-speed selector.
+ *
+ * State follows HA's canonical vacuum lifecycle: `idle` / `cleaning` /
+ * `paused` / `returning` / `docked` / `error`. `batteryLevel`
+ * (0..100) is nullable — some vacuums don't report a battery
+ * percentage. `fanSpeed` is the current speed token (provider-verbatim,
+ * e.g. `'standard'` / `'turbo'`) and `availableFanSpeeds` lists the
+ * tokens the hardware accepts so the UI renders only supported choices.
+ *
+ * The `setFanSpeed` method takes the bare `speed` token — the provider
+ * validates it against the vacuum's own list. `locate` triggers the
+ * find-me chirp; `returnToBase` sends it home.
+ *
+ * Consumable / waste tanks: `cleanWater` / `dirtyWater` / `detergent` /
+ * `dustBin` each carry a nullable `{ level (0..100 %), status ('ok' |
+ * 'low' | 'full') }` reading. Native providers (e.g. Dreame, Roborock)
+ * SHOULD populate whichever tanks the hardware has — leave a field `null`
+ * only when the device has no such tank at all, and use a `TankStatus`
+ * with both inner fields `null` when the tank exists but its level is
+ * currently unknown. HA `vacuum.*` entities expose no per-tank telemetry,
+ * so the HA provider leaves all four `null`.
+ */
+export declare const VacuumStateSchema: z.ZodEnum<{
+    error: "error";
+    idle: "idle";
+    paused: "paused";
+    docked: "docked";
+    cleaning: "cleaning";
+    returning: "returning";
+}>;
+export type VacuumState = z.infer<typeof VacuumStateSchema>;
+/**
+ * One consumable / waste tank on a robot vacuum (clean-water, dirty-water,
+ * detergent or dust-bin). A tank can report a numeric fill `level` (0..100),
+ * a discrete `status` (binary-style hardware), or both. Both `null` means the
+ * level is currently unknown; the OWNING field being `null` means the
+ * hardware has no such tank at all.
+ */
+export declare const TankStatusSchema: z.ZodObject<{
+    level: z.ZodNullable<z.ZodNumber>;
+    status: z.ZodNullable<z.ZodEnum<{
+        ok: "ok";
+        full: "full";
+        low: "low";
+    }>>;
+}, z.core.$strip>;
+export type TankStatus = z.infer<typeof TankStatusSchema>;
+export declare const VacuumControlStatusSchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        error: "error";
+        idle: "idle";
+        paused: "paused";
+        docked: "docked";
+        cleaning: "cleaning";
+        returning: "returning";
+    }>;
+    batteryLevel: z.ZodNullable<z.ZodNumber>;
+    fanSpeed: z.ZodNullable<z.ZodString>;
+    availableFanSpeeds: z.ZodArray<z.ZodString>;
+    cleanWater: z.ZodNullable<z.ZodObject<{
+        level: z.ZodNullable<z.ZodNumber>;
+        status: z.ZodNullable<z.ZodEnum<{
+            ok: "ok";
+            full: "full";
+            low: "low";
+        }>>;
+    }, z.core.$strip>>;
+    dirtyWater: z.ZodNullable<z.ZodObject<{
+        level: z.ZodNullable<z.ZodNumber>;
+        status: z.ZodNullable<z.ZodEnum<{
+            ok: "ok";
+            full: "full";
+            low: "low";
+        }>>;
+    }, z.core.$strip>>;
+    detergent: z.ZodNullable<z.ZodObject<{
+        level: z.ZodNullable<z.ZodNumber>;
+        status: z.ZodNullable<z.ZodEnum<{
+            ok: "ok";
+            full: "full";
+            low: "low";
+        }>>;
+    }, z.core.$strip>>;
+    dustBin: z.ZodNullable<z.ZodObject<{
+        level: z.ZodNullable<z.ZodNumber>;
+        status: z.ZodNullable<z.ZodEnum<{
+            ok: "ok";
+            full: "full";
+            low: "low";
+        }>>;
+    }, z.core.$strip>>;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type VacuumControlStatus = z.infer<typeof VacuumControlStatusSchema>;
+export declare const vacuumControlCapability: {
+    readonly name: "vacuum-control";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Vacuum];
+    readonly methods: {
+        readonly start: 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 returnToBase: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly locate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly setFanSpeed: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            speed: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            state: z.ZodEnum<{
+                error: "error";
+                idle: "idle";
+                paused: "paused";
+                docked: "docked";
+                cleaning: "cleaning";
+                returning: "returning";
+            }>;
+            batteryLevel: z.ZodNullable<z.ZodNumber>;
+            fanSpeed: z.ZodNullable<z.ZodString>;
+            availableFanSpeeds: z.ZodArray<z.ZodString>;
+            cleanWater: z.ZodNullable<z.ZodObject<{
+                level: z.ZodNullable<z.ZodNumber>;
+                status: z.ZodNullable<z.ZodEnum<{
+                    ok: "ok";
+                    full: "full";
+                    low: "low";
+                }>>;
+            }, z.core.$strip>>;
+            dirtyWater: z.ZodNullable<z.ZodObject<{
+                level: z.ZodNullable<z.ZodNumber>;
+                status: z.ZodNullable<z.ZodEnum<{
+                    ok: "ok";
+                    full: "full";
+                    low: "low";
+                }>>;
+            }, z.core.$strip>>;
+            detergent: z.ZodNullable<z.ZodObject<{
+                level: z.ZodNullable<z.ZodNumber>;
+                status: z.ZodNullable<z.ZodEnum<{
+                    ok: "ok";
+                    full: "full";
+                    low: "low";
+                }>>;
+            }, z.core.$strip>>;
+            dustBin: z.ZodNullable<z.ZodObject<{
+                level: z.ZodNullable<z.ZodNumber>;
+                status: z.ZodNullable<z.ZodEnum<{
+                    ok: "ok";
+                    full: "full";
+                    low: "low";
+                }>>;
+            }, z.core.$strip>>;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — mirrored by the kernel. UI controls watch the
+     * slice for live state + battery + fan-speed changes.
+     */
+    readonly runtimeState: z.ZodObject<{
+        state: z.ZodEnum<{
+            error: "error";
+            idle: "idle";
+            paused: "paused";
+            docked: "docked";
+            cleaning: "cleaning";
+            returning: "returning";
+        }>;
+        batteryLevel: z.ZodNullable<z.ZodNumber>;
+        fanSpeed: z.ZodNullable<z.ZodString>;
+        availableFanSpeeds: z.ZodArray<z.ZodString>;
+        cleanWater: z.ZodNullable<z.ZodObject<{
+            level: z.ZodNullable<z.ZodNumber>;
+            status: z.ZodNullable<z.ZodEnum<{
+                ok: "ok";
+                full: "full";
+                low: "low";
+            }>>;
+        }, z.core.$strip>>;
+        dirtyWater: z.ZodNullable<z.ZodObject<{
+            level: z.ZodNullable<z.ZodNumber>;
+            status: z.ZodNullable<z.ZodEnum<{
+                ok: "ok";
+                full: "full";
+                low: "low";
+            }>>;
+        }, z.core.$strip>>;
+        detergent: z.ZodNullable<z.ZodObject<{
+            level: z.ZodNullable<z.ZodNumber>;
+            status: z.ZodNullable<z.ZodEnum<{
+                ok: "ok";
+                full: "full";
+                low: "low";
+            }>>;
+        }, z.core.$strip>>;
+        dustBin: z.ZodNullable<z.ZodObject<{
+            level: z.ZodNullable<z.ZodNumber>;
+            status: z.ZodNullable<z.ZodEnum<{
+                ok: "ok";
+                full: "full";
+                low: "low";
+            }>>;
+        }, z.core.$strip>>;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IVacuumControlProvider = InferProvider<typeof vacuumControlCapability>;
+//# sourceMappingURL=vacuum-control.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vacuum-control.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/vacuum-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;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,eAAO,MAAM,iBAAiB;;;;;;;EAO5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;;;;;iBAK3B,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqBpC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA6ClC;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

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

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Pipe / water / gas valve cap. Models HA `valve.*` entities — anything
+ * that moves between an open and a closed state with optional
+ * intermediate positioning.
+ *
+ * State follows HA's canonical lifecycle: `open` / `opening` /
+ * `closing` / `closed` / `stopped`. `position` (0 closed, 100 open) is
+ * nullable — some valves only support full open/close, while others
+ * report and accept an intermediate position. Providers populate only
+ * what the hardware reports.
+ *
+ * Unlike `cover`, valves have no tilt surface — the cap is the strict
+ * open/close + optional position subset of the cover lifecycle.
+ *
+ * Sub-surface gating paired with a `DeviceFeature` flag:
+ *   - `ValvePositionable` — intermediate `position` slider / drag
+ */
+export declare const ValveStateSchema: z.ZodEnum<{
+    open: "open";
+    stopped: "stopped";
+    opening: "opening";
+    closing: "closing";
+    closed: "closed";
+}>;
+export type ValveState = z.infer<typeof ValveStateSchema>;
+export declare const ValveStatusSchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        open: "open";
+        stopped: "stopped";
+        opening: "opening";
+        closing: "closing";
+        closed: "closed";
+    }>;
+    position: z.ZodNullable<z.ZodNumber>;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type ValveStatus = z.infer<typeof ValveStatusSchema>;
+export declare const valveCapability: {
+    readonly name: "valve";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Valve];
+    readonly methods: {
+        readonly open: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly close: 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 setPosition: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            position: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            state: z.ZodEnum<{
+                open: "open";
+                stopped: "stopped";
+                opening: "opening";
+                closing: "closing";
+                closed: "closed";
+            }>;
+            position: 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 position changes during a move.
+     */
+    readonly runtimeState: z.ZodObject<{
+        state: z.ZodEnum<{
+            open: "open";
+            stopped: "stopped";
+            opening: "opening";
+            closing: "closing";
+            closed: "closed";
+        }>;
+        position: z.ZodNullable<z.ZodNumber>;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IValveProvider = InferProvider<typeof valveCapability>;
+//# sourceMappingURL=valve.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"valve.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/valve.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;;;;;;;;;;;;;;;;GAgBG;AAEH,eAAO,MAAM,gBAAgB;;;;;;EAM3B,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,eAAO,MAAM,iBAAiB;;;;;;;;;;iBAQ5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmC1B;;;OAGG;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,cAAc,GAAG,aAAa,CAAC,OAAO,eAAe,CAAC,CAAA"}

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

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Vibration / shake / impact sensor. Drives Home Assistant
+ * `binary_sensor` entries with `device_class: vibration`. Push-driven.
+ */
+export declare const VibrationStatusSchema: z.ZodObject<{
+    detected: z.ZodBoolean;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type VibrationStatus = z.infer<typeof VibrationStatusSchema>;
+export declare const vibrationCapability: {
+    readonly name: "vibration";
+    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 IVibrationProvider = InferProvider<typeof vibrationCapability>;
+//# sourceMappingURL=vibration.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vibration.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/vibration.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,qBAAqB;;;iBAIhC,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;CAYS,CAAA;AAEzC,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/capabilities/water-heater.cap.d.ts

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Water heater / boiler cap. Models HA `water_heater.*` entities — a
+ * climate-family actuator with a target temperature, an operation-mode
+ * selector (`eco` / `electric` / `gas` / `heat_pump` / `high_demand` /
+ * `performance` / `off`), and an optional away-mode toggle.
+ *
+ * The slice carries the current + target temperature, the active
+ * operation mode (HA's `state`) and its available set (HA's
+ * `operation_list`), the away flag (HA `away_mode` 'on'/'off' → bool,
+ * null when unsupported), plus the `min_temp` / `max_temp` bounds.
+ *
+ * Providers populate only what the hardware reports — temperature and
+ * away fields stay null when the device has no such surface.
+ */
+export declare const WaterHeaterStatusSchema: z.ZodObject<{
+    currentTemp: z.ZodNullable<z.ZodNumber>;
+    targetTemp: z.ZodNullable<z.ZodNumber>;
+    operationMode: z.ZodNullable<z.ZodString>;
+    availableModes: z.ZodArray<z.ZodString>;
+    away: z.ZodNullable<z.ZodBoolean>;
+    minTemp: z.ZodNullable<z.ZodNumber>;
+    maxTemp: z.ZodNullable<z.ZodNumber>;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type WaterHeaterStatus = z.infer<typeof WaterHeaterStatusSchema>;
+export declare const waterHeaterCapability: {
+    readonly name: "water-heater";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.WaterHeater];
+    readonly methods: {
+        readonly setTargetTemp: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            temp: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly setOperationMode: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            mode: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly setAway: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            on: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            currentTemp: z.ZodNullable<z.ZodNumber>;
+            targetTemp: z.ZodNullable<z.ZodNumber>;
+            operationMode: z.ZodNullable<z.ZodString>;
+            availableModes: z.ZodArray<z.ZodString>;
+            away: z.ZodNullable<z.ZodBoolean>;
+            minTemp: z.ZodNullable<z.ZodNumber>;
+            maxTemp: 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 temperature / mode / away changes.
+     */
+    readonly runtimeState: z.ZodObject<{
+        currentTemp: z.ZodNullable<z.ZodNumber>;
+        targetTemp: z.ZodNullable<z.ZodNumber>;
+        operationMode: z.ZodNullable<z.ZodString>;
+        availableModes: z.ZodArray<z.ZodString>;
+        away: z.ZodNullable<z.ZodBoolean>;
+        minTemp: z.ZodNullable<z.ZodNumber>;
+        maxTemp: z.ZodNullable<z.ZodNumber>;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IWaterHeaterProvider = InferProvider<typeof waterHeaterCapability>;
+//# sourceMappingURL=water-heater.cap.d.ts.map

package/dist/capabilities/water-heater.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"water-heater.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/water-heater.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;;;;;;;;;;;;;GAaG;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;iBAoBlC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoChC;;;OAGG;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAAC,OAAO,qBAAqB,CAAC,CAAA"}