@camstack/ui-library 1.2.257 → 1.2.259

package/dist/composites/device-controls/sensor-value-atom.d.ts

@@ -1,106 +1,127 @@
-import { ReactNode } from 'react';
-import { DeviceProxy, SliceHandle } from '@camstack/types';
-import { UseDeviceProxyTrpc } from '../../hooks/use-device-proxy';
-import { ControlDateTimeFormat } from '../../lib/format-control-datetime';
-import { DeviceItemDevice } from '../device-item/helpers';
+/**
+* SensorValueAtom — read-only badge for Sensor / Presence device rows.
+*
+* Renders a compact inline badge showing the device's current value:
+*  - typed numeric roles (temperature/humidity/ambient-light/pressure):
+*    value + canonical unit from ROLE_DESCRIPTOR (not sourceInfo)
+*  - generic numeric-sensor role: value + unit from the SLICE (populated
+*    live by the HA provider from state.attributes.unit_of_measurement)
+*  - binary roles: on/off label coloured per state
+*  - presence: Home / Away / zone name
+*
+* Returns null when no descriptor matches the role, or when the slice
+* has not yet landed (binding still resolving, or cap unbound).
+*
+* The proxy state is accessed via a typed per-role accessor stored in
+* `SensorDescriptor.getSliceHandle`. Each accessor is a concrete arrow
+* into the typed `DeviceProxy['state']` shape — no dynamic string
+* indexing. The shared handle type is `SliceHandle<unknown>` so the
+* discriminated union can hold all three descriptor kinds without casts
+* at the call site; narrowing occurs after `useDeviceStateSlice`.
+*/
+import type { ReactNode } from "react";
+import type { DeviceProxy, SliceHandle } from "@camstack/types";
+import { type UseDeviceProxyTrpc } from "../../hooks/use-device-proxy";
+import { type ControlDateTimeFormat } from "../../lib/format-control-datetime";
+import type { DeviceItemDevice } from "../device-item/helpers";
 interface NumericDescriptor {
-    readonly kind: 'numeric';
-    /** Field in the slice that holds the numeric value. */
-    readonly field: string;
-    /** Canonical display unit for TYPED roles (temperature → '°C', humidity → '%',
-     *  ambient-light → 'lx', pressure → 'hPa'). When present the UI renders this
-     *  directly WITHOUT consulting the slice or sourceInfo.
-     *  For the generic `numeric-sensor` role this is `undefined` — the unit is
-     *  read live from the slice (`slice.unit`). */
-    readonly canonicalUnit?: string;
-    /** Accessor into DeviceProxy['state'] — returns a typed slice handle. */
-    readonly getSliceHandle: (state: DeviceProxy['state']) => SliceHandle<unknown>;
+	readonly kind: "numeric";
+	/** Field in the slice that holds the numeric value. */
+	readonly field: string;
+	/** Canonical display unit for TYPED roles (temperature → '°C', humidity → '%',
+	*  ambient-light → 'lx', pressure → 'hPa'). When present the UI renders this
+	*  directly WITHOUT consulting the slice or sourceInfo.
+	*  For the generic `numeric-sensor` role this is `undefined` — the unit is
+	*  read live from the slice (`slice.unit`). */
+	readonly canonicalUnit?: string;
+	/** Accessor into DeviceProxy['state'] — returns a typed slice handle. */
+	readonly getSliceHandle: (state: DeviceProxy["state"]) => SliceHandle<unknown>;
 }
 interface BinaryDescriptor {
-    readonly kind: 'binary';
-    /** Field in the slice that holds the boolean trigger. */
-    readonly field: string;
-    /** Label shown when the boolean field is truthy. */
-    readonly onLabel: string;
-    /** Label shown when the boolean field is falsy. */
-    readonly offLabel: string;
-    readonly getSliceHandle: (state: DeviceProxy['state']) => SliceHandle<unknown>;
+	readonly kind: "binary";
+	/** Field in the slice that holds the boolean trigger. */
+	readonly field: string;
+	/** Label shown when the boolean field is truthy. */
+	readonly onLabel: string;
+	/** Label shown when the boolean field is falsy. */
+	readonly offLabel: string;
+	readonly getSliceHandle: (state: DeviceProxy["state"]) => SliceHandle<unknown>;
 }
 interface PresenceDescriptor {
-    readonly kind: 'presence';
-    readonly getSliceHandle: (state: DeviceProxy['state']) => SliceHandle<unknown>;
+	readonly kind: "presence";
+	readonly getSliceHandle: (state: DeviceProxy["state"]) => SliceHandle<unknown>;
 }
 /**
- * String-valued sensor whose slice holds `{ value: string, lastFetchedAt }`.
- * Used for HA free-text sensors (IP address, SSID, firmware version, …) that
- * have no numeric device_class and whose state is a plain string.
- */
+* String-valued sensor whose slice holds `{ value: string, lastFetchedAt }`.
+* Used for HA free-text sensors (IP address, SSID, firmware version, …) that
+* have no numeric device_class and whose state is a plain string.
+*/
 interface StringDescriptor {
-    readonly kind: 'string';
-    readonly getSliceHandle: (state: DeviceProxy['state']) => SliceHandle<unknown>;
+	readonly kind: "string";
+	readonly getSliceHandle: (state: DeviceProxy["state"]) => SliceHandle<unknown>;
 }
 /**
- * Date / timestamp sensor whose slice holds `{ value: string, format? }`
- * carrying a raw ISO string (e.g. '2025-12-02T09:36:12+00:00'). Rendered
- * locale-formatted via `formatControlDateTime`. The slice's own `format` (seeded
- * by the HA provider from the entity's `device_class` — `timestamp` → 'datetime',
- * `date` → 'date', time-only → 'time') selects the shape; `descriptor.format` is
- * the fallback for slices adopted before the field was threaded ('datetime').
- */
+* Date / timestamp sensor whose slice holds `{ value: string, format? }`
+* carrying a raw ISO string (e.g. '2025-12-02T09:36:12+00:00'). Rendered
+* locale-formatted via `formatControlDateTime`. The slice's own `format` (seeded
+* by the HA provider from the entity's `device_class` — `timestamp` → 'datetime',
+* `date` → 'date', time-only → 'time') selects the shape; `descriptor.format` is
+* the fallback for slices adopted before the field was threaded ('datetime').
+*/
 interface DateTimeDescriptor {
-    readonly kind: 'datetime';
-    readonly format: ControlDateTimeFormat;
-    readonly getSliceHandle: (state: DeviceProxy['state']) => SliceHandle<unknown>;
+	readonly kind: "datetime";
+	readonly format: ControlDateTimeFormat;
+	readonly getSliceHandle: (state: DeviceProxy["state"]) => SliceHandle<unknown>;
 }
 export type SensorDescriptor = NumericDescriptor | BinaryDescriptor | PresenceDescriptor | StringDescriptor | DateTimeDescriptor;
 /**
- * Binary fallback for the `battery-sensor` role.
- *
- * HA assigns role `battery-sensor` to BOTH numeric battery entities
- * (`sensor.*` device_class=battery → cap `numeric-sensor`) AND binary battery
- * entities (`binary_sensor.*` device_class=battery → cap `binary`, e.g. a
- * HomeMatic `LOW_BAT` flag). When the numeric slice is absent the binary slice
- * is rendered instead, with battery-specific polarity: `on:true` means LOW
- * (bad → warning style + "Low"), `on:false` means Normal (neutral).
- */
+* Binary fallback for the `battery-sensor` role.
+*
+* HA assigns role `battery-sensor` to BOTH numeric battery entities
+* (`sensor.*` device_class=battery → cap `numeric-sensor`) AND binary battery
+* entities (`binary_sensor.*` device_class=battery → cap `binary`, e.g. a
+* HomeMatic `LOW_BAT` flag). When the numeric slice is absent the binary slice
+* is rendered instead, with battery-specific polarity: `on:true` means LOW
+* (bad → warning style + "Low"), `on:false` means Normal (neutral).
+*/
 export declare const BINARY_BATTERY_DESCRIPTOR: BinaryDescriptor;
 /** True for the role that can resolve to either a numeric or a binary slice. */
 export declare function isBatterySensorRole(role: string | null | undefined): boolean;
 /**
- * A numeric slice counts as "present" only when it carries a real numeric value
- * at the descriptor field — a cold-start slice (`{ value: 0, lastFetchedAt: 0 }`)
- * or a binary slice (no numeric field) does NOT, so the binary fallback wins.
- */
+* A numeric slice counts as "present" only when it carries a real numeric value
+* at the descriptor field — a cold-start slice (`{ value: 0, lastFetchedAt: 0 }`)
+* or a binary slice (no numeric field) does NOT, so the binary fallback wins.
+*/
 export declare function hasBatteryNumericValue(slice: unknown, field: string): boolean;
 /**
- * Keyed by DeviceRole string value. Every entry maps a role to the
- * exact proxy state accessor + rendering instructions. The accessor
- * avoids dynamic string indexing — each one is a concrete property
- * access on the typed `DeviceProxy['state']` shape.
- *
- * Canonical unit rules:
- *  - Typed roles (temperature/humidity/ambient-light/pressure/power/energy)
- *    carry a `canonicalUnit` constant. The slice is normalised to one unit
- *    so no per-device lookup is needed.
- *  - Generic `numeric-sensor` has no `canonicalUnit`. The unit is read live
- *    from the slice (`slice.unit`) as populated by the provider from the
- *    upstream source on every state push.
- */
+* Keyed by DeviceRole string value. Every entry maps a role to the
+* exact proxy state accessor + rendering instructions. The accessor
+* avoids dynamic string indexing — each one is a concrete property
+* access on the typed `DeviceProxy['state']` shape.
+*
+* Canonical unit rules:
+*  - Typed roles (temperature/humidity/ambient-light/pressure/power/energy)
+*    carry a `canonicalUnit` constant. The slice is normalised to one unit
+*    so no per-device lookup is needed.
+*  - Generic `numeric-sensor` has no `canonicalUnit`. The unit is read live
+*    from the slice (`slice.unit`) as populated by the provider from the
+*    upstream source on every state push.
+*/
 export declare const ROLE_DESCRIPTOR: Record<string, SensorDescriptor>;
 export interface StringSliceValue {
-    readonly value: string;
+	readonly value: string;
 }
 export declare function isStringSliceValue(v: unknown): v is StringSliceValue;
 /**
- * The enum-sensor slice carries an optional `format` ('date' | 'time' |
- * 'datetime') for `DateTimeSensor`-role sensors. Read it off the live slice so
- * each sensor renders its true shape; returns `undefined` when absent (older
- * adoptions) so the caller falls back to the descriptor default.
- */
+* The enum-sensor slice carries an optional `format` ('date' | 'time' |
+* 'datetime') for `DateTimeSensor`-role sensors. Read it off the live slice so
+* each sensor renders its true shape; returns `undefined` when absent (older
+* adoptions) so the caller falls back to the descriptor default.
+*/
 export declare function readSliceDateTimeFormat(slice: unknown): ControlDateTimeFormat | undefined;
 export interface SensorValueAtomProps {
-    readonly trpc: UseDeviceProxyTrpc;
-    readonly device: DeviceItemDevice;
+	readonly trpc: UseDeviceProxyTrpc;
+	readonly device: DeviceItemDevice;
 }
 export declare function SensorValueAtom({ trpc, device }: SensorValueAtomProps): ReactNode;
 export {};

