@camstack/ui-library 0.1.57 → 0.2.0

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

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+import { DeviceControlProps } from './control-registry';
+/**
+ * MediaPlayerHeroCard — now-playing hero for MediaPlayer devices.
+ *
+ * Renders (Spec §3):
+ *  - Now-playing block: cover glyph + title + artist/album.
+ *  - Seek GripTrack with a native range overlay (gated on DeviceFeature
+ *    MediaPlayerSeek + a known duration).
+ *  - Transport row: SkipBack / Play-Pause / SkipForward (lucide icons). Skip
+ *    buttons are gated on MediaPlayerPrevious / MediaPlayerNext.
+ *  - Volume GripTrack with a native range overlay + mute toggle (gated on a
+ *    non-null volume surface + DeviceFeature.MediaPlayerVolume).
+ *
+ * Cap-gated on `media-player` — returns null when the device lacks the cap.
+ */
+export declare function MediaPlayerHeroCard({ trpc, deviceId, features, optimistic, }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/media-player-panel.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+import { ControlPanelProps } from './types.js';
+import { MediaPlayerState } from '@camstack/types';
+/**
+ * Exhaustive colour map — one entry per MediaPlayerState.
+ * Build fails if a state is added and not reflected here.
+ */
+export declare const STATE_COLOR: Record<MediaPlayerState, string>;
+export declare function MediaPlayerPanel({ trpc, deviceId, features: _features, layout, optimistic, }: ControlPanelProps): ReactNode;

package/dist/composites/device-controls/offline-badge.d.ts

@@ -0,0 +1,11 @@
+import { ReactElement } from 'react';
+export interface OfflineBadgeProps {
+    /**
+     * Ms epoch of the last online→offline transition (device-status
+     * `lastChangedAt`). `null`/`undefined`/non-positive → no "last seen"
+     * suffix is shown.
+     */
+    readonly lastChangedAt?: number | null;
+    readonly className?: string;
+}
+export declare function OfflineBadge({ lastChangedAt, className }: OfflineBadgeProps): ReactElement;

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

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+import { DeviceControlProps } from './control-registry';
+export { ThermostatHeroCard } from './thermostat-hero-card';
+export { LockHeroCard } from './lock-hero-card';
+export { LightHeroCard } from './light-hero-card';
+export { FanHeroCard } from './fan-hero-card';
+export { SwitchHeroCard } from './switch-hero-card';
+export { MediaPlayerHeroCard } from './media-player-hero-card';
+export { AlarmHeroCard, AlarmInlineControl as AlarmPanelInlineControl } from './alarm-hero-card';
+export declare function SwitchInlineControl({ trpc, deviceId, features, optimistic, }: DeviceControlProps): ReactNode;
+export declare function LockInlineControl({ trpc, deviceId, features, optimistic, }: DeviceControlProps): ReactNode;
+export declare function LightInlineControl({ trpc, deviceId, features, optimistic, }: DeviceControlProps): ReactNode;
+export declare function FanInlineControl({ trpc, deviceId, features, optimistic, }: DeviceControlProps): ReactNode;
+export declare function ThermostatInlineControl({ trpc, deviceId, features, optimistic, }: DeviceControlProps): ReactNode;
+export declare function MediaPlayerInlineControl({ trpc, deviceId, features, optimistic, }: DeviceControlProps): ReactNode;
+export declare function ControlInlineControl({ trpc, deviceId, features, optimistic, }: DeviceControlProps): ReactNode;
+export declare function ControlHeroCard({ trpc, deviceId, features, optimistic, }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/popover-row-action.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+import { LucideIcon } from 'lucide-react';
+interface PopoverRowActionProps {
+    readonly icon: LucideIcon;
+    readonly title: string;
+    readonly children: ReactNode;
+}
+export declare function PopoverRowAction({ icon: Icon, title, children, }: PopoverRowActionProps): ReactNode;
+export {};

package/dist/composites/device-controls/primary-child.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Pure resolver: given a container's entity-children and an optional picker
+ * override (stored as an entityId string, re-sync-stable), returns the child
+ * that should be rendered as the container's PRIMARY child.
+ *
+ * Design note: ChildRef.type is kept as `string` (not `DeviceType`) to decouple
+ * this pure resolver from the types enum. The resolver is tolerant of unknown
+ * type names — they sort after all known PRIORITY entries. This avoids creating
+ * a hard import dependency between the resolver and the enum, and handles future
+ * entity types gracefully.
+ */
+export declare const PRIORITY: readonly string[];
+export interface ChildRef {
+    readonly id: number;
+    readonly entityId: string;
+    readonly type: string;
+}
+export declare function resolvePrimaryChild(children: readonly ChildRef[], overrideEntityId: string | undefined): ChildRef | null;

package/dist/composites/device-controls/radial-gauge.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from 'react';
+export interface RadialGaugeProps {
+    /** Fill fraction 0..1 (brightness or speed level). */
+    readonly fraction: number;
+    /** Hex/CSS colour for the fill arc + knob border. */
+    readonly color: string;
+    /** Centered content (icon + value readout). */
+    readonly children: ReactNode;
+    /**
+     * When provided, the ArcKnob becomes draggable: dragging it reports the new
+     * arc fraction (0..1) to the parent, which owns the value and re-renders the
+     * gauge at the new `fraction`. When omitted the knob is display-only.
+     */
+    readonly onDragFraction?: (fraction: number) => void;
+}
+/**
+ * Circular gauge with an ArcKnob at `fraction` and centered children.
+ * The knob wrapper carries `data-testid="arc-knob"` for test assertions.
+ */
+export declare function RadialGauge({ fraction, color, children, onDragFraction, }: RadialGaugeProps): ReactNode;

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

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { DeviceControlProps } from './control-registry';
+/**
+ * SensorHeroCard — full hero card for the device-detail area.
+ *
+ * Fetches the device row (name, role, sourceInfo) via React Query
+ * (`deviceManager.getDevice`), then delegates rendering to the inner
+ * component that reads the live state slice via the proxy.
+ */
+export declare function SensorHeroCard({ trpc, deviceId }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/sensor-inline-control.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { DeviceControlProps } from './control-registry';
+/**
+ * Registry InlineControl for Sensor and Presence device types.
+ *
+ * Fetches the device row once (React Query cache — no waterfall for
+ * repeated renders), maps to DeviceItemDevice, and delegates rendering
+ * to the existing SensorValueAtom so both the row special-case path and
+ * the registry path stay in sync.
+ */
+export declare function SensorInlineControl({ trpc, deviceId }: DeviceControlProps): ReactNode;

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

@@ -0,0 +1,106 @@
+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';
+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>;
+}
+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>;
+}
+interface PresenceDescriptor {
+    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.
+ */
+interface StringDescriptor {
+    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').
+ */
+interface DateTimeDescriptor {
+    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).
+ */
+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.
+ */
+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.
+ */
+export declare const ROLE_DESCRIPTOR: Record<string, SensorDescriptor>;
+export interface StringSliceValue {
+    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.
+ */
+export declare function readSliceDateTimeFormat(slice: unknown): ControlDateTimeFormat | undefined;
+export interface SensorValueAtomProps {
+    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

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { 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.
+ */
+export declare function SwitchHeroCard({ trpc, deviceId, optimistic }: DeviceControlProps): ReactNode;

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

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

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

@@ -0,0 +1,17 @@
+import { 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.
+ */
+export interface TapToggleProps {
+    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

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+import { 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;

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

@@ -0,0 +1,17 @@
+import { 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). */
+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;
+}
+/** 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. */
+export declare const CONTROL_CAP_NAMES: readonly ["cover", "lock-control", "switch", "brightness", "fan-control", "climate-control", "media-player", "control"];
+export type ControlCapName = (typeof CONTROL_CAP_NAMES)[number];

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

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { 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.
+ */
+export declare function UpdateHeroCard({ trpc, deviceId }: DeviceControlProps): ReactNode;

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

@@ -0,0 +1,36 @@
+import { ReactNode } from 'react';
+import { VacuumState, TankStatus } from '@camstack/types';
+import { DeviceControlProps } from './control-registry';
+export interface VacuumStateMeta {
+    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.
+ */
+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';
+/**
+ * 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.
+ */
+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.
+ */
+export declare function VacuumHeroCard({ trpc, deviceId }: DeviceControlProps): ReactNode;

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

@@ -0,0 +1,46 @@
+import { ReactNode } from 'react';
+import { ValveState } from '@camstack/types';
+import { DeviceControlProps } from './control-registry';
+export interface ValveStateMeta {
+    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.
+ */
+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.
+ */
+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;
+}
+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;

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

@@ -0,0 +1,41 @@
+import { ReactNode } from 'react';
+import { DeviceControlProps } from './control-registry';
+/** Heating phase derived from the slice — drives the tank tint + element glow. */
+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;
+}
+/**
+ * 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.
+ */
+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;
+/**
+ * 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;

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

@@ -0,0 +1,41 @@
+import { ReactNode } from 'react';
+import { DeviceControlProps } from './control-registry';
+/** Which sky glyph a condition maps to. Drives both the inline icon and
+ *  the hero scene's graphic branch. */
+export type WeatherGlyph = 'sun' | 'clear-night' | 'partly-cloudy' | 'cloudy' | 'rain' | 'snow' | 'lightning' | 'fog' | 'wind' | 'hail';
+export interface WeatherConditionMeta {
+    /** Human-readable label for the condition. */
+    readonly label: string;
+    /** Which glyph to render. */
+    readonly glyph: WeatherGlyph;
+}
+export interface WeatherTint {
+    /** Tailwind class for the wash behind the scene. */
+    readonly glow: string;
+    /** Tailwind text token driving the scene glyph via currentColor. */
+    readonly accent: string;
+}
+/**
+ * Pure helper — maps a verbatim HA condition string to a label + glyph.
+ * Covers the known HA `weather.*` condition set; an unknown / null
+ * condition falls back to a neutral cloud.
+ */
+export declare function weatherConditionMeta(condition: string | null): WeatherConditionMeta;
+/**
+ * Pure helper — maps a verbatim HA condition string to a tint. Exhaustive
+ * over the known condition set with a neutral default.
+ */
+export declare function weatherTint(condition: string | null): WeatherTint;
+/**
+ * WeatherInlineControl — compact condition icon + temperature readout
+ * for a device-list row. Read-only; must NOT blow out the row width.
+ */
+export declare function WeatherInlineControl({ trpc, deviceId }: DeviceControlProps): ReactNode;
+/**
+ * WeatherHeroCard — read-only weather panel for the device-detail hero.
+ *
+ * Bespoke state-tinted sky scene + a large temperature readout +
+ * humidity / wind-speed (with a bearing arrow) / pressure readouts.
+ * Pure — no controls (the cap is read-only).
+ */
+export declare function WeatherHeroCard({ trpc, deviceId }: DeviceControlProps): ReactNode;

package/dist/composites/device-export-panel.d.ts

@@ -20,4 +20,4 @@ export interface DeviceExportPanelProps {
  * Generic device-export panel. Addon-agnostic — only the `device-export`
  * cap drives it.
  */
-export declare function DeviceExportPanel({ addonId, trpc, onOpenDevice }: DeviceExportPanelProps): ReactElement;
+export declare function DeviceExportPanel({ addonId, trpc, onOpenDevice, }: DeviceExportPanelProps): ReactElement;

package/dist/composites/device-grid.d.ts

@@ -9,4 +9,4 @@ export interface DeviceGridProps {
     /** Additional CSS classes */
     className?: string;
 }
-export declare function DeviceGrid({ children, minCardWidth, gap, className, }: DeviceGridProps): import("react/jsx-runtime").JSX.Element;
+export declare function DeviceGrid({ children, minCardWidth, gap, className }: DeviceGridProps): import("react").JSX.Element;

package/dist/composites/device-item/actions.d.ts

@@ -1,9 +1,20 @@
 import { ReactNode } from 'react';
 import { UseDeviceProxyTrpc } from '../../hooks/use-device-proxy';
+import { ControlPlacement } from '../device-controls/control-registry';
 import { DeviceItemDevice, VariantDefaults } from './helpers';
 export interface DeviceItemActionsProps {
     readonly trpc: UseDeviceProxyTrpc;
     readonly device: DeviceItemDevice;
     readonly flags: VariantDefaults;
+    /**
+     * Where the control sits and whether the column carries the fixed `w-[140px]`
+     * box. `'right'` (default) → flush right in the fixed column, for card /
+     * minimal views. `'center'` → centered in the fixed column. `'table'` → the
+     * column sizes to its content (no fixed width) so a wide control lays out in
+     * sequence with the trailing trash + status dot without overflowing/colliding
+     * — used by the main devices table. FILL controls stretch to the fixed column
+     * width under `'right'`/`'center'`; under `'table'` they take natural width.
+     */
+    readonly controlPlacement?: ControlPlacement;
 }
-export declare function DeviceItemActions({ trpc, device, flags }: DeviceItemActionsProps): ReactNode;
+export declare function DeviceItemActions({ trpc, device, controlPlacement, }: DeviceItemActionsProps): ReactNode;

package/dist/composites/device-item/child-layout.d.ts

@@ -0,0 +1,32 @@
+import { ChildLayout } from '@camstack/types';
+import { DeviceItemDevice } from './helpers';
+export interface ChildLayoutSection {
+    readonly title: string;
+    readonly children: readonly DeviceItemDevice[];
+    /** Whether the section renders open by default. `false` when any matched
+     *  layout entry for this section declared `collapsed: true`. */
+    readonly defaultOpen: boolean;
+    /** When `true`, the section's children render visually de-emphasized
+     *  (muted). Set only on the synthetic "Disabled" section. */
+    readonly muted?: boolean;
+}
+export interface GroupedChildren {
+    /** Sections ordered by first appearance in `childLayout`. */
+    readonly sections: readonly ChildLayoutSection[];
+    /** Children not referenced by any layout entry — render plainly, as today. */
+    readonly ungrouped: readonly DeviceItemDevice[];
+    /** Trailing synthetic section gathering every child whose CamStack-side
+     *  `disabled` flag is set. Kept SEPARATE from `sections`/`ungrouped` so
+     *  consumers render it LAST (after provider sections + ungrouped) and
+     *  muted. Undefined when no child is disabled. Generic — driven purely by
+     *  `child.disabled`, no provider/HA-specific input. */
+    readonly disabledSection?: ChildLayoutSection;
+}
+/**
+ * Partition a parent's children into provider-declared accordion sections +
+ * the remaining (ungrouped) children. A child matches an entry when
+ * `child.stableId === ${parentStableId}-${entry.childKey}`. Within a section,
+ * children sort by `order ?? Number.MAX_SAFE_INTEGER` then by name. Sections
+ * appear in first-seen order across `childLayout`. Pure — no I/O.
+ */
+export declare function groupChildrenByLayout(parentStableId: string, children: readonly DeviceItemDevice[], childLayout: ChildLayout | undefined): GroupedChildren;

package/dist/composites/device-item/child-section-accordion.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+interface ChildSectionAccordionProps {
+    readonly title: string;
+    readonly count: number;
+    readonly children: ReactNode;
+    readonly defaultOpen?: boolean;
+}
+export declare function ChildSectionAccordion({ title, count, children, defaultOpen, }: ChildSectionAccordionProps): ReactNode;
+export {};

package/dist/composites/device-item/children-accordion.d.ts

@@ -7,5 +7,5 @@ interface ChildrenAccordionProps {
     readonly adoptedChildren: readonly DeviceItemDevice[];
     readonly onNavigate: (id: number) => void;
 }
-export declare function ChildrenAccordion({ trpc, accessoryChildren, adoptedChildren, onNavigate }: ChildrenAccordionProps): ReactNode;
+export declare function ChildrenAccordion({ trpc, accessoryChildren, adoptedChildren, onNavigate, }: ChildrenAccordionProps): ReactNode;
 export {};

package/dist/composites/device-item/container-children-context.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { DeviceItemDevice } from './helpers';
+export interface ContainerChildrenProviderProps {
+    /** `parentDeviceId → that parent's children`. Built once by the list. */
+    readonly value: ReadonlyMap<number, readonly DeviceItemDevice[]>;
+    readonly children: ReactNode;
+}
+export declare function ContainerChildrenProvider({ value, children, }: ContainerChildrenProviderProps): ReactNode;
+/**
+ * The children of `deviceId` as published by the nearest
+ * `ContainerChildrenProvider`. Returns a stable empty array when there is no
+ * provider or the device has no children — so a non-container row, or a row
+ * rendered outside a list, degrades exactly like the old optional prop.
+ */
+export declare function useContainerChildren(deviceId: number): readonly DeviceItemDevice[];

package/dist/composites/device-item/device-delete-action.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+import { DeviceItemDevice } from './helpers';
+export interface DeviceDeleteActionProps {
+    readonly device: DeviceItemDevice;
+    /** Called only after the operator confirms the destructive delete. */
+    readonly onDelete: (device: DeviceItemDevice) => void;
+}
+export declare function DeviceDeleteAction({ device, onDelete }: DeviceDeleteActionProps): ReactNode;

package/dist/composites/device-item/header.d.ts

@@ -10,5 +10,12 @@ export interface DeviceItemHeaderProps {
     readonly expanded: boolean;
     readonly onToggleExpand: () => void;
     readonly onNavigateToParent: (id: number) => void;
+    /**
+     * Vertical-card layout. When true, the name is rendered as the card's
+     * primary anchor: bigger font, heavier weight, line-clamp-2 instead of
+     * single-line truncation, and the inline integrationIcon flips above
+     * the name as a small lead-line so the name's full width is name-only.
+     */
+    readonly stacked?: boolean;
 }
-export declare function DeviceItemHeader({ device, variant, flags, parent, integrationIcon, hasChildren, expanded, onToggleExpand, onNavigateToParent, }: DeviceItemHeaderProps): ReactNode;
+export declare function DeviceItemHeader({ device, variant, flags, parent, integrationIcon, hasChildren, expanded, onToggleExpand, onNavigateToParent, stacked, }: DeviceItemHeaderProps): ReactNode;