@camstack/types 0.1.39 → 0.1.41

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"}

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

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Weather provider cap. Models HA `weather.*` entities — a read-only
+ * snapshot of the CURRENT conditions a weather integration reports.
+ *
+ * Read-only: there are no setters. The slice is populated from upstream
+ * pushes (the HA weather entity's state + attributes) and rendered by
+ * the UI as a sky scene + readouts.
+ *
+ * `condition` is the verbatim HA state string (`sunny` / `cloudy` /
+ * `rainy` / `snowy` / `partlycloudy` / `pouring` / `lightning` /
+ * `lightning-rainy` / `fog` / `windy` / `windy-variant` / `hail` /
+ * `clear-night` / `exceptional` / …). The UI maps it to a glyph + tint;
+ * unknown strings fall back to a neutral cloud.
+ *
+ * Every numeric reading is nullable — a given weather integration only
+ * populates the metrics it actually provides.
+ *
+ * Forecast deferred — current conditions only for v1.
+ */
+export declare const WeatherStatusSchema: z.ZodObject<{
+    condition: z.ZodNullable<z.ZodString>;
+    temperature: z.ZodNullable<z.ZodNumber>;
+    temperatureUnit: z.ZodNullable<z.ZodString>;
+    humidity: z.ZodNullable<z.ZodNumber>;
+    pressure: z.ZodNullable<z.ZodNumber>;
+    pressureUnit: z.ZodNullable<z.ZodString>;
+    windSpeed: z.ZodNullable<z.ZodNumber>;
+    windSpeedUnit: z.ZodNullable<z.ZodString>;
+    windBearing: z.ZodNullable<z.ZodNumber>;
+    lastFetchedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type WeatherStatus = z.infer<typeof WeatherStatusSchema>;
+export declare const weatherCapability: {
+    readonly name: "weather";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Weather];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            condition: z.ZodNullable<z.ZodString>;
+            temperature: z.ZodNullable<z.ZodNumber>;
+            temperatureUnit: z.ZodNullable<z.ZodString>;
+            humidity: z.ZodNullable<z.ZodNumber>;
+            pressure: z.ZodNullable<z.ZodNumber>;
+            pressureUnit: z.ZodNullable<z.ZodString>;
+            windSpeed: z.ZodNullable<z.ZodNumber>;
+            windSpeedUnit: z.ZodNullable<z.ZodString>;
+            windBearing: z.ZodNullable<z.ZodNumber>;
+            lastFetchedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — mirrored by the kernel. The UI reads the
+     * current conditions directly from the slice on each weather push.
+     */
+    readonly runtimeState: z.ZodObject<{
+        condition: z.ZodNullable<z.ZodString>;
+        temperature: z.ZodNullable<z.ZodNumber>;
+        temperatureUnit: z.ZodNullable<z.ZodString>;
+        humidity: z.ZodNullable<z.ZodNumber>;
+        pressure: z.ZodNullable<z.ZodNumber>;
+        pressureUnit: z.ZodNullable<z.ZodString>;
+        windSpeed: z.ZodNullable<z.ZodNumber>;
+        windSpeedUnit: z.ZodNullable<z.ZodString>;
+        windBearing: z.ZodNullable<z.ZodNumber>;
+        lastFetchedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IWeatherProvider = InferProvider<typeof weatherCapability>;
+//# sourceMappingURL=weather.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"weather.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/weather.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;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;iBAsB9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;IAa5B;;;OAGG;;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC,OAAO,iBAAiB,CAAC,CAAA"}