package/dist/composites/device-controls/switch-hero-card.d.ts

@@ -1,13 +1,13 @@
-import { ReactNode } from 'react';
-import { DeviceControlProps } from './control-registry';
+import type { ReactNode } from "react";
+import type { DeviceControlProps } from "./control-registry";
 /**
- * SwitchHeroCard — large tap-toggle hero for Switch / Siren devices.
- *
- * Renders (Spec §3):
- *  - A power glyph tinted by on/off state (success when on, muted when off).
- *  - A large TAP TOGGLE for on/off — a single tap flips state. This is NOT a
- *    SlideToggle; slide-to-confirm is reserved for safety-gated locks ONLY.
- *
- * Cap-gated on `switch` — returns null when the device has no switch cap.
- */
+* SwitchHeroCard — large tap-toggle hero for Switch / Siren devices.
+*
+* Renders (Spec §3):
+*  - A power glyph tinted by on/off state (success when on, muted when off).
+*  - A large TAP TOGGLE for on/off — a single tap flips state. This is NOT a
+*    SlideToggle; slide-to-confirm is reserved for safety-gated locks ONLY.
+*
+* Cap-gated on `switch` — returns null when the device has no switch cap.
+*/
 export declare function SwitchHeroCard({ trpc, deviceId, optimistic }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/switch-panel.d.ts

@@ -1,3 +1,3 @@
-import { ReactNode } from 'react';
-import { ControlPanelProps } from './types';
+import { type ReactNode } from "react";
+import type { ControlPanelProps } from "./types";
 export declare function SwitchPanel({ trpc, deviceId, optimistic }: ControlPanelProps): ReactNode;

package/dist/composites/device-controls/tap-toggle.d.ts

@@ -1,17 +1,17 @@
-import { ReactNode } from 'react';
+import type { ReactNode } from "react";
 /**
- * TapToggle — plain tap-to-toggle on/off control.
- *
- * Spec §3: everyday on/off (switch, light, fan) uses a plain TAP TOGGLE.
- * slide-to-confirm is reserved for safety-gated actions (lock) ONLY. This
- * component must NEVER be built on `SlideToggle` — a single tap flips state.
- *
- * Presentational: the caller owns the cap mutation + optimistic update via
- * `onToggle`. Mirrors the `SwitchPanel` button treatment at hero scale.
- */
+* TapToggle — plain tap-to-toggle on/off control.
+*
+* Spec §3: everyday on/off (switch, light, fan) uses a plain TAP TOGGLE.
+* slide-to-confirm is reserved for safety-gated actions (lock) ONLY. This
+* component must NEVER be built on `SlideToggle` — a single tap flips state.
+*
+* Presentational: the caller owns the cap mutation + optimistic update via
+* `onToggle`. Mirrors the `SwitchPanel` button treatment at hero scale.
+*/
 export interface TapToggleProps {
-    readonly on: boolean;
-    readonly busy: boolean;
-    readonly onToggle: () => void;
+	readonly on: boolean;
+	readonly busy: boolean;
+	readonly onToggle: () => void;
 }
 export declare function TapToggle({ on, busy, onToggle }: TapToggleProps): ReactNode;

package/dist/composites/device-controls/thermostat-hero-card.d.ts

@@ -1,17 +1,17 @@
-import { ReactNode } from 'react';
-import { DeviceControlProps } from './control-registry';
+import type { ReactNode } from "react";
+import type { DeviceControlProps } from "./control-registry";
 /**
- * ThermostatHeroCard — circular gauge hero for thermostat / HVAC devices.
- *
- * Renders:
- *  - SVG ring gauge: track + fill arc representing the setpoint fraction
- *  - Centered current temperature (large, prominent)
- *  - ArcKnob(s) at the setpoint fraction(s) riding the ring
- *    - Single knob for heat / cool / auto / dry modes
- *    - Two knobs (low + high) with a band fill for heat_cool mode
- *  - Stepper (single) or "Low / High" display (range) for the setpoint
- *  - Mode select
- *
- * Cap-gated: returns null when the device has no climateControl cap.
- */
-export declare function ThermostatHeroCard({ trpc, deviceId, features: _features, optimistic, }: DeviceControlProps): ReactNode;
+* ThermostatHeroCard — circular gauge hero for thermostat / HVAC devices.
+*
+* Renders:
+*  - SVG ring gauge: track + fill arc representing the setpoint fraction
+*  - Centered current temperature (large, prominent)
+*  - ArcKnob(s) at the setpoint fraction(s) riding the ring
+*    - Single knob for heat / cool / auto / dry modes
+*    - Two knobs (low + high) with a band fill for heat_cool mode
+*  - Stepper (single) or "Low / High" display (range) for the setpoint
+*  - Mode select
+*
+* Cap-gated: returns null when the device has no climateControl cap.
+*/
+export declare function ThermostatHeroCard({ trpc, deviceId, features: _features, optimistic }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/types.d.ts

@@ -1,17 +1,17 @@
-import { UseDeviceProxyTrpc } from '../../hooks/use-device-proxy';
+import type { UseDeviceProxyTrpc } from "../../hooks/use-device-proxy";
 /** Shared props for every control panel. `layout` selects the compact (row
- *  popover) vs full (detail tab) presentation. `features` gates sub-controls
- *  (e.g. cover position/tilt, fan speed/preset). */
+*  popover) vs full (detail tab) presentation. `features` gates sub-controls
+*  (e.g. cover position/tilt, fan speed/preset). */
 export interface ControlPanelProps {
-    readonly trpc: UseDeviceProxyTrpc;
-    readonly deviceId: number;
-    readonly features: readonly string[] | undefined;
-    readonly layout: 'compact' | 'full';
-    /** Enable optimistic UI mode (default: true). Set to false to disable. */
-    readonly optimistic?: boolean;
+	readonly trpc: UseDeviceProxyTrpc;
+	readonly deviceId: number;
+	readonly features: readonly string[] | undefined;
+	readonly layout: "compact" | "full";
+	/** Enable optimistic UI mode (default: true). Set to false to disable. */
+	readonly optimistic?: boolean;
 }
 /** Cap names whose presence (bound on a device) means it has a control surface.
- *  Single source of truth shared by the row registry and the detail Controls tab
- *  so the two never drift. */
+*  Single source of truth shared by the row registry and the detail Controls tab
+*  so the two never drift. */
 export declare const CONTROL_CAP_NAMES: readonly ["cover", "lock-control", "switch", "brightness", "fan-control", "climate-control", "media-player", "control", "pet-feeder"];
 export type ControlCapName = (typeof CONTROL_CAP_NAMES)[number];

package/dist/composites/device-controls/update-control.d.ts

@@ -1,11 +1,24 @@
-import { ReactNode } from 'react';
-import { DeviceControlProps } from './control-registry';
 /**
- * UpdateInlineControl — compact firmware state for a device-list row.
- */
+* Firmware/software Update controls for a `DeviceType.Update` device.
+*
+* Reads the `update` cap status slice (currentVersion / availableVersion /
+* updatable / state / inProgress) and renders:
+*   - InlineControl (device-list row): a compact state badge — "Update
+*     available" (actionable) / "Installing…" / current version (up to date).
+*   - HeroCard (device-detail hero): the version transition + an Install button
+*     that calls `update.installUpdate()` when an update is available.
+*
+* Mirrors the cover/sensor controls' `useDeviceCapability` pattern so the row
+* and the hero never diverge.
+*/
+import type { ReactNode } from "react";
+import type { DeviceControlProps } from "./control-registry";
+/**
+* UpdateInlineControl — compact firmware state for a device-list row.
+*/
 export declare function UpdateInlineControl({ trpc, deviceId }: DeviceControlProps): ReactNode;
 /**
- * UpdateHeroCard — version transition + Install action for the device-detail
- * hero area.
- */
+* UpdateHeroCard — version transition + Install action for the device-detail
+* hero area.
+*/
 export declare function UpdateHeroCard({ trpc, deviceId }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/vacuum-control.d.ts

@@ -1,36 +1,52 @@
-import { ReactNode } from 'react';
-import { VacuumState, TankStatus } from '@camstack/types';
-import { DeviceControlProps } from './control-registry';
+/**
+* Robot-vacuum controls for a `DeviceType.Vacuum` device.
+*
+* Reads the `vacuum-control` cap status slice (state / batteryLevel /
+* fanSpeed / availableFanSpeeds) and renders:
+*   - VacuumInlineControl (device-list row): compact Start / Pause /
+*     Return-to-base buttons with state-aware highlight + a battery %
+*     badge.
+*   - VacuumHeroCard (device-detail hero): a state glyph + label, the
+*     full action set (Start / Pause / Stop / Return / Locate), a
+*     fan-speed selector built from `availableFanSpeeds`, and the
+*     battery readout.
+*
+* Mirrors the cover/update controls' `useDeviceCapability` pattern so the
+* row and hero never diverge. Buttons are gated on `available`.
+*/
+import type { ReactNode } from "react";
+import type { VacuumState, TankStatus } from "@camstack/types";
+import type { DeviceControlProps } from "./control-registry";
 export interface VacuumStateMeta {
-    readonly label: string;
-    /** Tailwind text-colour token for the state label. */
-    readonly tone: string;
+	readonly label: string;
+	/** Tailwind text-colour token for the state label. */
+	readonly tone: string;
 }
 /**
- * Pure helper — maps a VacuumState (or undefined when no slice yet) to a
- * human label + colour tone. Exhaustive switch: a new enum member fails
- * the build.
- */
+* Pure helper — maps a VacuumState (or undefined when no slice yet) to a
+* human label + colour tone. Exhaustive switch: a new enum member fails
+* the build.
+*/
 export declare function vacuumStateMeta(state: VacuumState | undefined): VacuumStateMeta;
 /** The four intrinsic tanks a vacuum cap can expose. */
-export type TankKind = 'cleanWater' | 'dirtyWater' | 'detergent' | 'dustBin';
-export type TankAlert = 'ok' | 'warning';
+export type TankKind = "cleanWater" | "dirtyWater" | "detergent" | "dustBin";
+export type TankAlert = "ok" | "warning";
 /**
- * Pure helper — classifies a tank as `ok` or `warning`.
- *
- * Clean-water + detergent are "supply" tanks: low is bad. Dirty-water +
- * dust-bin are "waste" tanks: full is bad. Prefers the numeric `level`
- * (thresholds 15 / 85), falling back to the discrete `status` flag. Both
- * unknown → `ok`. Exhaustive over TankKind.
- */
+* Pure helper — classifies a tank as `ok` or `warning`.
+*
+* Clean-water + detergent are "supply" tanks: low is bad. Dirty-water +
+* dust-bin are "waste" tanks: full is bad. Prefers the numeric `level`
+* (thresholds 15 / 85), falling back to the discrete `status` flag. Both
+* unknown → `ok`. Exhaustive over TankKind.
+*/
 export declare function tankAlert(kind: TankKind, tank: TankStatus): TankAlert;
 /**
- * VacuumInlineControl — compact, state-aware vacuum controls for a
- * device-list row. Start / Pause / Return-to-base + battery badge.
- */
+* VacuumInlineControl — compact, state-aware vacuum controls for a
+* device-list row. Start / Pause / Return-to-base + battery badge.
+*/
 export declare function VacuumInlineControl({ trpc, deviceId }: DeviceControlProps): ReactNode;
 /**
- * VacuumHeroCard — full control surface for the device-detail hero area.
- * State label + action buttons + fan-speed selector + battery readout.
- */
+* VacuumHeroCard — full control surface for the device-detail hero area.
+* State label + action buttons + fan-speed selector + battery readout.
+*/
 export declare function VacuumHeroCard({ trpc, deviceId }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/valve-control.d.ts

@@ -1,46 +1,62 @@
-import { ReactNode } from 'react';
-import { ValveState } from '@camstack/types';
-import { DeviceControlProps } from './control-registry';
+/**
+* Valve controls for a `DeviceType.Valve` device.
+*
+* Reads the `valve` cap status slice (state / position) and renders:
+*   - ValveInlineControl (device-list row): compact Open / Stop / Close
+*     icon-buttons with state-aware highlight + a small position % badge.
+*   - ValveHeroCard (device-detail hero): a bespoke state-tinted pipe +
+*     gate-valve SVG that doubles as a vertical drag surface when the
+*     valve is positionable, the full action set (Open / Stop / Close),
+*     and a position slider gated on `ValvePositionable`.
+*
+* Mirrors the cover controls' `useDeviceCapability` + `useOptimisticSlice`
+* pattern so the row and hero never diverge. The button highlight reuses
+* `coverHighlight` — the valve state enum is identical to the cover one.
+* Buttons are gated on `available`.
+*/
+import { type ReactNode } from "react";
+import { type ValveState } from "@camstack/types";
+import type { DeviceControlProps } from "./control-registry";
 export interface ValveStateMeta {
-    readonly label: string;
-    /** Tailwind text-colour token for the state label. */
-    readonly tone: string;
+	readonly label: string;
+	/** Tailwind text-colour token for the state label. */
+	readonly tone: string;
 }
 /**
- * Pure helper — maps a ValveState (or undefined when no slice yet) to a
- * human label + colour tone. Exhaustive switch: a new enum member fails
- * the build.
- */
+* Pure helper — maps a ValveState (or undefined when no slice yet) to a
+* human label + colour tone. Exhaustive switch: a new enum member fails
+* the build.
+*/
 export declare function valveStateMeta(state: ValveState | undefined): ValveStateMeta;
 /**
- * ValveInlineControl — compact, state-aware valve controls for a
- * device-list row. Open ▲ Stop ■ Close ▼ + optional position % badge.
- * Mirrors `CoverInlineControl` exactly. Must NOT blow out the row width.
- */
+* ValveInlineControl — compact, state-aware valve controls for a
+* device-list row. Open ▲ Stop ■ Close ▼ + optional position % badge.
+* Mirrors `CoverInlineControl` exactly. Must NOT blow out the row width.
+*/
 export declare function ValveInlineControl({ trpc, deviceId, optimistic }: DeviceControlProps): ReactNode;
 /** Per-state visual tint tokens for the framed valve graphic. */
 export interface ValveGraphicTint {
-    /** Tailwind class for the flow-glow wash over the pipe. */
-    readonly glow: string;
-    /** Tailwind text token driving the valve body via currentColor. */
-    readonly accent: string;
-    /** Whether to render the animated flow dashes (open / opening). */
-    readonly flowing: boolean;
-    /** Whether to render the transient-motion activity pulse. */
-    readonly active: boolean;
+	/** Tailwind class for the flow-glow wash over the pipe. */
+	readonly glow: string;
+	/** Tailwind text token driving the valve body via currentColor. */
+	readonly accent: string;
+	/** Whether to render the animated flow dashes (open / opening). */
+	readonly flowing: boolean;
+	/** Whether to render the transient-motion activity pulse. */
+	readonly active: boolean;
 }
 export declare function valveGraphicTint(state: ValveState | undefined): ValveGraphicTint;
 /**
- * ValveHeroCard — full control surface for the device-detail hero area.
- *
- * Bespoke pipe + gate-valve graphic (drag surface when positionable) +
- * a large position % (or capitalized state when position is null) +
- * Open / Stop / Close hero buttons + a position slider gated on
- * `ValvePositionable` (additive to drag), and a read-only range when a
- * position is reported but not settable.
- *
- * Position support is detected via `ValveStatus.position !== null`; the
- * interactive setPosition surface is gated on `DeviceFeature.ValvePositionable`.
- * Only hides when the device truly has no valve cap.
- */
-export declare function ValveHeroCard({ trpc, deviceId, features, optimistic, }: DeviceControlProps): ReactNode;
+* ValveHeroCard — full control surface for the device-detail hero area.
+*
+* Bespoke pipe + gate-valve graphic (drag surface when positionable) +
+* a large position % (or capitalized state when position is null) +
+* Open / Stop / Close hero buttons + a position slider gated on
+* `ValvePositionable` (additive to drag), and a read-only range when a
+* position is reported but not settable.
+*
+* Position support is detected via `ValveStatus.position !== null`; the
+* interactive setPosition surface is gated on `DeviceFeature.ValvePositionable`.
+* Only hides when the device truly has no valve cap.
+*/
+export declare function ValveHeroCard({ trpc, deviceId, features, optimistic }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/water-heater-control.d.ts

@@ -1,41 +1,58 @@
-import { ReactNode } from 'react';
-import { DeviceControlProps } from './control-registry';
+/**
+* Water-heater controls for a `DeviceType.WaterHeater` device.
+*
+* Reads the `water-heater` cap status slice (current / target temp /
+* operation mode / away / bounds) and renders:
+*   - WaterHeaterInlineControl (device-list row): a compact
+*     `current°→target°` readout + a tiny mode hint. Row-narrow.
+*   - WaterHeaterHeroCard (device-detail hero): a bespoke state-tinted
+*     tank / boiler SVG (water fill + heating-element glow when actively
+*     heating) in the framed-box language, a target-temp stepper with
+*     min/max clamp, an operation-mode `<select>`, an "Away" toggle
+*     (only when `away !== null`), and the current-temp readout.
+*
+* Mirrors the climate / valve controls' `useDeviceCapability` +
+* `useOptimisticSlice` pattern. Controls are gated on `available`. The
+* decorative SVG is aria-hidden.
+*/
+import { type ReactNode } from "react";
+import type { DeviceControlProps } from "./control-registry";
 /** Heating phase derived from the slice — drives the tank tint + element glow. */
-export type WaterHeaterPhase = 'heating' | 'idle' | 'off';
+export type WaterHeaterPhase = "heating" | "idle" | "off";
 export interface WaterHeaterTint {
-    /** Tailwind class for the wash behind the tank. */
-    readonly glow: string;
-    /** Tailwind text token driving the tank via currentColor. */
-    readonly accent: string;
-    /** Whether to render the heating-element glow. */
-    readonly heating: boolean;
+	/** Tailwind class for the wash behind the tank. */
+	readonly glow: string;
+	/** Tailwind text token driving the tank via currentColor. */
+	readonly accent: string;
+	/** Whether to render the heating-element glow. */
+	readonly heating: boolean;
 }
 /**
- * Pure helper — maps a phase to a tint. Exhaustive over WaterHeaterPhase
- * (a new member fails the build).
- *
- *   heating → warning (element glow)
- *   idle    → primary (warm but settled)
- *   off     → muted
- */
+* Pure helper — maps a phase to a tint. Exhaustive over WaterHeaterPhase
+* (a new member fails the build).
+*
+*   heating → warning (element glow)
+*   idle    → primary (warm but settled)
+*   off     → muted
+*/
 export declare function waterHeaterTint(phase: WaterHeaterPhase): WaterHeaterTint;
 /**
- * Heuristic heating phase: off when the operation mode is 'off' (or null);
- * heating when current < target (actively warming); otherwise idle.
- */
+* Heuristic heating phase: off when the operation mode is 'off' (or null);
+* heating when current < target (actively warming); otherwise idle.
+*/
 export declare function waterHeaterPhase(operationMode: string | null, currentTemp: number | null, targetTemp: number | null): WaterHeaterPhase;
 /**
- * WaterHeaterInlineControl — compact current→target readout + mode hint
- * for a device-list row. Must NOT blow out the row width.
- */
-export declare function WaterHeaterInlineControl({ trpc, deviceId, optimistic, }: DeviceControlProps): ReactNode;
+* WaterHeaterInlineControl — compact current→target readout + mode hint
+* for a device-list row. Must NOT blow out the row width.
+*/
+export declare function WaterHeaterInlineControl({ trpc, deviceId, optimistic }: DeviceControlProps): ReactNode;
 /**
- * WaterHeaterHeroCard — full control surface for the device-detail hero.
- *
- * Bespoke tank graphic + a large current-temp readout + a target-temp
- * stepper (clamped to min/maxTemp) + an operation-mode `<select>` + an
- * "Away" toggle (only when `away !== null`) + the current-temp readout.
- * Gated on `available`. Only hides when the device truly has no
- * water-heater cap.
- */
+* WaterHeaterHeroCard — full control surface for the device-detail hero.
+*
+* Bespoke tank graphic + a large current-temp readout + a target-temp
+* stepper (clamped to min/maxTemp) + an operation-mode `<select>` + an
+* "Away" toggle (only when `away !== null`) + the current-temp readout.
+* Gated on `available`. Only hides when the device truly has no
+* water-heater cap.
+*/
 export declare function WaterHeaterHeroCard({ trpc, deviceId, optimistic }: DeviceControlProps): ReactNode;